evil-client 0.3.3 → 1.0.0

data/lib/evil/client/chaining.rb

@@ -0,0 +1,17 @@
+class Evil::Client
+  #
+  # Support chaining of calls for nested scopes/operations
+  #
+  module Chaining
+    private
+
+    def respond_to_missing?(name, *)
+      operations[name] || scopes[name]
+    end
+
+    def method_missing(name, *args, &block)
+      return super unless respond_to_missing? name
+      (operations[name] || scopes[name]).call(*args)
+    end
+  end
+end

data/lib/evil/client/connection.rb

@@ -1,31 +1,71 @@
 class Evil::Client
-  # @abstract Base class for a specific connection to remote uri
-  class Connection
-    REGISTRY = { net_http: "NetHTTP" }.freeze
+  #
+  # Object that sends rack-compatible request environment to remote API,
+  # and wraps a response into rack-compatible array of [status, headers, body].
+  #
+  # @see http://www.rubydoc.info/github/rack/rack/master/file/SPEC
+  #
+  module Connection
+    extend self
 
-    extend Dry::Initializer::Mixin
-    param :base_uri
-
-    # Envokes a specific connection class
+    # Makes the request by taking rack env and returning rack response
     #
-    # @param  [#to_sym] key
-    # @return [Class]
+    # @param  [Hash<String, Object>] env Rack environment
+    # @return [Array] Rack-compatible response
     #
-    def self.[](name = nil)
-      keys  = REGISTRY.keys
-      key   = (name || keys.first).to_sym
-      klass = REGISTRY.fetch(key) do
-        raise ArgumentError.new "Connection '#{key}' is not registered." \
-                                " Use the following keys: #{keys}"
+    def call(env)
+      request = Rack::Request.new(env)
+      with_logger_for request do
+        open_http_connection_for request do |http|
+          res = http.request build_from(request)
+          [res.code.to_i, Hash(res.header), Array(res.body)]
+        end
+      end
+    end
+
+    private
+
+    def open_http_connection_for(req)
+      Net::HTTP.start req.host, req.port, use_ssl: req.ssl? do |http|
+        yield(http)
+      end
+    end
+
+    def build_from(request)
+      uri     = URI request.url
+      body    = request.body
+      type    = request.env["REQUEST_METHOD"].capitalize
+      headers = request.env["HTTP_Variables"]
+
+      Net::HTTP.const_get(type).new(uri).tap do |req|
+        req.body = body
+        headers.each { |key, val| req[key] = val }
       end
+    end
 
-      require_relative "connection/#{key}"
-      const_get klass
+    def with_logger_for(request)
+      logger = request.logger
+      log_request(logger, request)
+      yield.tap { |response| log_response(logger, response) }
     end
 
-    # @abstract Sends request to the server and returns rack-compatible response
-    def call(_env, *)
-      raise NotImplementedError
+    def log_request(logger, request)
+      return unless logger
+
+      logger.info(self) { "sending request:" }
+      logger.info(self) { " Url     | #{request.url}" }
+      logger.info(self) { " Headers | #{request.env['HTTP_Variables']}" }
+      logger.info(self) { " Body    | #{request.body}" }
+    end
+
+    def log_response(logger, response)
+      return unless logger
+
+      status, headers, body = Array response
+      logger.info(self) { "receiving response:" }
+      logger.info(self) { " Status  | #{status}" }
+      logger.info(self) { " Headers | #{headers}" }
+      logger.info(self) { " Body    | #{body}" }
     end
   end
 end

data/lib/evil/client/container.rb

@@ -0,0 +1,66 @@
+class Evil::Client
+  #
+  # @abstract
+  # Container that carries schema of operation/scope along with its settings
+  # and methods to build sub-scope/operation or perform the current operation.
+  #
+  class Container
+    # Loads concrete implementations of the abstract container
+    require_relative "container/scope"
+    require_relative "container/operation"
+
+    # The schema containing info about sub-scopes and operations of the scope
+    # @return [Evil::Client::Container::ScopeDefinition]
+    attr_reader :schema
+
+    # The settings current scope is initialized with
+    # @return [Evil::Client::Settings]
+    attr_reader :settings
+
+    # Options assigned to the [#settings]
+    #
+    # These are opts given to the [#initializer],
+    # processed (via defaults, coercion, renaming) by a constructor of settings.
+    #
+    # @return [Hash<Symbol, Object>]
+    def options
+      @options ||= settings.options
+    end
+
+    # The human-friendly representation of the scope instance
+    #
+    # @example
+    #   '#<MyClient.scopes[:users] @version=1>'
+    #
+    # @return [String]
+    def to_s
+      "#<#{schema} #{options.map { |key, val| "@#{key}=#{val}" }.join(', ')}>"
+    end
+    alias_method :to_str,  :to_s
+    alias_method :inspect, :to_s
+
+    # (Re)sets current logger
+    #
+    # @param  [Logger, nil] logger
+    # @return [Logger, nil]
+    #
+    def logger=(logger)
+      settings.logger = logger
+    end
+
+    # Current logger
+    #
+    # @return [Logger, nil]
+    #
+    def logger
+      settings.logger
+    end
+
+    private
+
+    def initialize(schema, logger = nil, **opts)
+      @schema   = schema
+      @settings = schema.settings.new(logger, opts)
+    end
+  end
+end

data/lib/evil/client/container/operation.rb

@@ -0,0 +1,23 @@
+class Evil::Client
+  #
+  # Contains operation schema and settings along with DSL method [#call]
+  # to sends a request to API and handle the response.
+  #
+  class Container::Operation < Container
+    # Executes the operation and returns rack-compatible response
+    #
+    # @return [Array]
+    #
+    # rubocop: disable Metrics/AbcSize
+    def call
+      request    = Resolver::Request.call(schema, settings)
+      middleware = Resolver::Middleware.call(schema, settings)
+      connection = schema.client.connection
+      stack      = middleware.inject(connection) { |app, layer| layer.new app }
+      response   = stack.call request
+
+      Resolver::Response.call schema, settings, response
+    end
+    # rubocop: enable Metrics/AbcSize
+  end
+end

data/lib/evil/client/container/scope.rb

@@ -0,0 +1,28 @@
+class Evil::Client
+  #
+  # Contains schema and settings of some scope along with methods
+  # to initialize its sub-[#scopes] and [#operations]
+  #
+  class Container::Scope < Container
+    include Chaining
+
+    # The collection of named sub-scope constructors
+    # @return [Hash<Symbol, Evil::Client::Container::Scope::Builder>]
+    def scopes
+      @scopes ||= \
+        schema.scopes.each_with_object({}) do |(key, sub_schema), obj|
+          obj[key] = Builder::Scope.new(sub_schema, settings)
+        end
+    end
+
+    # The collection of named operations constructors
+    # @return [Hash<Symbol, Evil::Client::Container::Operation::Builder>]
+    def operations
+      @operations ||= \
+        schema.operations.each_with_object({}) do |(key, sub_schema), obj|
+          next unless key
+          obj[key] = Builder::Operation.new(sub_schema, settings)
+        end
+    end
+  end
+end

data/lib/evil/client/exceptions/definition_error.rb

@@ -0,0 +1,15 @@
+class Evil::Client
+  #
+  # Exception to be risen when schema definitions cannot be resolved.
+  # This is possibly a bug in client definition.
+  #
+  class DefinitionError < StandardError
+    private
+
+    def initialize(schema, keys, settings, text)
+      super "failed to resolve #{keys.join(' ')} from #{schema} schema" \
+            " for #{settings}: #{text}. Possibly this means a lack of" \
+            " necessary validations in definition of the client."
+    end
+  end
+end

data/lib/evil/client/exceptions/name_error.rb

@@ -0,0 +1,32 @@
+class Evil::Client
+  #
+  # Exception to be risen when selected name cannot be used in a custom client.
+  #
+  class NameError < ::NameError
+    # Checks whether a name is valid
+    #
+    # @param  [#to_sym] name The name to check
+    # @param  [Array<Symbol>] forbidden ([]) The list of forbidden names
+    # @return [Symbol] if name is valid
+    # @raise  [self] if name isn't valid
+    #
+    def self.check!(name, forbidden = [])
+      name = name.to_sym
+      return name if name[FORMAT] && !forbidden.include?(name)
+      raise new(name, forbidden)
+    end
+
+    private
+
+    def initialize(name, forbidden)
+      super "Invalid name :#{name}." \
+            " It should contain latin letters in the lower case, digits," \
+            " and underscores only; have minimum 2 chars;" \
+            " start from a letter; end with either letter or digit." \
+            " The following names: '#{forbidden.join("', '")}'" \
+            " are already used by Evil::Client."
+    end
+
+    FORMAT = /^[a-z]([a-z\d_])*[a-z\d]$/
+  end
+end

data/lib/evil/client/exceptions/response_error.rb

@@ -0,0 +1,42 @@
+class Evil::Client
+  #
+  # Exception to be risen when remote API responded with undefined status
+  #
+  class ResponseError < RuntimeError
+    # @!attribute [r] schema
+    # @return [Evil::Client::Container::Operation::Schema] The operation schema
+    attr_reader :schema
+
+    # @!attribute [r] settings
+    # @return [Evil::Client::Settings] The settings used by the request
+    attr_reader :settings
+
+    # @!attribute [r] response
+    # @return [Array] The rack response to the request
+    attr_reader :response
+
+    # @!attribute [r] settings
+    # @return [Integer] The status of the [#response]
+    attr_reader :status
+
+    # @!attribute [r] headers
+    # @return [Hash] The hash of the [#response] headers
+    attr_reader :headers
+
+    # @!attribute [r] settings
+    # @return [Enumerable] The enumerable object describing the [#response] body
+    attr_reader :body
+
+    private
+
+    def initialize(schema, settings, response)
+      @schema   = schema
+      @settings = settings
+      @response = response
+      @status, @headers, @body = Array(response)
+
+      super "remote API responded to #{@schema}" \
+            " with unexpected status #{@status}"
+    end
+  end
+end

data/lib/evil/client/exceptions/type_error.rb

@@ -0,0 +1,29 @@
+class Evil::Client
+  #
+  # Exception to be risen when user defines a scope/operation with a name,
+  # that has been used by existing operation/scope.
+  #
+  class TypeError < ::TypeError
+    # Checks whether a name can be used to define operation/scope of the schema
+    #
+    # @param  [Evil::Client::Schema::Scope] scope
+    # @param  [Symbol] name
+    # @param  [Symbol] type
+    # @return [Symbol] nil
+    # @raise  [self] if name cannot be used
+    #
+    def self.check!(schema, name, type)
+      return if type == :scope && schema.operations[name].nil?
+      return if type == :operation && schema.scopes[name].nil?
+      raise new(name, type)
+    end
+
+    private
+
+    def initialize(name, new_type)
+      old_type = new_type == :scope ? :operation : :scope
+      super "The #{old_type} :#{name} was already defined." \
+            " You cannot create #{new_type} with the same name."
+    end
+  end
+end

data/lib/evil/client/exceptions/validation_error.rb

@@ -0,0 +1,27 @@
+class Evil::Client
+  #
+  # Exception to be risen when scope or operation cannot be initialized
+  # due to some options or their composition are invalid
+  #
+  class ValidationError < ArgumentError
+    private
+
+    def initialize(key, scope = nil, **options)
+      scope = "evil.client.errors.#{scope}"
+              .split(".")
+              .map { |part| __underscore__(part) }
+
+      super key.is_a?(Symbol) ? I18n.t(key, scope: scope, **options) : key
+    end
+
+    def __underscore__(name)
+      name.dup.tap do |n|
+        n.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        n.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        n.gsub!("::", "/")
+        n.tr!("-", "_")
+        n.downcase!
+      end
+    end
+  end
+end

data/lib/evil/client/formatter.rb

@@ -0,0 +1,49 @@
+class Evil::Client
+  # Utility to format body/query into one of formats: :json, :form, :multipart
+  module Formatter
+    extend self
+
+    # Loads concrete formatters called by factory method [#call]
+    require_relative "formatter/text"
+    require_relative "formatter/form"
+    require_relative "formatter/multipart"
+
+    # Factory that knows how to format source depending on given format
+    #
+    # @param  [Object] source
+    # @param  [:json, :form, :multipart, :text] format
+    # @option opts [String] :boundary The boundary for a multipart body
+    # @return [String] formatted body
+    #
+    def call(source, format, **opts)
+      return unless source
+      return to_json(source) if format == :json
+      return to_yaml(source) if format == :yaml
+      return to_form(source) if format == :form
+      return to_text(source) if format == :text
+      to_multipart(source, opts)
+    end
+
+    private
+
+    def to_json(source)
+      JSON.dump source
+    end
+
+    def to_yaml(source)
+      YAML.dump source
+    end
+
+    def to_text(source)
+      Text.call source
+    end
+
+    def to_form(source)
+      Form.call source
+    end
+
+    def to_multipart(source, opts)
+      Multipart.call [source], opts
+    end
+  end
+end

data/lib/evil/client/formatter/form.rb

@@ -0,0 +1,45 @@
+module Evil::Client::Formatter
+  #
+  # Utility module to format body/query as a form
+  #
+  # @example
+  #   Evil::Client::Formatter::Form.call foo: { bar: [:baz] }, qux: 1
+  #   # => "foo[bar][]=baz&qux=1"
+  #
+  module Form
+    extend self
+
+    # Formats nested hash as a string
+    #
+    # @param  [Hash] source
+    # @return [String]
+    #
+    def call(source)
+      case source
+      when nil  then nil
+      when Hash then normalize(source)
+      else raise "#{source} is not a hash"
+      end
+    end
+
+    private
+
+    def normalize(value, *keys)
+      case value
+      when Hash then
+        value.flat_map { |key, val| normalize(val, *keys, key) }.join("&")
+      when Array then
+        value.flat_map { |val| normalize(val, *keys, nil) }.join("&")
+      else
+        finalize(value, *keys)
+      end
+    end
+
+    def finalize(value, key, *keys)
+      value = CGI.escape(value.to_s)
+      key   = CGI.escape(key.to_s)
+      keys  = keys.map { |k| "[#{CGI.escape(k.to_s)}]" }
+      "#{key}#{keys.join}=#{value}"
+    end
+  end
+end