api_recipes 0.6.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41b256b43696edaa5735f827046946ee0ee438ec69fc90387cfc3c9a841828b8
-  data.tar.gz: dcab748e71d294af415263f5e1c6a5c2c55374f782d34ec3e389069aaa132431
+  metadata.gz: febe7d307961dd407eae97ef0519280abf463e896f8a83471d3242b6f8a7b8a1
+  data.tar.gz: 15df723f847728e9c433223eef128069204aa15344856a4388847860c45304f2
 SHA512:
-  metadata.gz: 42963a27d5644ea0e1b6afc22f393cfe5f9db95a8d2bfa83beffaeca7ee8bd59995c227c124b1ab0df059b950d175a74175fa05bde1c8a88f01b294c514bc4ba
-  data.tar.gz: 0b5ea14d92e44fc67ea5b8af1d1debd654b43974c5b98c88c8ba45555567fb2980387a6fa5e2ed3dd9ff964b7981cd976c40005c65b3f51f6c181a60ac6f0607
+  metadata.gz: 94627389adf247362789b3213f6ec2f45c4443e43c4212ec1fffa96f4796c4de9c097288ef0d328d657c98eb8590fa6908e89f77f080c09be1b0cb0b9c7f44d9
+  data.tar.gz: a887790e2ac8c3ec7853d2a24735f6c79a7761287e76265854963e80f18320b63bb598365ba75fb316064ebf9c424569e09160f4dc3eb79ce4c09e6326e1972f

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,28 +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(base)
+  def self.included(receiver)
+
+    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::ApiConfigIsNotAnHash.new(api_name)
+      end
 
-    def base.endpoint(endpoint_name, configs = {})
-      configs = ApiRecipes._aprcps_merge_endpoints_configs(endpoint_name, configs.deep_symbolize_keys)
-      endpoint_name = endpoint_name.to_sym
+      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 'endpoint_name' method for the class
-      ApiRecipes._aprcps_define_class_endpoint endpoint_name, configs, self, true
-      # Define 'endpoint_name' method for the class' instances
-      ApiRecipes._aprcps_define_instance_endpoint endpoint_name, self
+        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 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
@@ -33,64 +64,86 @@ module ApiRecipes
   def self.configure
     if block_given?
       yield(configuration)
-      _aprcps_define_global_endpoints
     else
       configuration
     end
   end
 
-  def self._aprcps_define_global_endpoints
-    configuration.endpoints_configs.each do |endpoint_name, endpoint_configs|
-      unless method_defined? endpoint_name
-        unless _aprcps_storage[endpoint_name]
-          _aprcps_storage[endpoint_name] = Endpoint.new endpoint_name, endpoint_configs
-        end
-        define_singleton_method endpoint_name do
-          _aprcps_storage[endpoint_name]
-        end
+  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[api.name].authorization
+        api.authorization = auth
       end
     end
   end
 
-  def self._aprcps_storage
-    unless Thread.current[:api_recipes]
-      Thread.current[:api_recipes] = {}
+  def self.set_authorization_for_api(authorization, api_name)
+    api_name = api_name.to_sym
+
+    # Set authorization on thread storage
+    if _aprcps_thread_storage[api_name]
+      _aprcps_thread_storage[api_name].each do |_, api|
+        api.authorization = authorization
+      end
     end
-    Thread.current[:api_recipes]
   end
 
+  def self.set_basic_auth_for_api(basic_auth, api_name)
+    api_name = api_name.to_sym
 
-  def self._aprcps_define_class_endpoint(ep_name, configs, obj, overwrite)
-    unless obj.method_defined? ep_name
-      if overwrite
-        ep = Endpoint.new(ep_name, configs)
-      else
-        ep = _aprcps_storage[ep_name]
-      end
-      obj.define_singleton_method ep_name do
-        ep
+    # Set authorization on thread storage
+    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_instance_endpoint(ep_name, obj)
-    obj.instance_eval do
-      unless obj.method_defined? ep_name
-        define_method ep_name do
-          self.class.send ep_name
-        end
+  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
 
-  def self._aprcps_merge_endpoints_configs(endpoint_name, configs)
-    if configs && !configs.is_a?(Hash)
-      raise ApiRecipes::EndpointConfigIsNotAnHash.new(endpoint_name)
+  def self._aprcps_global_storage
+    unless @storage
+      @storage = {}
+    end
+    @storage
+  end
+
+  def self._aprcps_thread_storage
+    unless Thread.current[:api_recipes]
+      Thread.current[:api_recipes] = {}
+    end
+    Thread.current[:api_recipes]
+  end
+
+  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.apis_configs[api_name].merge(configs) do |_, old_val, new_val|
+        if new_val.nil?
+          old_val
+        else
+          new_val
+        end
+      end
+    else
+      ApiRecipes.configuration.apis_configs[api_name]
     end
-    ApiRecipes.configuration.endpoints_configs[endpoint_name].merge configs
   end
 end
 

data/lib/api_recipes/api.rb

@@ -0,0 +1,69 @@
+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
+            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,16 +1,49 @@
 module ApiRecipes
   class Configuration
 
-    def endpoints_configs=(configs = {})
-      raise ArgumentError, 'endpoints_configs must be an Hash' unless configs.is_a? Hash
-      @endpoints_configs = configs.deep_symbolize_keys
+    attr_accessor :log_to, :log_level
+
+    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 apis_configs
+      unless @apis_configs
+        @apis_configs = {}
+      end
+      @apis_configs
+    end
+
+    def logger=(logger)
+      @logger = logger
     end
 
-    def endpoints_configs
-      unless @endpoints_configs
-        @endpoints_configs = {}
+    def logger
+      unless @logger
+        log = ::Logger.new(log_to)
+        log.level    = normalize_log_level
+        log.progname = 'ApiRecipes'
+        @logger = log
+      end
+
+      @logger
+    end
+
+    private
+
+    # @private
+    def normalize_log_level
+      case @log_level
+      when :debug, ::Logger::DEBUG, 'debug' then ::Logger::DEBUG
+      when :info,  ::Logger::INFO,  'info'  then ::Logger::INFO
+      when :warn,  ::Logger::WARN,  'warn'  then ::Logger::WARN
+      when :error, ::Logger::ERROR, 'error' then ::Logger::ERROR
+      when :fatal, ::Logger::FATAL, 'fatal' then ::Logger::FATAL
+      else
+        Logger::ERROR
       end
-      @endpoints_configs
     end
   end
 end

data/lib/api_recipes/endpoint.rb

@@ -1,25 +1,126 @@
 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
+
+    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 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 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
+
+    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 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 required_params_for_path
+      absolute_path.scan(/:(\w+)/).flatten.map { |p| p.to_sym }
     end
   end
 end