api_recipes 1.0.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc2b26e8c66139a2ff051ef066bb512b389a48bcbfa2ba2b391f1dc29719426d
-  data.tar.gz: 281afb372a91edac6bbc1bc6335da2fb413e856ed7f32cff476f9c527d4dc459
+  metadata.gz: 8ac0841819d455adb4d85f88d7858e33cfaa17bf35316811f5a6d7c75879b271
+  data.tar.gz: ddacdca3095b42cdc14c51e066a52d237c85dfc0ba79419342168d7667f0b12e
 SHA512:
-  metadata.gz: 610ff709c864f8cb71f29f42a0a50cd75318e0ce184801f8aa40102d35301b937afdd1c3a56381f783e405763aad2ac4886205809c2b26a07d73a9433e368c81
-  data.tar.gz: a3a0cd7ac6a1b7aaea7fe3f5989d4e1c7b071f6d7b18ffc99b4fbff56689114407310f37e459cee183a56b78529f51fe39b59712b4dc5cbd31577fc7e451b2b7
+  metadata.gz: ec9f37f976b33f9386b4f201f4200ce33fdc526510f31984b591823c093c187037c7c8fc6c967fd33094b41f5343b4810ae251a89d3a9922e55b565f7f648503
+  data.tar.gz: 4c2f41152de95562744e8b60e8d14ca4adbbd4a88487d89f52149ba9bfd6b9bff3bf830bedc1aee9c59787e541ad5386d151baea552b11e7c63a8eac1e795b85

data/README.md

@@ -28,7 +28,7 @@ Or install it yourself as:
     
 ## Compatibility
 
-Ruby 1.9.3 or higher.
+Ruby 2.5.0 or higher.
 
 ## Usage
 
@@ -38,7 +38,7 @@ In the meantime take a look at the ``` examples ``` folder. Thank you.
 
 ## TODO
 
-* Write specs (I know... this code has been wrote down on a hurry so please do not beat me)
+* Re-write specs
 * Write a good Usage
 * Add more examples
 * Add documentation

data/lib/api_recipes.rb

@@ -3,56 +3,57 @@ require 'http'
 require 'api_recipes/utils'
 require 'api_recipes/exceptions'
 require 'api_recipes/configuration'
-require 'api_recipes/resource'
+require 'api_recipes/route'
 require 'api_recipes/endpoint'
+require 'api_recipes/api'
 require 'api_recipes/response'
 require 'api_recipes/settings'
 
+# TODO: Sistema i default nelle config
+
 module ApiRecipes
 
   def self.included(receiver)
 
-    def receiver.endpoint(endpoint_name, configs = {})
-      unless endpoint_name.is_a?(String) || endpoint_name.is_a?(Symbol)
-        raise ArgumentError, "endpoint name must be a Symbol or String"
+    def receiver.api(api_name, configs = {})
+      unless api_name.is_a?(String) || api_name.is_a?(Symbol)
+        raise ArgumentError, "api name must be a Symbol or String"
       end
 
       if configs && !configs.is_a?(Hash)
-        raise ApiRecipes::EndpointConfigIsNotAnHash.new(endpoint_name)
+        raise ApiRecipes::ApiConfigIsNotAnHash.new(api_name)
       end
 
-      endpoint_name = endpoint_name.to_sym
-      configs = ApiRecipes._aprcps_merge_endpoints_configs(endpoint_name, configs.deep_symbolize_keys)
-      if self.respond_to? endpoint_name
-        raise EndpointNameClashError.new(self, endpoint_name)
+      api_name = api_name.to_sym
+      # configs = ApiRecipes._aprcps_merge_apis_configs(api_name, configs.deep_symbolize_keys)
+      if self.respond_to? api_name
+        raise ApiNameClashError.new(self, api_name)
       else
-        ep = Endpoint.new(endpoint_name, configs)
-        ApiRecipes.copy_global_authorizations_to_endpoint ep
-        ApiRecipes._aprcps_thread_storage[endpoint_name] = {}
-        ApiRecipes._aprcps_thread_storage[endpoint_name][self] = ep
-
-        define_method endpoint_name do
-          unless ApiRecipes._aprcps_thread_storage[endpoint_name]
-            ApiRecipes._aprcps_thread_storage[endpoint_name] = {}
-          end
-          unless ApiRecipes._aprcps_thread_storage[endpoint_name][self.class]
-            ApiRecipes._aprcps_thread_storage[endpoint_name][self.class] = ep.clone
-          end
-          ApiRecipes._aprcps_thread_storage[endpoint_name][self.class]
+
+        define_method api_name do
+          configs = ApiRecipes._aprcps_merge_apis_configs(api_name, configs.deep_symbolize_keys)
+          api = Api.new(api_name, configs, self)
+          ApiRecipes.copy_global_authorizations_to_api api
+          api
         end
-        define_singleton_method endpoint_name do
-          unless ApiRecipes._aprcps_thread_storage[endpoint_name]
-            ApiRecipes._aprcps_thread_storage[endpoint_name] = {}
-          end
-          unless ApiRecipes._aprcps_thread_storage[endpoint_name][self]
-            ApiRecipes._aprcps_thread_storage[endpoint_name][self] = ep.clone
-          end
-          ApiRecipes._aprcps_thread_storage[endpoint_name][self]
+        define_singleton_method api_name do
+          configs = ApiRecipes._aprcps_merge_apis_configs(api_name, configs.deep_symbolize_keys)
+          api = Api.new(api_name, configs, self)
+          ApiRecipes.copy_global_authorizations_to_api api
+          api
         end
       end
     end
   end
 
+  def self.print_urls=(value)
+    @print_urls = value
+  end
+
+  def self.print_urls
+    @print_urls || false
+  end
+
   def self.configuration
     unless @configuration
       @configuration = Configuration.new
@@ -68,45 +69,45 @@ module ApiRecipes
     end
   end
 
-  def self.copy_global_authorizations_to_endpoint(endpoint)
-    if _aprcps_global_storage[endpoint.name]
-      if auth = _aprcps_global_storage[endpoint.name].basic_auth
-        endpoint.authorization = auth
+  def self.copy_global_authorizations_to_api(api)
+    if _aprcps_global_storage[api.name]
+      if auth = _aprcps_global_storage[api.name].basic_auth
+        api.basic_auth = auth
       end
-      if auth = _aprcps_global_storage[endpoint.name].authorization
-        endpoint.authorization = auth
+      if auth = _aprcps_global_storage[api.name].authorization
+        api.authorization = auth
       end
     end
   end
 
-  def self.set_authorization_for_endpoint(authorization, endpoint_name)
-    endpoint_name = endpoint_name.to_sym
+  def self.set_authorization_for_api(authorization, api_name)
+    api_name = api_name.to_sym
 
     # Set authorization on thread storage
-    if _aprcps_thread_storage[endpoint_name]
-      _aprcps_thread_storage[endpoint_name].each do |_, endpoint|
-        endpoint.authorization = authorization
+    if _aprcps_thread_storage[api_name]
+      _aprcps_thread_storage[api_name].each do |_, api|
+        api.authorization = authorization
       end
     end
   end
 
-  def self.set_basic_auth_for_endpoint(basic_auth, endpoint_name)
-    endpoint_name = endpoint_name.to_sym
+  def self.set_basic_auth_for_api(basic_auth, api_name)
+    api_name = api_name.to_sym
 
     # Set authorization on thread storage
-    if _aprcps_thread_storage[endpoint_name]
-      _aprcps_thread_storage[endpoint_name].each do |_, endpoint|
-        endpoint.authorization = basic_auth
+    if _aprcps_thread_storage[api_name]
+      _aprcps_thread_storage[api_name].each do |_, api|
+        api.authorization = basic_auth
       end
     end
   end
 
-  def self._aprcps_define_global_endpoints
-    configuration.endpoints_configs.each do |endpoint_name, endpoint_configs|
-      endpoint_name = endpoint_name.to_sym
-      _aprcps_global_storage[endpoint_name] = Endpoint.new endpoint_name, endpoint_configs
-      define_singleton_method endpoint_name do
-        _aprcps_global_storage[endpoint_name]
+  def self._aprcps_define_global_apis
+    configuration.apis_configs.each do |api_name, api_configs|
+      api_name = api_name.to_sym
+      _aprcps_global_storage[api_name] = Api.new api_name, api_configs, self
+      define_singleton_method api_name do
+        _aprcps_global_storage[api_name]
       end
     end
   end
@@ -125,15 +126,15 @@ module ApiRecipes
     Thread.current[:api_recipes]
   end
 
-  def self._aprcps_merge_endpoints_configs(endpoint_name, configs = nil)
-    unless endpoint_name.is_a?(String) || endpoint_name.is_a?(Symbol)
-      raise ArgumentError, "no enpoint_name provided. Given: #{endpoint_name.inspect}"
+  def self._aprcps_merge_apis_configs(api_name, configs = nil)
+    unless api_name.is_a?(String) || api_name.is_a?(Symbol)
+      raise ArgumentError, "no api_name provided. Given: #{api_name.inspect}"
     end
-    unless ApiRecipes.configuration.endpoints_configs[endpoint_name]
-      ApiRecipes.configuration.endpoints_configs[endpoint_name] = {}
+    unless ApiRecipes.configuration.apis_configs[api_name]
+      ApiRecipes.configuration.apis_configs[api_name] = {}
     end
     if configs
-      ApiRecipes.configuration.endpoints_configs[endpoint_name].merge(configs) do |_, old_val, new_val|
+      ApiRecipes.configuration.apis_configs[api_name].merge(configs) do |_, old_val, new_val|
         if new_val.nil?
           old_val
         else
@@ -141,7 +142,7 @@ module ApiRecipes
         end
       end
     else
-      ApiRecipes.configuration.endpoints_configs[endpoint_name]
+      ApiRecipes.configuration.apis_configs[api_name]
     end
   end
 end

data/lib/api_recipes/api.rb

@@ -0,0 +1,71 @@
+module ApiRecipes
+  class Api
+
+    attr_accessor :name, :configs, :authorization, :basic_auth
+    attr_reader :base_configs, :object
+
+    BASE_CONFIGS_KEYS = [:protocol, :host, :port, :api_version, :timeout, :on_bad_code, :verify_with]
+
+    def initialize(name, configs, object)
+      @name = name
+      @configs = ApiRecipes::Settings::DEFAULT.merge configs
+      @object = object
+
+      # Generate   some_api.some_endpoint  methods
+      # e.g.  github.users
+      endpoints = @configs[:endpoints]
+      if endpoints && endpoints.is_a?(Hash)
+        endpoints.each do |ep_name, params|
+          unless respond_to? ep_name
+            # TODO: store endpoints, routes and routes_urls
+            define_singleton_method ep_name do |*request_params, &block|
+              # puts "API params: #{params}"
+              Endpoint.new api: self, name: ep_name, path: path, params: params, request_params: request_params, &block
+            end
+          end
+        end
+      end
+    end
+
+    def authorization=(auth)
+      @authorization = auth
+
+      # Check if I'm the global api
+      if global?
+        # Set authorization also on every "children" (classes that define the same api)
+        ApiRecipes.set_authorization_for_api auth, name
+      end
+    end
+
+    def basic_auth=(auth)
+      @basic_auth = auth
+
+      # Check if I'm the global api
+      if global?
+        # Set authorization also on every "children" (classes that define the same api)
+        ApiRecipes.set_basic_auth_for_api auth, name
+      end
+    end
+
+    def base_configs
+      @configs.select { |c| BASE_CONFIGS_KEYS.include? c }
+    end
+
+    private
+
+    def check_route_name_does_not_clash(route_name)
+      # Check if a method named route_name has already been defined on this object
+      if respond_to? route_name
+        raise RouteNameClashWithExistentMethod.new(@name, route_name)
+      end
+    end
+
+    def global?
+      ApiRecipes._aprcps_global_storage[name] == self
+    end
+
+    def path
+      "/#{configs[:base_url]}/"
+    end
+  end
+end

data/lib/api_recipes/configuration.rb

@@ -1,19 +1,19 @@
 module ApiRecipes
   class Configuration
 
-    attr_accessor :log_to, :log_level
+    attr_accessor :log_to, :log_level, :print_urls
 
-    def endpoints_configs=(configs = {})
-      raise ArgumentError, 'endpoints_configs must be an Hash' unless configs.is_a? Hash
-      @endpoints_configs = configs.deep_symbolize_keys
-      ApiRecipes._aprcps_define_global_endpoints
+    def apis_configs=(configs = {})
+      raise ArgumentError, 'apis_configs must be an Hash' unless configs.is_a? Hash
+      @apis_configs = configs.deep_symbolize_keys
+      ApiRecipes._aprcps_define_global_apis
     end
 
-    def endpoints_configs
-      unless @endpoints_configs
-        @endpoints_configs = {}
+    def apis_configs
+      unless @apis_configs
+        @apis_configs = {}
       end
-      @endpoints_configs
+      @apis_configs
     end
 
     def logger=(logger)

data/lib/api_recipes/endpoint.rb

@@ -1,51 +1,137 @@
 module ApiRecipes
   class Endpoint
 
-    attr_accessor :name, :configs, :authorization, :basic_auth
-    attr_reader :resources
+    attr_reader :api, :name, :params, :route, :children
 
-    def initialize(name, configs)
+    FORWARDABLE_PARAMS = %i[verify_with].freeze
+
+    def initialize(api: nil, name: nil, path: nil, params: {}, request_params: [], &block)
+      @api = api
       @name = name
-      @configs = ApiRecipes::Settings::DEFAULT.merge configs
-
-      # Generate   some_endpoint.some_resource  methods
-      # e.g.  github.users
-      @resources = [] unless @resources
-      @configs[:routes].each do |resource, routes|
-        @resources << resource
-        res = Resource.new resource, self, routes
-        unless respond_to? resource
-          define_singleton_method resource do
-            res
+      @path = path.to_s
+      new_params = params.dup || {}
+      self.params = new_params
+      @children = new_params.delete :endpoints
+      @route = nil
+      @request_params = request_params.extract_options!
+      self.path_params = request_params
+
+      generate_route
+      generate_children
+      if block_given?
+        run &block
+      end
+    end
+
+    def run(&block)
+      if @route
+        @route.start_request &block
+      else
+        raise NoRouteExists.new @name
+      end
+    end
+
+    def url
+      @route.url
+    end
+
+    private
+
+    def generate_route
+      # Check if we have to generate route for this endpoint
+      if create_route?
+        ensure_route_does_not_clash @name
+        # Generate route
+        attrs = params.dup
+        attrs.delete(:endpoints)
+        # puts "Generating route '#{@name}' with path '#{build_path}'"
+        @route = Route.new(api: @api, endpoint: self, path: build_path, attributes: attrs, req_pars: @request_params)
+      end
+    end
+
+    def generate_children
+      # Generate children endpoints if any
+      # puts "generating children of #{@name}: #{children.inspect}"
+      if children
+        children.each do |ep_name, pars|
+          pars = forwardable_params.merge(pars) if pars
+          # TODO: Merge pars with params
+          # puts "Creating Endpoint '#{@name}' child '#{ep_name}' passing path #{build_path}"
+          define_singleton_method ep_name do |*request_params, &block|
+            Endpoint.new api: @api, name: ep_name, path: build_path, params: pars, request_params: request_params, &block
           end
         end
       end
+      # Route.new(api: @api, endpoint: self, name: route_name, attributes: route_attrs, req_pars: request_params).start_request &block
+    end
+
+    def ensure_route_does_not_clash(route_name)
+      # Check if a method named route_name has already been defined on this object
+      if respond_to? route_name
+        raise RouteNameClashWithExistentMethod.new(@name, route_name)
+      end
     end
 
-    def authorization=(auth)
-      @authorization = auth
+    def create_route?
+      res = params[:route].eql?('yes') || params[:route].eql?(true)
+      res
+    end
+
+    def absolute_path
+      # Append path passed to initialize and (params[:path] || @name)
+      append = params[:path] || @name
+      unless append.empty?
+        "#{@path}/#{append}"
+      else
+        "#{@path}"
+      end.gsub(/\/+/, '/')   # remove multiple consecutive '//'
+    end
 
-      # Check if I'm the global endpoint
-      if global?
-        # Set authorization also on every "children" (classes that define the same endpoint)
-        ApiRecipes.set_authorization_for_endpoint auth, name
+    def params=(attrs)
+      unless attrs.is_a? Hash
+        raise ArgumentError, "provided 'attrs' must be an Hash"
+      end
+      # Merge DEFAULT_ROUTE_ATTRIBUTES with Api base_configs
+      # Then merge the result with provided attributes
+      @params = Settings::DEFAULT_ROUTE_ATTRIBUTES.inject({}) do |out, key_val|
+        new_val = @api.base_configs[key_val.first]
+        out[key_val.first] = new_val.nil? ? key_val.last : new_val
+        out
+      end.inject({}) do |out, key_val|
+        new_val = attrs[key_val.first]
+        out[key_val.first] = new_val.nil? ? key_val.last : new_val
+        out
       end
     end
 
-    def basic_auth=(auth)
-      @basic_auth = auth
+    def build_path
+      final_path = absolute_path
+      # Check if provided path_params match with required path params
+      req_params = required_params_for_path
+      if @path_params.size != req_params.size
+        # puts "\nWARNING\n"
+        raise PathParamsMismatch.new(final_path, req_params, @path_params)
+      end
+      # Replace required_params present in path with params provided by user (@path_params)
+      @path_params.each { |par| final_path.sub! /(:[^\/]+)/, par.to_s }
+
+      final_path
+    end
 
-      # Check if I'm the global endpoint
-      if global?
-        # Set authorization also on every "children" (classes that define the same endpoint)
-        ApiRecipes.set_basic_auth_for_endpoint auth, name
+    def path_params=(params)
+      unless params.is_a? Array
+        raise ArgumentError, 'path params must be an Array'
       end
+      # Merge route attributes with defaults and deep clone route attributes
+      @path_params = params
     end
 
-    private
+    def required_params_for_path
+      absolute_path.scan(/:(\w+)/).flatten.map { |p| p.to_sym }
+    end
 
-    def global?
-      ApiRecipes._aprcps_global_storage[name] == self
+    def forwardable_params
+      params.select { |k, v| FORWARDABLE_PARAMS.include? k }
     end
   end
 end