namira 1.0.0.rc2 → 1.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da250f857c2e6f20c0d0b09681e892959d660c65
-  data.tar.gz: 17583cacb46a3dae5e16c8b0756bedd4e618ae48
+  metadata.gz: 218528e873d7b85eafe5cc3e31dbb0297d9d1786
+  data.tar.gz: ead0b1b476362ffc18352416afde87af3578047f
 SHA512:
-  metadata.gz: 49a3ac09358ada8d9566817ff59b54292c24026f59be3f366557e8c98ac5a3ae61f4e70cb65f01ce94874b2bfe2d8f1efa16a1ac8d971381d41dc8d3b83211a5
-  data.tar.gz: 5c1baca7057c948e73ac578547be39360c531a203bf2cac0593ccfca250243a7d7367d9cba7bdb83718a69c5ea095baf1e0b5d979d30be0a26667422af0367de
+  metadata.gz: 4c0bd6e7e24bee243dc0de7abefc331aff7b46941976434acecb0e77bbfdbd6db01fbb38aed4f709112cb477aac71f98b4b7a128258085a9ea3accea8dec2d3a
+  data.tar.gz: 9c2bba7ce244f44b33836c1541e12564173c82010649f4f4db9fc489fbeb86d2608c53937113907bcd0697e94a602d6d06f92cb5463ebaf4e1a97b22a1e7f646

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.2
+  TargetRubyVersion: 2.3
   Exclude:
     - Rakefile
     - spec/**/*
@@ -48,3 +48,6 @@ Style/GuardClause:
 
 Style/RaiseArgs:
   Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,11 @@
-# 1.0.0.rc1 (master)
+# 1.0.0.rc3 (2018-01-28)
+
+* Converted to using a middleware stack for sending requests.
+
+# 1.0.0.rc2
+
+Namira 1.0.0.rc2
+
+# 1.0.0.rc1
 
 Namira 1.0

data/lib/namira.rb

@@ -1,11 +1,12 @@
-require 'namira/version'
-require 'namira/request'
-require 'namira/response'
-require 'namira/errors'
 require 'namira/config'
+require 'namira/env'
+require 'namira/errors'
+require 'namira/middleware'
 require 'namira/query_builder'
-require 'namira/backend'
-require 'namira/auth'
+require 'namira/request'
+require 'namira/response'
+require 'namira/stack'
+require 'namira/version'
 
 ##
 # A Ruby HTTP client

data/lib/namira/env.rb

@@ -0,0 +1,26 @@
+module Namira
+  ##
+  # The calling environment for the request
+  class Env
+    attr_accessor \
+      :uri,
+      :headers,
+      :body,
+      :method,
+      :config,
+      :redirect_count,
+      :response,
+      :timing
+
+    def initialize(env)
+      @uri     = Addressable::URI.parse(env[:uri].to_s)
+      @body    = env[:body]
+      @method  = env[:method]
+      @headers = Hash(env[:headers])
+      @config  = Hash(env[:config])
+      @redirect_count = 0
+      @response = nil
+      @timing = nil
+    end
+  end
+end

data/lib/namira/middleware.rb

@@ -0,0 +1,15 @@
+require_relative 'middleware/config'
+require_relative 'middleware/header'
+require_relative 'middleware/logger'
+require_relative 'middleware/network'
+require_relative 'middleware/redirector'
+require_relative 'middleware/responder'
+require_relative 'middleware/timeout'
+require_relative 'middleware/timing'
+
+module Namira
+  ##
+  # Contains the middleware classes for the default stack
+  module Middleware
+  end
+end

data/lib/namira/middleware/config.rb

@@ -0,0 +1,26 @@
+module Namira
+  module Middleware
+    ##
+    # Duplicates the global config for modification by other middleware
+    class Config
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Called by the middleware runner.
+      #
+      # @param env [Namira::Env] The request environment
+      def call(env)
+        env.config = merge_config(env.config.dup)
+        @app.call(env)
+      end
+
+      private
+
+      def merge_config(config)
+        Namira.configure.to_h.merge(config)
+      end
+    end
+  end
+end

data/lib/namira/middleware/header.rb

@@ -0,0 +1,38 @@
+module Namira
+  module Middleware
+    ##
+    # Creates the final request headers by merging global, defaults, and request headers
+    class Header
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Called by the middleware runner.
+      #
+      # @param env [Namira::Env] The request environment
+      def call(env)
+        headers = Hash(Namira.configure.headers.to_h).dup
+        headers.merge!(additional_headers(env))
+        headers.merge!(env.headers.to_h)
+        env.headers = convert_headers(headers)
+        @app.call(env)
+      end
+
+      private
+
+      def additional_headers(env)
+        {
+          'User-Agent' => env.config[:user_agent]
+        }
+      end
+
+      def convert_headers(headers)
+        headers.each_with_object({}) do |(key, value), obj|
+          header = key.to_s.split(/-|_/).map(&:capitalize).join('-')
+          obj[header] = value
+        end
+      end
+    end
+  end
+end

data/lib/namira/middleware/logger.rb

@@ -0,0 +1,44 @@
+module Namira
+  module Middleware
+    ##
+    # Performs request logging
+    class Logger
+      ##
+      # The key that will disable logging
+      SKIP_LOGGING_KEY = :skip_logging
+
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Called by the middleware runner.
+      #
+      # @param env [Namira::Env] The request environment
+      def call(env)
+        log_request(env)
+        @app.call(env)
+      end
+
+      private
+
+      def logging?(env)
+        if env.config.keys.include?(SKIP_LOGGING_KEY)
+          env.config[SKIP_LOGGING_KEY] == false
+        else
+          Namira.configure.log_requests == true
+        end
+      end
+
+      def log_request(env)
+        return unless logging?(env)
+        message = "#{env.method.to_s.upcase} - #{env.uri}"
+        if defined?(::Rails)
+          Rails.logger.debug(message)
+        else
+          STDOUT.puts(message)
+        end
+      end
+    end
+  end
+end

data/lib/namira/middleware/network.rb

@@ -0,0 +1,28 @@
+module Namira
+  module Middleware
+    ##
+    # Performs the network request
+    class Network
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Called by the middleware runner.
+      #
+      # @param env [Namira::Env] The request environment
+      def call(env)
+        timeout = env.config[:timeout] || 30.0
+        http = HTTP.timeout(
+          :per_operation,
+          write:   timeout,
+          connect: timeout,
+          read:    timeout
+        )
+        http = http.headers(env.headers)
+        env.response = http.send(env.method, env.uri, body: env.body)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/namira/middleware/redirector.rb

@@ -0,0 +1,66 @@
+module Namira
+  module Middleware
+    ##
+    # Performs following the redirect and handling multiple redirect errors.
+    class Redirector
+      ##
+      # The HTTP status codes Namira will consider a redirect
+      REDIRECT_STATUS = [301, 302].freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Called by the middleware runner.
+      #
+      # @param env [Namira::Env] The request environment
+      def call(env)
+        @app.call(env)
+      rescue Errors::HTTPError => e
+        if redirect?(e, env)
+          handle_redirect(env, e)
+        else
+          raise e
+        end
+      end
+
+      private
+
+      def handle_redirect(env, e)
+        count = env.redirect_count
+        redirect_count_error(env) if count >= max_redirect(env)
+        location = e.response.headers['Location']
+        redirect_location_error(env) if location.nil?
+        env.uri = Addressable::URI.parse(location)
+        env.redirect_count += 1
+        call(env)
+      end
+
+      def max_redirect(env)
+        env.config[:max_redirect] || 3
+      end
+
+      def redirect_count_error(env)
+        raise Errors::RedirectError.new(
+          "Max number of redirects #{env.redirect_count} for #{env.uri}",
+          env.uri.to_s,
+          env.redirect_count
+        )
+      end
+
+      def redirect_location_error(env)
+        raise Errors::RedirectError.new(
+          'Request redirected but no location was supplied',
+          nil,
+          env.redirect_count
+        )
+      end
+
+      def redirect?(e, env)
+        return false unless env.config[:follow_redirect].nil? ? true : env.config[:follow_redirect]
+        REDIRECT_STATUS.include?(e.status)
+      end
+    end
+  end
+end

data/lib/namira/middleware/responder.rb

@@ -0,0 +1,32 @@
+module Namira
+  module Middleware
+    ##
+    # Builds the {Namira::Response} from the backend responses
+    class Responder
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Called by the middleware runner.
+      #
+      # @param env [Namira::Env] The request environment
+      def call(env)
+        handle_response(env.response)
+        env.response = Namira::Response.new(env.response)
+        @app.call(env)
+      end
+
+      private
+
+      def handle_response(response)
+        final = Namira::Response.new(response)
+        if (200...300).cover?(response.status)
+          final
+        else
+          raise Errors::HTTPError.new("http_error/#{response.status}", response.status, final)
+        end
+      end
+    end
+  end
+end

data/lib/namira/middleware/timeout.rb

@@ -0,0 +1,21 @@
+module Namira
+  module Middleware
+    ##
+    # Handles timeout errors
+    class Timeout
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Called by the middleware runner.
+      #
+      # @param env [Namira::Env] The request environment
+      def call(env)
+        @app.call(env)
+      rescue HTTP::TimeoutError => e
+        raise Errors::TimeoutError.new(e.message)
+      end
+    end
+  end
+end

data/lib/namira/middleware/timing.rb

@@ -0,0 +1,22 @@
+module Namira
+  module Middleware
+    ##
+    # Records timing for the request
+    class Timing
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Called by the middleware runner.
+      #
+      # @param env [Namira::Env] The request environment
+      def call(env)
+        start_time = Time.now
+        result = @app.call(env)
+        result.timing = Time.now - start_time
+        result
+      end
+    end
+  end
+end

data/lib/namira/request.rb

@@ -15,19 +15,14 @@ module Namira
     # @param http_method [Symbol] The HTTP method for the request. (Default `:get`)
     # @param headers [Hash] Additional headers to send with the request. (Default: `{}`)
     # @param body [String, #to_s] The body to send. (Default: nil)
-    # @param auth [Namira::Auth::Base] The auth instance used to sign requests.
     # @param config [Hash] {Namira::Config} overrides
-    def initialize(uri:, http_method: :get, headers: {}, body: nil, auth: nil, config: {})
-      @uri          = uri
-      @http_method  = http_method
-      @headers      = Hash(headers)
-      @body         = body
-      @auth         = auth
-      @timeout      = config[:timeout] || Namira.configure.timeout
-      @max_redirect = config[:max_redirect] || Namira.configure.max_redirect
-      @backend      = config[:backend] || Namira.configure.backend || Namira::Backend
-      @user_agent   = config[:user_agent] || Namira.configure.user_agent
-      @max_redirect = Backend::NO_FOLLOW_REDIRECT_COUNT if config[:follow_redirect] == false
+    def initialize(uri:, http_method: :get, headers: {}, body: nil, config: {})
+      @uri         = uri
+      @http_method = http_method
+      @headers     = Hash(headers)
+      @body        = body
+      @config      = Namira.configure.to_h.merge(Hash(config))
+      @stack       = Namira::Stack.default
     end
 
     ##
@@ -35,7 +30,7 @@ module Namira
     #
     # Every time this method is called a network request will be sent.
     def send_request
-      @response = _send_request(uri)
+      @response = _send_request
     end
 
     ##
@@ -51,29 +46,20 @@ module Namira
 
     private
 
-    def build_headers
-      {}.tap do |headers|
-        headers['User-Agent'] = @user_agent
-        Namira.configure.headers.to_h.each do |k, v|
-          key = k.to_s.split('_').map(&:capitalize).join('-')
-          headers[key] = v
-        end
-        @headers.each do |k, v|
-          headers[k] = v
-        end
-      end
+    def env
+      Namira::Env.new(
+        uri: @uri,
+        method: @http_method,
+        body: @body,
+        headers: @headers,
+        config: @config
+      )
     end
 
-    def _send_request(uri)
-      @backend.send_request(
-        uri:          uri,
-        method:       http_method,
-        headers:      build_headers,
-        max_redirect: @max_redirect,
-        timeout:      @timeout,
-        body:         @body,
-        auth:         @auth
-      )
+    def _send_request
+      @stack.call(env).response
+    rescue Addressable::URI::InvalidURIError => e
+      raise Namira::Errors::InvalidURIError.new(e.message)
     end
   end
 end

data/lib/namira/stack.rb

@@ -0,0 +1,57 @@
+module Namira
+  ##
+  # The middleware stack used to send a request
+  class Stack
+    class << self
+      ##
+      # The default middleware stack
+      def default
+        Stack.new do
+          use Middleware::Config
+          use Middleware::Header
+          use Middleware::Timing
+          use Middleware::Redirector
+          use Middleware::Logger
+          use Middleware::Timeout
+          use Middleware::Network
+          use Middleware::Responder
+        end
+      end
+    end
+
+    def initialize(&block)
+      @middleware = []
+      instance_eval(&block)
+    end
+
+    ##
+    # Called by the middleware runner.
+    #
+    # @param env [Namira::Env] The request environment
+    def call(env)
+      raise ArgumentError, 'Invalid environment' unless env.is_a?(Namira::Env)
+      to_app.call(env)
+    end
+
+    ##
+    # Add a class to the middleware stack
+    #
+    # @param klass [Class, #call] The middleware class
+    # @param args [Any] Arguments passed to the class initializer
+    # @param block [Block] A block to pass to the class initializer
+    def use(klass, *args, &block)
+      @middleware << lambda do |app|
+        klass.new(app, *args, &block)
+      end
+    end
+
+    private
+
+    def to_app
+      application = ->(env) { env }
+      @middleware.reverse.inject(application) do |app, component|
+        component.call(app)
+      end
+    end
+  end
+end

data/lib/namira/version.rb

@@ -1,5 +1,5 @@
 module Namira
   ##
   # The current version of Namira
-  VERSION = '1.0.0.rc2'.freeze
+  VERSION = '1.0.0.rc3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: namira
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc2
+  version: 1.0.0.rc3
 platform: ruby
 authors:
 - Skylar Schipper
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-23 00:00:00.000000000 Z
+date: 2018-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -148,20 +148,27 @@ files:
 - bin/console
 - bin/setup
 - lib/namira.rb
-- lib/namira/auth.rb
-- lib/namira/auth/base.rb
-- lib/namira/auth/http_basic.rb
-- lib/namira/backend.rb
 - lib/namira/config.rb
+- lib/namira/env.rb
 - lib/namira/errors.rb
 - lib/namira/errors/base_error.rb
 - lib/namira/errors/http_error.rb
 - lib/namira/errors/invalid_uri_error.rb
 - lib/namira/errors/redirect_error.rb
 - lib/namira/errors/timeout_error.rb
+- lib/namira/middleware.rb
+- lib/namira/middleware/config.rb
+- lib/namira/middleware/header.rb
+- lib/namira/middleware/logger.rb
+- lib/namira/middleware/network.rb
+- lib/namira/middleware/redirector.rb
+- lib/namira/middleware/responder.rb
+- lib/namira/middleware/timeout.rb
+- lib/namira/middleware/timing.rb
 - lib/namira/query_builder.rb
 - lib/namira/request.rb
 - lib/namira/response.rb
+- lib/namira/stack.rb
 - lib/namira/version.rb
 - namira.gemspec
 homepage: https://github.com/skylarsch/namira

data/lib/namira/auth.rb

@@ -1,2 +0,0 @@
-require_relative 'auth/base'
-require_relative 'auth/http_basic'

data/lib/namira/auth/base.rb

@@ -1,39 +0,0 @@
-module Namira
-  ##
-  # Authentication
-  module Auth
-    ##
-    # The base authentication class
-    class Base
-      attr_accessor :sign_redirects
-
-      def sign_redirects?
-        if @sign_redirects.nil?
-          true
-        else
-          @sign_redirects == true
-        end
-      end
-
-      ##
-      # @private
-      #
-      # Signs a request.
-      #
-      # @param backend [HTTP] The request being signed
-      # @param redirect_count [Integer] The number of redirects this request has encountered
-      def sign_request(backend, redirect_count)
-        return if redirect_count > 0 && !sign_redirects?
-        sign(backend)
-      end
-
-      ##
-      # Perform the signing of the request
-      #
-      # @param backend [HTTP] The instance of the backend request to sign.
-      def sign(_backend)
-        raise NotImplementedError, 'Auth should override the `sign` method'
-      end
-    end
-  end
-end

data/lib/namira/auth/http_basic.rb

@@ -1,25 +0,0 @@
-module Namira
-  module Auth
-    ##
-    # Signs a HTTP request with HTTP basic authentication
-    class HTTPBasic < Base
-      attr_reader :user, :pass
-
-      ##
-      # Create a new instance
-      #
-      # @param user [String] The username
-      # @param pass [String] The password
-      def initialize(user:, pass:)
-        @user = user
-        @pass = pass
-      end
-
-      ##
-      # Signs the request
-      def sign(request)
-        request.basic_auth(user: user, pass: pass)
-      end
-    end
-  end
-end

data/lib/namira/backend.rb

@@ -1,138 +0,0 @@
-module Namira
-  ##
-  # The backend is responsible for sending the requests.
-  #
-  # Namira uses HTTP Gem as its default backend. You can create your own backend and override `.send_request` to
-  # use a different network stack.
-  #
-  #   Namira.config do |c|
-  #     c.backend = CustomBackend
-  #   end
-  #
-  # A fully compatable backend should handle redirects, respecting the max_redirect parameter as well as
-  # throwing a Errors::HTTPError for anything but a redirect & 2xx status code.
-  class Backend
-    ##
-    # This allows anyone to substitute in their own networking stack.
-    #
-    # Any class that implements this method and resturns a `Namira::Response` object can be a fully qualified backend.
-    #
-    # @param uri [String] The URI to fetch
-    # @param method [Symbol] The HTTP method to use, expressed as a Symbol i.e. `:get`
-    # @param headers [Hash] The full HTTP headers to send from the request expressed as a Hash
-    # @param max_redirect [Integer] The maximum number of redirects to follow.  Passed from the Request
-    # @param timeout [Integer] The number of seconds before a timeout should occure
-    # @param auth [Namira::Auth::Base] The `Namira::Auth::Base` subclass instance or nil to sign the request with
-    #
-    # @return [Namira::Response] The HTTP response
-    def self.send_request(uri:, method:, headers:, max_redirect:, timeout:, body:, auth:)
-      Backend.new(
-        uri: uri,
-        method: method,
-        headers: headers,
-        max_redirect: max_redirect,
-        timeout: timeout,
-        body: body,
-        auth: auth
-      ).execute
-    end
-
-    ##
-    # The default max redirects to consider the request a "no follow"
-    NO_FOLLOW_REDIRECT_COUNT = -1
-
-    ##
-    # @private
-    def initialize(opts = {})
-      opts.each do |key, value|
-        instance_variable_set("@#{key}", value)
-      end
-      @redirect_count = 0
-    end
-
-    ##
-    # @private
-    #
-    # Perform the request
-    def execute(location = nil)
-      ensure_redirect_count!(location)
-      prepare_request
-      sign_request_if_needed
-      send_request(location || @uri)
-      handle_response
-    end
-
-    private
-
-    def ensure_redirect_count!(location)
-      return if @redirect_count.zero?
-      return if @redirect_count <= @max_redirect
-      raise Errors::RedirectError.new(
-        "Max number of redirects #{@redirect_count} for #{@uri}",
-        location,
-        @redirect_count
-      )
-    end
-
-    def prepare_request
-      @http = HTTP.timeout(
-        :per_operation,
-        write:   @timeout,
-        connect: @timeout,
-        read:    @timeout
-      ).headers(@headers)
-    end
-
-    def log_request(method, uri)
-      return unless Namira.configure.log_requests
-      if defined?(::Rails)
-        Rails.logger.debug "#{method.to_s.upcase} - #{uri}"
-      else
-        STDOUT.puts "#{method.to_s.upcase} - #{uri}"
-      end
-    end
-
-    def send_request(location)
-      log_request(@method, location)
-      @response = @http.send(@method, location, body: @body)
-    rescue HTTP::TimeoutError => e
-      raise Namira::Errors::TimeoutError.new(e.message)
-    rescue Addressable::URI::InvalidURIError => e
-      raise Namira::Errors::InvalidURIError.new(e.message)
-    end
-
-    def sign_request_if_needed
-      @http = @auth.sign_request(@http, @redirect_count) unless @auth.nil?
-    end
-
-    def handle_response
-      case @response.status
-      when 200..299
-        create_response
-      when 301, 302
-        handle_redirect
-      else
-        create_error_response
-      end
-    end
-
-    def create_response
-      Namira::Response.new(@response)
-    end
-
-    def create_error_response
-      raise Errors::HTTPError.new("http_error/#{@response.status}", @response.status, create_response)
-    end
-
-    def handle_redirect
-      if @max_redirect == NO_FOLLOW_REDIRECT_COUNT
-        create_error_response
-      else
-        @redirect_count += 1
-        location = @response.headers['Location']
-        raise Errors::RedirectError.new('Request redirected but no location was supplied', nil, @redirect_count) if location.nil?
-        execute(location)
-      end
-    end
-  end
-end