api_recipes 0.7.1 → 2.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfd5a3d85babd54baa4d9001c52362cc5dfff4421cf3f9e7a2417e78b3f5eb2b
-  data.tar.gz: 316bd1cefa28669906a4e87a56ef7e64ed14369cf2099262ad5ed85fa0544b05
+  metadata.gz: 2ce6553d9d7e1e72dca69781d977310670ac25a3c88b39a974b3b4d5865c0f0f
+  data.tar.gz: '08ff597bfc3b86e31d4f7d467cf7b0a7f67bd5d08783d9b901ce15f05e0f85ac'
 SHA512:
-  metadata.gz: 28bd374672f163b8912794f12e33bbaaa9168f03940651dda9fba2bb88899b5202ea51cace5ed0a814508eef4dcbb195ac32826590c12d1e5d91a31f66a93d84
-  data.tar.gz: 0bbb7e6ec0b1f02254449edfb03731b05927e5ac3bdc51a3fc2c2a89ae8ccbe79238f70ebe022978611ca4e49a0e9b1b95c96a3c4977360f36686424371b492e
+  metadata.gz: ddfbfdedaba0d774e87c868836f22e493bd0e336e015fa0907939d57756bc6f93b7540836887ea194ef27041b2c4848ccff258b69a9eb59142d591951bfe5827
+  data.tar.gz: ebca5a942daeb2d98522bb8fc811e1f0ad4b0916e6299a7bf7b6ad3c1b549d3ef28a1ebfe4cbdaf51103513578b97fd4732e730608174b356fafe8ef58a993a1

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

@@ -1,59 +1,59 @@
 require 'http'
-require 'oj'
 
 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
-        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]
-            ep = Endpoint.new(endpoint_name, configs)
-            ApiRecipes.copy_global_authorizations_to_endpoint ep
-            ApiRecipes._aprcps_thread_storage[endpoint_name][self.class] = ep
-          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)
+          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]
-            ep = Endpoint.new(endpoint_name, configs)
-            ApiRecipes.copy_global_authorizations_to_endpoint ep
-            ApiRecipes._aprcps_thread_storage[endpoint_name][self] = ep
-          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)
+          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
@@ -69,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
+      define_singleton_method api_name do
+        _aprcps_global_storage[api_name]
       end
     end
   end
@@ -126,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
@@ -142,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,70 @@
+module ApiRecipes
+  class Api
+
+    attr_accessor :name, :configs, :authorization, :basic_auth
+    attr_reader :base_configs
+
+    BASE_CONFIGS_KEYS = [:protocol, :host, :port, :api_version, :timeout, :on_bad_code]
+
+    def initialize(name, configs)
+      @name = name
+      @configs = ApiRecipes::Settings::DEFAULT.merge configs
+
+      # 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,130 @@
 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)
+    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|
+          # 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 authorization=(auth)
-      @authorization = auth
-
-      # 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 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 basic_auth=(auth)
-      @basic_auth = 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_basic_auth_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
 
-    private
+    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
+
+    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
 
-    def global?
-      ApiRecipes._aprcps_global_storage[name] == self
+    def required_params_for_path
+      absolute_path.scan(/:(\w+)/).flatten.map { |p| p.to_sym }
     end
   end
 end