drillbit 0.0.1

data/lib/drillbit/requests/rack.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require 'drillbit/configuration'
+require 'drillbit/requests/base'
+require 'drillbit/accept_header'
+require 'drillbit/tokens/json_web_token'
+require 'drillbit/tokens/base64'
+
+module  Drillbit
+module  Requests
+class   Rack < Base
+  ACCEPT_PARAM_PATTERN         = /(?:\A|&)accept=(.+?)(?=\z|&)/
+  BASE64_TOKEN_PARAM_PATTERN   = /(?:\A|&)#{BASE64_TOKEN_PARAM_NAME}=(.*)(?=\z|&)/
+  JSON_WEB_TOKEN_PARAM_PATTERN = /(?:\A|&)#{JSON_WEB_TOKEN_PARAM_NAME}=(.*)(?=\z|&)/
+
+  def authorization_token_from_params
+    case request['QUERY_STRING']
+    when JSON_WEB_TOKEN_PARAM_PATTERN
+      Tokens::JsonWebToken.from_jwe(
+        request['QUERY_STRING'][JSON_WEB_TOKEN_PARAM_PATTERN, 1] || '',
+        private_key: token_private_key,
+      )
+    when BASE64_TOKEN_PARAM_PATTERN
+      base64_token = request['QUERY_STRING'][BASE64_TOKEN_PARAM_PATTERN, 1]
+
+      Tokens::Base64.convert(raw_token: base64_token)
+    else
+      Tokens::Null.instance
+    end
+  end
+
+  private
+
+  def raw_accept_header_from_header
+    request['HTTP_ACCEPT']
+  end
+
+  def raw_accept_header_from_params
+    URI.unescape(request['QUERY_STRING'][ACCEPT_PARAM_PATTERN, 1] || '')
+  end
+
+  def raw_authorization_header
+    request['HTTP_AUTHORIZATION'] || ''
+  end
+
+  def raw_request_application_name
+    request['HTTP_X_APPLICATION_NAME']
+  end
+end
+end
+end

data/lib/drillbit/requests/rails.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require 'drillbit/configuration'
+require 'drillbit/requests/base'
+require 'drillbit/accept_header'
+require 'drillbit/tokens/json_web_token'
+require 'drillbit/tokens/base64'
+
+module  Drillbit
+module  Requests
+class   Rails < Base
+  def authorization_token_from_params
+    case
+    when request.params.key?(JSON_WEB_TOKEN_PARAM_NAME)
+      Tokens::JsonWebToken.from_jwe(
+        request.params[JSON_WEB_TOKEN_PARAM_NAME] || '',
+        private_key: token_private_key,
+      )
+    when request.params.key?(BASE64_TOKEN_PARAM_NAME)
+      Tokens::Base64.convert(raw_token: request.params[BASE64_TOKEN_PARAM_NAME] || '')
+    else
+      Tokens::Null.instance
+    end
+  end
+
+  private
+
+  def raw_accept_header_from_header
+    request.headers['Accept']
+  end
+
+  def raw_accept_header_from_params
+    request.params['accept']
+  end
+
+  def raw_authorization_header
+    request.headers['HTTP_AUTHORIZATION'] || ''
+  end
+
+  def raw_request_application_name
+    request.headers['X-Application-Name']
+  end
+end
+end
+end

data/lib/drillbit/resource.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'drillbit/authorizable_resource'
+require 'erratum/rescuable_resource'
+require 'erratum/verifiable_resource'
+
+module  Drillbit
+module  Resource
+  def self.included(base)
+    base.include Erratum::RescuableResource
+    base.include Erratum::VerifiableResource
+    base.include Drillbit::AuthorizableResource
+  end
+end
+end

data/lib/drillbit/resource/model.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require 'drillbit/resource/processors/filtering'
+require 'drillbit/resource/processors/sorting'
+require 'drillbit/resource/processors/paging'
+require 'drillbit/resource/processors/indexing'
+
+module  Drillbit
+module  Resource
+class   Model
+  DEFAULT_PROCESSORS = %w{filtering sorting paging indexing}.freeze
+
+  attr_accessor :resource,
+                :parameters,
+                :processors
+
+  def initialize(resource:, parameters:, **options)
+    self.resource   = resource
+    self.parameters = parameters.dup
+    self.processors = options.fetch(:processors, DEFAULT_PROCESSORS)
+  end
+
+  def processed
+    @processed ||= processors.inject(resource) do |processed_resource, processor|
+        processor.processed(processed_resource, parameters)
+    end
+  end
+
+  def meta
+    @meta ||= processors.inject({}) do |metadata, processor|
+        metadata.merge processor.meta(processed, parameters)
+    end
+  end
+
+  def processors=(other)
+    @processors = other.map do |processor|
+      Object.const_get "::Drillbit::Resource::Processors::#{processor.capitalize}"
+    end
+  end
+end
+end
+end

data/lib/drillbit/resource/naming.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module  Drillbit
+module  Resource
+module  Naming
+  CONTROLLER_RESOURCE_NAME_PATTERN = /\A((.*?::)?.*?)(\w+)Controller\z/
+
+  module ClassMethods
+    def plural_resource_name
+      @plural_resource_name ||= name[CONTROLLER_RESOURCE_NAME_PATTERN, 3].
+                                underscore.
+                                pluralize.
+                                downcase
+    end
+
+    def singular_resource_name
+      @singular_resource_name ||= name[CONTROLLER_RESOURCE_NAME_PATTERN, 3].
+                                  underscore.
+                                  singularize.
+                                  downcase
+    end
+
+    def resource_class_name
+      @resource_class_name ||= singular_resource_name.
+                               camelize
+    end
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+end
+end
+end

data/lib/drillbit/resource/processors/filtering.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require 'drillbit/parameters/filter'
+
+module Drillbit
+module Resource
+module Processors
+class  Filtering
+  attr_accessor :resource,
+                :parameters
+
+  # rubocop:disable Style/OptionHash
+  def initialize(resource, parameters = {})
+    self.resource   = resource
+    self.parameters = Parameters::Filter.new(parameters['filter'] || {})
+  end
+  # rubocop:enable Style/OptionHash
+
+  def self.processed(*attrs)
+    new(*attrs).processed
+  end
+
+  def self.meta(*_attrs)
+    {}
+  end
+
+  def processed
+    parameters.each_with_object(resource) do |name, value, filtered_resource|
+      filter_method = filter_method_for(name)
+
+      if !filter_method
+        filtered_resource
+      elsif filter_method.arity == 0
+        filtered_resource.public_send(filter_method.name)
+      else
+        filtered_resource.public_send(filter_method.name, value)
+      end
+    end
+  end
+
+  private
+
+  def filter_method_for(filter_item)
+    filter_method_name = filter_method_name_for(filter_item)
+
+    resource_class.method(filter_method_name) if filter_method_name
+  end
+
+  def filter_method_name_for(filter_item)
+    if resource_class.respond_to? "for_#{filter_item}"
+      "for_#{filter_item}"
+    elsif resource_class.respond_to? filter_item
+      filter_item
+    end
+  end
+
+  def resource_class
+    @resource_class ||= if resource.respond_to? :klass
+                          resource.klass
+                        else
+                          resource
+                        end
+  end
+end
+end
+end
+end

data/lib/drillbit/resource/processors/indexing.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'drillbit/parameters/index'
+
+module Drillbit
+module Resource
+module Processors
+class  Indexing
+  attr_accessor :resource,
+                :parameters
+
+  # rubocop:disable Style/OptionHash
+  def initialize(resource, parameters = {})
+    self.resource   = resource
+    self.parameters = Parameters::Index.new(parameters['filter'] || {})
+  end
+  # rubocop:enable Style/OptionHash
+
+  def self.processed(*attrs)
+    new(*attrs).processed
+  end
+
+  def self.meta(*_attrs)
+    {}
+  end
+
+  def processed
+    return resource unless parameters.present? || force_query
+
+    resource.for_query(parameters.query || Parameters::Index::DEFAULT_QUERY)
+  end
+
+  private
+
+  def force_query
+    resource.class.name.include? 'Index'
+  end
+end
+end
+end
+end

data/lib/drillbit/resource/processors/paging.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'drillbit/parameters/page'
+
+module  Drillbit
+module  Resource
+module  Processors
+class   Paging
+  attr_accessor :resource,
+                :parameters
+
+  # rubocop:disable Style/OptionHash
+  def initialize(resource, parameters = {})
+    self.resource   = resource
+    self.parameters = Parameters::Page.new(parameters['page'] || {})
+  end
+  # rubocop:enable Style/OptionHash
+
+  def self.processed(*attrs)
+    new(*attrs).processed
+  end
+
+  def self.meta(*attrs)
+    new(*attrs).meta
+  end
+
+  def processed
+    return resource unless parameters.present?
+
+    resource.page(parameters.page_number).
+             per(parameters.per_page)
+  end
+
+  def meta
+    return {} unless parameters.present?
+
+    {
+      'total-pages'   => resource.total_pages,
+      'current-page'  => resource.current_page,
+      'previous-page' => resource.prev_page,
+      'next-page'     => resource.next_page,
+    }
+  end
+end
+end
+end
+end

data/lib/drillbit/resource/processors/sorting.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require 'drillbit/parameters/sort'
+
+module  Drillbit
+module  Resource
+module  Processors
+class   Sorting
+  attr_accessor :resource,
+                :parameters
+
+  # rubocop:disable Style/OptionHash
+  def initialize(resource, parameters = {})
+    self.resource   = resource
+    self.parameters = Parameters::Sort.new(parameters['sort'])
+  end
+  # rubocop:enable Style/OptionHash
+
+  def self.processed(*attrs)
+    new(*attrs).processed
+  end
+
+  def self.meta(*attrs)
+    new(*attrs).meta
+  end
+
+  def processed
+    return resource unless parameters.present?
+
+    resource.order(parameters.to_h)
+  end
+
+  def meta
+    return {} unless parameters.present?
+
+    {
+      'sort' => parameters.to_h,
+    }
+  end
+end
+end
+end
+end

data/lib/drillbit/responses/invalid_api_request.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'drillbit/errors/invalid_api_request'
+
+module  Drillbit
+module  Responses
+class   InvalidApiRequest
+  def self.call(env)
+    error = Drillbit::Errors::InvalidApiRequest.new(accept_header: env['HTTP_ACCEPT'])
+
+    [
+      error.http_status,  # HTTP Status Code
+      {},                 # Response Headers
+      [error.to_json],  # Message
+    ]
+  end
+end
+end
+end

data/lib/drillbit/responses/invalid_subdomain.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'drillbit/errors/invalid_subdomain'
+
+module  Drillbit
+module  Responses
+class   InvalidSubdomain
+  def self.call(env)
+    error = Drillbit::Errors::InvalidSubdomain.new(http_host: env['HTTP_HOST'])
+
+    [
+      error.http_status,  # HTTP Status Code
+      {},                 # Response Headers
+      [error.to_json],  # Message
+    ]
+  end
+end
+end
+end

data/lib/drillbit/responses/invalid_token.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'drillbit/errors/invalid_token'
+
+module  Drillbit
+module  Responses
+class   InvalidToken
+  def self.call(_env, application_name:)
+    error = Drillbit::Errors::InvalidToken.new
+
+    [
+      error.http_status, # HTTP Status Code
+      {                  # Response Headers
+        'WWW-Authenticate' => %Q{Token realm="#{application_name}"},
+      },
+      [error.to_json],   # Message
+    ]
+  end
+end
+end
+end