apill 2.9.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57ee7efdfee5d8f2b2425c1d8a1683983c0d5c3d
-  data.tar.gz: 3c8ae2f88ec48122895c01a8306cf1b6a22dadb3
+  metadata.gz: c68aa89f529dc07063d53a0f2e53e210b606c1bb
+  data.tar.gz: 6fc4b20a268b92b45d8e2e3f0b6ae195b118827d
 SHA512:
-  metadata.gz: 9c094f1dc4250418fcc89b54588e1585dfa66e5165dcee4c16b26444ddcb40315b01baf7874fa5f2957f678ab66dcddd7fa74e2d35d8f036af3e11175f859b7d
-  data.tar.gz: 3a62bad4d957827247fed3eb561eed9c61df95e20b1bd54fe0153d62ea2c76d565b265df982182ee3ee2583129d1786f1de8bea45bab15180fa1de6d75716446
+  metadata.gz: 02544a5f552ca8205ccd6aff687b60460f001c06b49db580ebfc9ad2cc841e5af9af65440af2494d1ba3f4baf6c56b002d68ce1afc720b90c5b0192d62d7c509
+  data.tar.gz: 9ac237ebc9b635993885a286f8b22353c98c655efc68fde7c50056dba9cbc332298465e328bcc80c8cf23cc6a0f44eab59c21aa381943c06a43c54993fe8a4a5

data/lib/apill/errors/invalid_api_request_error.rb

@@ -2,25 +2,27 @@ require 'human_error'
 
 module  Apill
 module  Errors
-class   InvalidApiRequestError < HumanError::Errors::RequestError
+class   InvalidApiRequestError < RuntimeError
+  include HumanError::Error
+
   attr_accessor :accept_header
 
   def http_status
     400
   end
 
-  def developer_message
+  def title
+    'Invalid API Request'
+  end
+
+  def detail
     'The accept header that you passed in the request cannot be parsed, ' \
     'please refer to the documentation to verify.'
   end
 
-  def developer_details
+  def source
     { accept_header: accept_header }
   end
-
-  def friendly_message
-    "Sorry! We couldn't understand what you were trying to ask us to do."
-  end
 end
 end
 end

data/lib/apill/errors/invalid_subdomain_error.rb

@@ -2,25 +2,27 @@ require 'human_error'
 
 module  Apill
 module  Errors
-class   InvalidSubdomainError < HumanError::Errors::RequestError
+class   InvalidSubdomainError < RuntimeError
+  include HumanError::Error
+
   attr_accessor :http_host
 
   def http_status
     404
   end
 
-  def developer_message
+  def title
+    'Invalid Subdomain'
+  end
+
+  def detail
     'The resource you attempted to access is either not authorized for the ' \
     'authenticated user or does not exist.'
   end
 
-  def developer_details
+  def source
     { http_host: http_host }
   end
-
-  def friendly_message
-    'Sorry! The resource you tried to access does not exist.'
-  end
 end
 end
 end

data/lib/apill/parameters/filter.rb

@@ -0,0 +1,23 @@
+module  Apill
+class   Parameters
+class   Filter
+  attr_accessor :raw_parameters
+
+  def initialize(raw_parameters)
+    self.raw_parameters = raw_parameters
+  end
+
+  def each_with_object(memoized)
+    raw_parameters.each do |raw_parameter|
+      next if raw_parameter[0] == 'query' ||
+              raw_parameter[1] == '' ||
+              raw_parameter[1].nil?
+
+      memoized = yield raw_parameter[0], raw_parameter[1], memoized
+    end
+
+    memoized
+  end
+end
+end
+end

data/lib/apill/parameters/index.rb

@@ -0,0 +1,17 @@
+module  Apill
+class   Parameters
+class   Index
+  DEFAULT_QUERY = '*'
+
+  attr_accessor :raw_parameters
+
+  def initialize(raw_parameters)
+    self.raw_parameters = raw_parameters
+  end
+
+  def query
+    raw_parameters['query'] || raw_parameters['q']
+  end
+end
+end
+end

data/lib/apill/parameters/page.rb

@@ -0,0 +1,22 @@
+module  Apill
+class   Parameters
+class   Page
+  DEFAULT_STARTING_PAGE = 1
+  DEFAULT_PAGE_SIZE     = 25
+
+  attr_accessor :raw_parameters
+
+  def initialize(raw_parameters)
+    self.raw_parameters = raw_parameters
+  end
+
+  def page_number
+    raw_parameters['number'] || DEFAULT_STARTING_PAGE
+  end
+
+  def per_page
+    raw_parameters['size'] || DEFAULT_PAGE_SIZE
+  end
+end
+end
+end

data/lib/apill/parameters/sort.rb

@@ -0,0 +1,27 @@
+module  Apill
+class   Parameters
+class   Sort
+  DESCENDING_PREFIX = '-'
+
+  attr_accessor :raw_parameters
+
+  def initialize(raw_parameters)
+    self.raw_parameters = raw_parameters ? raw_parameters.split(',') : ['-created_at']
+  end
+
+  def to_h
+    @to_h ||= Hash[to_a]
+  end
+
+  def to_a
+    @to_a ||= raw_parameters.map do |raw_parameter|
+      if raw_parameter.start_with?(DESCENDING_PREFIX)
+        [raw_parameter[1..-1], 'desc']
+      else
+        [raw_parameter, 'asc']
+      end
+    end
+  end
+end
+end
+end

data/lib/apill/resource/model.rb

@@ -0,0 +1,42 @@
+require 'apill/resource/processors/filtering'
+require 'apill/resource/processors/sorting'
+require 'apill/resource/processors/paging'
+require 'apill/resource/processors/indexing'
+
+module  Apill
+module  Resource
+class   Model
+  DEFAULT_PROCESSORS = %w{filtering sorting paging indexing}
+
+  attr_accessor :resource,
+                :parameters,
+                :processors
+
+  def initialize(resource:, parameters:, **options)
+    self.resource   = resource
+    self.parameters = parameters
+    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 "::Apill::Resource::Processors::#{processor.capitalize}"
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,63 @@
+require 'apill/parameters/filter'
+
+module Apill
+module Resource
+module Processors
+class  Filtering
+  attr_accessor :resource,
+                :parameters
+
+  def initialize(resource, parameters = {})
+    self.resource   = resource
+    self.parameters = Parameters::Filter.new(parameters['filter'] || {})
+  end
+
+  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/apill/resource/processors/indexing.rb

@@ -0,0 +1,32 @@
+require 'apill/parameters/index'
+
+module Apill
+module Resource
+module Processors
+class  Indexing
+  attr_accessor :resource,
+                :parameters
+
+  def initialize(resource, parameters)
+    self.resource   = resource
+    self.parameters = Parameters::Index.new(parameters['filter'] || {})
+  end
+
+  def self.processed(*attrs)
+    new(*attrs).processed
+  end
+
+  def self.meta(*_attrs)
+    {}
+  end
+
+  def processed
+    return resource unless resource.respond_to?(:for_query) &&
+                           parameters.query
+
+    resource.for_query(parameters.query)
+  end
+end
+end
+end
+end

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

@@ -0,0 +1,39 @@
+require 'apill/parameters/page'
+
+module  Apill
+module  Resource
+module  Processors
+class   Paging
+  attr_accessor :resource,
+                :parameters
+
+  def initialize(resource, parameters = {})
+    self.resource   = resource
+    self.parameters = Parameters::Page.new(parameters['page'] || {})
+  end
+
+  def self.processed(*attrs)
+    new(*attrs).processed
+  end
+
+  def self.meta(*attrs)
+    new(*attrs).meta
+  end
+
+  def processed
+    resource.page(parameters.page_number).
+             per(parameters.per_page)
+  end
+
+  def meta
+    {
+      'total-pages'   => processed.total_pages,
+      'current-page'  => processed.current_page,
+      'previous-page' => processed.prev_page,
+      'next-page'     => processed.next_page,
+    }
+  end
+end
+end
+end
+end

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

@@ -0,0 +1,35 @@
+require 'apill/parameters/sort'
+
+module  Apill
+module  Resource
+module  Processors
+class   Sorting
+  attr_accessor :resource,
+                :parameters
+
+  def initialize(resource, parameters = {})
+    self.resource   = resource
+    self.parameters = Parameters::Sort.new(parameters['sort'])
+  end
+
+  def self.processed(*attrs)
+    new(*attrs).processed
+  end
+
+  def self.meta(*attrs)
+    new(*attrs).meta
+  end
+
+  def processed
+    resource.order(parameters.to_h)
+  end
+
+  def meta
+    {
+      'sort' => parameters.to_h,
+    }
+  end
+end
+end
+end
+end

data/lib/apill/resource.rb

@@ -0,0 +1,68 @@
+require 'apill/resource/model'
+require 'human_error/rescuable_resource'
+
+module  Apill
+module  Resource
+  module ClassMethods
+    def plural_resource_name
+      name[/(\w+)Controller\z/, 1].
+      underscore.
+      pluralize.
+      downcase
+    end
+
+    def singular_resource_name
+      name[/(\w+)Controller\z/, 1].
+      underscore.
+      singularize.
+      downcase
+    end
+  end
+
+  def self.included(base)
+    base.extend  ClassMethods
+    base.include HumanError::RescuableResource
+    base.include HumanError::VerifiableResource
+  end
+
+  def api_resource
+    @resource ||= Resource::Model.new(
+                    resource:   public_send(self.class.plural_resource_name),
+                    parameters: api_resource_params)
+  end
+
+  def api_resource_params
+    params.permit(sort:   String,
+                  page:   %i{
+                    number
+                    size
+                    offset
+                    limit
+                    cursor
+                  },
+                  filter: api_filterable_parameters)
+  end
+
+  def api_filterable_parameters
+    @api_filterable_parameters ||= begin
+      filter_params     = params.fetch(:filter, {})
+      scalar_params     = [:query]
+      array_params      = {}
+
+      api_filterable_attributes.each do |api_filterable_attribute|
+        if filter_params[api_filterable_attribute].class == Array
+          array_params[api_filterable_attribute] = []
+        else
+          scalar_params << api_filterable_attribute
+        end
+      end
+
+      scalar_params << array_params
+    end
+  end
+
+  def api_filterable_attributes
+    []
+  end
+end
+end

data/lib/apill/version.rb

@@ -1,3 +1,3 @@
 module Apill
-  VERSION = '2.9.0'
+  VERSION = '3.0.0'
 end

data/lib/apill.rb

@@ -1,15 +1,10 @@
-require 'kaminari'
-
 require 'apill/version'
 
 require 'apill/configuration'
 require 'apill/matchers/accept_header_matcher'
 require 'apill/matchers/subdomain_matcher'
 require 'apill/matchers/version_matcher'
-require 'apill/mixins/indexable'
-require 'apill/mixins/sortable'
-require 'apill/mixins/queryable'
-require 'apill/mixins/pageable'
+require 'apill/resource'
 require 'apill/serializers/json_api'
 
 require 'apill/middleware/api_request'

data/spec/apill/errors/invalid_api_request_error_spec.rb

@@ -10,29 +10,20 @@ describe  InvalidApiRequestError do
     expect(error.http_status).to eql 400
   end
 
-  it 'has a code of 1007' do
-    expect(error.code).to eql 1007
+  it 'has a code' do
+    expect(error.code).to eql 'errors.invalid_api_request_error'
   end
 
-  it 'has a knowledgebase article ID of 1234567890' do
-    expect(error.knowledgebase_article_id).to eql '1234567890'
+  it 'can output the detail' do
+    expect(error.detail).to eql 'The accept header that you passed in the ' \
+                                'request cannot be parsed, please refer to ' \
+                                'the documentation to verify.'
   end
 
-  it 'can output the developer message' do
-    expect(error.developer_message).to eql 'The accept header that you passed in the ' \
-                                           'request cannot be parsed, please refer to ' \
-                                           'the documentation to verify.'
-  end
-
-  it 'can output the developer details' do
+  it 'can output the source' do
     error = InvalidApiRequestError.new accept_header: 'foo'
 
-    expect(error.developer_details).to eql(accept_header: 'foo')
-  end
-
-  it 'can output the friendly message' do
-    expect(error.friendly_message).to eql "Sorry! We couldn't understand what you were " \
-                                          'trying to ask us to do.'
+    expect(error.source).to eql(accept_header: 'foo')
   end
 end
 end

data/spec/apill/errors/invalid_subdomain_error_spec.rb

@@ -10,29 +10,20 @@ describe  InvalidSubdomainError do
     expect(error.http_status).to eql 404
   end
 
-  it 'has a code of 1010' do
-    expect(error.code).to eql 1010
+  it 'has a code' do
+    expect(error.code).to eql 'errors.invalid_subdomain_error'
   end
 
-  it 'has a knowledgebase article ID of 1234567890' do
-    expect(error.knowledgebase_article_id).to eql '1234567890'
-  end
-
-  it 'can output the developer message' do
-    expect(error.developer_message).to eql \
+  it 'can output the detail' do
+    expect(error.detail).to eql \
       'The resource you attempted to access is either not authorized for the ' \
       'authenticated user or does not exist.'
   end
 
-  it 'can output the developer details' do
+  it 'can output the source' do
     error = InvalidSubdomainError.new http_host: 'foo'
 
-    expect(error.developer_details).to eql(http_host: 'foo')
-  end
-
-  it 'can output the friendly message' do
-    expect(error.friendly_message).to eql \
-      'Sorry! The resource you tried to access does not exist.'
+    expect(error.source).to eql(http_host: 'foo')
   end
 end
 end

data/spec/apill/invalid_subdomain_response_spec.rb

@@ -3,43 +3,39 @@ require 'apill/responses/invalid_subdomain_response'
 
 module    Apill
 module    Responses
-describe  InvalidSubdomainResponse do
-  before(:each) do
-    HumanError.configuration.api_error_documentation_url = 'http://error.com'
-    HumanError.configuration.knowledgebase_url           = 'http://knowledge.com'
-    HumanError.configuration.api_version                 = '1'
-  end
-
+describe  InvalidSubdomainResponse, singletons: HumanError::Configuration do
   it 'returns the proper response' do
-    request  = { 'HTTP_HOST' => 'api.example.com' }
-    response = InvalidSubdomainResponse.call(request)
+    HumanError.configuration.url_mappings = {
+      'external_documentation_urls'  => {
+        'errors.invalid_subdomain_response' => 'http://example.com/foo',
+      },
+      'developer_documentation_urls' => {
+        'errors.invalid_subdomain_response' => 'http://example.com/foo',
+      },
+    }
+
+    request                   = { 'HTTP_HOST' => 'api.example.com' }
+    status, headers, response = InvalidSubdomainResponse.call(request)
 
-    expect(response).to eql(
-      [
-        404,
-        {},
-        [
-          '{' \
-            '"error":' \
-            '{' \
-              '"status":404,' \
-              '"code":1010,' \
-              '"developer_documentation_uri":"http://error.com/1010?version=1",' \
-              '"customer_support_uri":"http://knowledge.com/1234567890",' \
-              '"developer_message_key":"errors.invalid.subdomain.error.developer",' \
-              '"developer_message":"The resource you attempted to access is either not ' \
-                                   'authorized for the authenticated user or does not ' \
-                                   'exist.",' \
-              '"developer_details":' \
-                '{' \
-                  '"http_host":"api.example.com"' \
-                '},' \
-              '"friendly_message_key":"errors.invalid.subdomain.error.friendly",' \
-              '"friendly_message":"Sorry! The resource you tried to access does not ' \
-                                  'exist."' \
-            '}' \
-          '}',
-        ],
+    expect(status).to                 eql 404
+    expect(headers).to                eql({})
+    expect(JSON.load(response[0])).to include(
+      'errors'              => [
+        include(
+          'id'     => match(/[a-f0-9\-]+/),
+          'links'  => {
+            'about'         => nil,
+            'documentation' => nil,
+          },
+          'status' => 404,
+          'code'   => 'errors.invalid_subdomain_error',
+          'title'  => 'Invalid Subdomain',
+          'detail' => 'The resource you attempted to access is either not authorized ' \
+                      'for the authenticated user or does not exist.',
+          'source' => {
+            'http_host'     => 'api.example.com',
+          },
+        ),
       ],
     )
   end