apill 1.6.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6e916c78acf4e6b77bba21330da5ec51c64dc14
-  data.tar.gz: 5a52f7ab6a1ab045168db125dccf391fbde97e5b
+  metadata.gz: 974dc18ca764506d1a544244dfb65b70ce344ec7
+  data.tar.gz: a74c5b8c216e451a7d25015e623363b2b0348b2e
 SHA512:
-  metadata.gz: bbf3a7730599ec3d42223988e7e9732532dd72bde970aff017345c1cb4a3b959c7b7ae441f6b14795cac269fe944d9fbdfd92c2567e2f81ae76383bb523406dd
-  data.tar.gz: 882474601d4956b23b8aa815cc2ca91318639de79d26614e94694902db5c119332dfdfafa7b6ddf48ead4dab0a87a657320f0b4fca8d5766a720b39e92a7c07c
+  metadata.gz: 9e248544358f6cf0a0559504b360ca48ba560fdb88a59b23e6007acfddbe67c1c30e7e5de9abcfa3a2191c8d55065af654f4f685151d7c1cce61edc540e7afee
+  data.tar.gz: 0cd92dc06458725f440594001bce76f56a00625f88ee2d9afe56981972ac54c4d838ed50eaa1bdbfdbe8f008646bcf02c3614fe2bbe0d2fd4e8f6b99c898eb7b

data/lib/apill/configuration.rb

@@ -0,0 +1,24 @@
+module  Apill
+  class Configuration
+    attr_accessor \
+      :allowed_subdomains,
+      :application_name,
+      :default_api_version
+
+    def to_h
+      {
+        allowed_subdomains:  allowed_subdomains,
+        application_name:    application_name,
+        default_api_version: api_version,
+      }
+    end
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+end

data/lib/apill/errors/invalid_subdomain_error.rb

@@ -0,0 +1,26 @@
+require 'human_error'
+
+module  Apill
+module  Errors
+class   InvalidSubdomainError < HumanError::Errors::RequestError
+  attr_accessor :http_host
+
+  def http_status
+    404
+  end
+
+  def developer_message
+    'The resource you attempted to access is either not authorized for the ' \
+    'authenticated user or does not exist.'
+  end
+
+  def developer_details
+    { 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/matchers/accept_header_matcher.rb

@@ -8,7 +8,6 @@ class   AcceptHeaderMatcher
   def matches?(request)
     super
 
-    request.subdomains.first == 'api' &&
     accept_header.valid?
   end
 end

data/lib/apill/matchers/generic_matcher.rb

@@ -13,28 +13,31 @@ module  GenericMatcher
   end
 
   def matches?(request)
-    self.accept_header = get_accept_header(raw_header_from_headers: request.headers['Accept'],
-                                           raw_header_from_params:  request.params['accept'])
+    self.application   = request['API_APPLICATION_NAME']
+    self.accept_header = get_accept_header(raw_header_from_headers: request['HTTP_ACCEPT'],
+                                           raw_header_from_params:  request['QUERY_STRING'])
   end
 
   private
 
   def get_accept_header(raw_header_from_headers:, raw_header_from_params:)
-    header_from_header = accept_header_from_header(raw_header_from_headers)
+    header_from_header = accept_header_from_string(raw_header_from_headers)
 
-    return header_from_header if header_from_header.valid? || raw_header_from_params.nil?
+    return header_from_header if header_from_header.valid? ||
+                                 raw_header_from_params.to_s.empty?
 
-    accept_header_from_header(raw_header_from_params)
+    accept_header_from_params(raw_header_from_params)
   end
 
-  def accept_header_from_header(raw_header_from_headers='')
+  def accept_header_from_string(raw_header_from_headers='')
     Apill::AcceptHeader.new(application:  application,
                             header:       raw_header_from_headers)
   end
 
   def accept_header_from_params(raw_header_from_params='')
-    Apill::AcceptHeader.new(application:  application,
-                            header:       raw_header_from_params)
+    header_from_params = raw_header_from_params[%r{(?:\A|&)accept=(.+?)(?=\z|&)}, 1]
+
+    accept_header_from_string(header_from_params)
   end
 end
 end

data/lib/apill/matchers/subdomain_matcher.rb

@@ -1,17 +1,19 @@
 module  Apill
 module  Matchers
 class   SubdomainMatcher
-  def initialize(subdomain: 'api')
-    self.subdomain = subdomain
+  def initialize(allowed_subdomains: ['api'])
+    self.allowed_subdomains = Array(allowed_subdomains)
   end
 
   def matches?(request)
-    request.subdomains.first == subdomain
+    request_subdomain = request['HTTP_HOST'][/\A([a-z\-]+)/i, 1]
+
+    allowed_subdomains.include? request_subdomain
   end
 
   protected
 
-  attr_accessor :subdomain
+  attr_accessor :allowed_subdomains
 end
 end
 end

data/lib/apill/matchers/version_matcher.rb

@@ -1,5 +1,4 @@
 require 'apill/matchers/generic_matcher'
-require 'apill/errors/invalid_api_request_error'
 
 module  Apill
 module  Matchers
@@ -12,10 +11,7 @@ class   VersionMatcher
   def matches?(request)
     super
 
-    raise Apill::Errors::InvalidApiRequestError unless accept_header.valid?
-
-    request.subdomains.first == 'api' &&
-    requested_version        == version_constraint
+    requested_version == version_constraint
   end
 
   private

data/lib/apill/middleware/api_request.rb

@@ -0,0 +1,32 @@
+require 'json'
+require 'apill/configuration'
+require 'apill/matchers/subdomain_matcher'
+require 'apill/matchers/invalid_api_request_matcher'
+require 'apill/responses/invalid_api_request_response'
+require 'apill/responses/invalid_subdomain_response'
+
+module  Apill
+module  Middleware
+class   ApiRequest
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env['API_APPLICATION_NAME'] = Apill.configuration.application_name
+
+    if Matchers::SubdomainMatcher.new(allowed_subdomains: Apill.configuration.allowed_subdomains).
+                                  matches?(env)
+
+      if Matchers::AcceptHeaderMatcher.new.matches?(env)
+        @app.call(env)
+      else
+        Responses::InvalidApiRequestResponse.call(env)
+      end
+    else
+      Responses::InvalidSubdomainResponse.call(env)
+    end
+  end
+end
+end
+end

data/lib/apill/responses/invalid_subdomain_response.rb

@@ -0,0 +1,17 @@
+require 'apill/errors/invalid_subdomain_error'
+
+module  Apill
+module  Responses
+class   InvalidSubdomainResponse
+  def self.call(env)
+    error = Apill::Errors::InvalidSubdomainError.new(http_host: env['HTTP_HOST'])
+
+    [
+      error.http_status,  # HTTP Status Code
+      {},                 # Response Headers
+      [ error.to_json ],  # Message
+    ]
+  end
+end
+end
+end

data/lib/apill/version.rb

@@ -1,3 +1,3 @@
 module Apill
-  VERSION = '1.6.0'
+  VERSION = '2.0.0'
 end

data/spec/apill/errors/invalid_subdomain_error_spec.rb

@@ -0,0 +1,39 @@
+require 'rspectacular'
+require 'apill/errors/invalid_subdomain_error'
+
+module    Apill
+module    Errors
+describe  InvalidSubdomainError do
+  let(:error) { InvalidSubdomainError.new }
+
+  it 'has a status of 404' do
+    expect(error.http_status).to eql 404
+  end
+
+  it 'has a code of 1010' do
+    expect(error.code).to eql 1010
+  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 \
+      '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
+    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.'
+  end
+end
+end
+end

data/spec/apill/invalid_subdomain_response_spec.rb

@@ -0,0 +1,45 @@
+require 'rspectacular'
+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
+
+  it 'returns the proper response' do
+    request  = { 'HTTP_HOST' => 'api.example.com' }
+    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."' \
+            '}' \
+          '}'
+        ]
+      ]
+    )
+  end
+end
+end
+end

data/spec/apill/matchers/accept_header_matcher_spec.rb

@@ -0,0 +1,103 @@
+require 'rspectacular'
+require 'apill/matchers/accept_header_matcher'
+
+module    Apill
+module    Matchers
+describe  AcceptHeaderMatcher do
+  it 'matches if the subdomain is API and the accept header is valid' do
+    request = {
+      'HTTP_ACCEPT'          => 'application/vnd.matrix+zion;version=1.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    matcher = AcceptHeaderMatcher.new
+
+    expect(matcher.matches?(request)).to be_a TrueClass
+  end
+
+  it 'matches if the subdomain is API and the accept header is passed in as ' \
+     'a parameter' do
+
+    request = {
+      'QUERY_STRING'         => 'accept=application/vnd.matrix+zion;version=1.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    matcher = AcceptHeaderMatcher.new
+
+    expect(matcher.matches?(request)).to be_a TrueClass
+  end
+
+  it 'matches if the subdomain is API and the accept header is passed in as a ' \
+     'secondary parameter' do
+
+    request = {
+      'QUERY_STRING'         => 'first=my_param&accept=application/vnd.matrix+zion;version=1.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    matcher = AcceptHeaderMatcher.new
+
+    expect(matcher.matches?(request)).to be_a TrueClass
+  end
+
+  it 'matches the header accept header if the subdomain is API and the accept header ' \
+     'is passed both as a valid header and as a parameter' do
+
+    request = {
+      'HTTP_ACCEPT'          => 'application/vnd.matrix+zion;version=1.0.0',
+      'QUERY_STRING'         => 'accept=application/vnd.matrix+zion;version=2.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    matcher = AcceptHeaderMatcher.new
+    matcher.matches?(request)
+
+    expect(matcher.accept_header.version).to eql '1.0.0'
+  end
+
+  it 'matches the accept header parameter if the subdomain is API and the accept ' \
+     'header is passed both as an invalid header as well as as a parameter' do
+
+    request = {
+      'HTTP_ACCEPT'          => 'application/vndmatrix+zion;version=1.0.0',
+      'QUERY_STRING'         => 'accept=application/vnd.matrix+zion;version=2.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    matcher = AcceptHeaderMatcher.new
+    matcher.matches?(request)
+
+    expect(matcher.accept_header.version).to eql '2.0.0'
+  end
+
+  it 'matches the accept header parameter if the subdomain is API and the accept ' \
+     'header is passed both as an invalid header as well as as a parameter' do
+
+    request = {
+      'HTTP_ACCEPT'          => 'application/vndmatrix+zion;version=1.0.0',
+      'QUERY_STRING'         => '',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    matcher = AcceptHeaderMatcher.new
+    matcher.matches?(request)
+
+    expect(matcher.accept_header.raw_accept_header).to eql \
+      'application/vndmatrix+zion;version=1.0.0'
+  end
+
+  it 'does not match if the subdomain is API but the accept header is invalid' do
+    request = {
+      'HTTP_ACCEPT'          => 'application/vndmatrix+zion;version=1.0.0',
+      'QUERY_STRING'         => '',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    matcher = AcceptHeaderMatcher.new
+
+    expect(matcher.matches?(request)).to be_a FalseClass
+  end
+end
+end
+end

data/spec/apill/matchers/invalid_api_request_matcher_spec.rb

@@ -0,0 +1,21 @@
+require 'ostruct'
+require 'rspectacular'
+require 'apill/matchers/invalid_api_request_matcher'
+
+module    Apill
+module    Matchers
+describe  InvalidApiRequestMatcher do
+  it 'is the inverse of whether the accept header matches' do
+    request = {
+      'HTTP_HOST'            => 'api.example.com',
+      'HTTP_ACCEPT'          => 'application/vnd.matrix+zion;version=1.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    matcher = InvalidApiRequestMatcher.new
+
+    expect(matcher.matches?(request)).to be_a FalseClass
+  end
+end
+end
+end

data/spec/apill/matchers/subdomain_matcher_spec.rb

@@ -0,0 +1,46 @@
+require 'rspectacular'
+require 'apill/matchers/subdomain_matcher'
+
+module    Apill
+module    Matchers
+describe  SubdomainMatcher do
+  it 'matches if the subdomain is API' do
+    matcher = SubdomainMatcher.new
+    request = { 'HTTP_HOST' => 'api.example.com' }
+
+    expect(matcher.matches?(request)).to be_a TrueClass
+  end
+
+  it 'matches if the first subdomain is API' do
+    matcher = SubdomainMatcher.new
+    request = { 'HTTP_HOST' => 'api.matrix.example.com' }
+
+    expect(matcher.matches?(request)).to be_a TrueClass
+  end
+
+  it 'does not match if the first subdomain is not API' do
+    matcher = SubdomainMatcher.new
+    request = { 'HTTP_HOST' => 'matrix.example.com' }
+
+    expect(matcher.matches?(request)).to be_a FalseClass
+  end
+
+  it 'allows the matched subdomain to be specified' do
+    matcher = SubdomainMatcher.new(allowed_subdomains: 'matrix')
+    request = { 'HTTP_HOST' => 'matrix.example.com' }
+
+    expect(matcher.matches?(request)).to be_a TrueClass
+  end
+
+  it 'allows more than one subdomain to be matched' do
+    matcher = SubdomainMatcher.new(allowed_subdomains: %w{api matrix})
+
+    request = { 'HTTP_HOST' => 'matrix.example.com' }
+    expect(matcher.matches?(request)).to be_a TrueClass
+
+    request = { 'HTTP_HOST' => 'api.example.com' }
+    expect(matcher.matches?(request)).to be_a TrueClass
+  end
+end
+end
+end

data/spec/apill/matchers/version_matcher_spec.rb

@@ -0,0 +1,66 @@
+require 'rspectacular'
+require 'apill/matchers/version_matcher'
+
+module    Apill
+module    Matchers
+describe  VersionMatcher do
+  context 'when the version is passed in the accept header' do
+    it 'does not match if the subdomain is API but the requested version does not ' \
+       'equal the version constraint' do
+
+      request = {
+        'API_APPLICATION_NAME' => 'matrix',
+        'HTTP_ACCEPT'          => 'application/vnd.matrix+zion;version=10.0',
+      }
+
+      matcher = VersionMatcher.new(version_constraint: '10.1')
+
+      expect(matcher.matches?(request)).to be_a FalseClass
+    end
+
+    it 'does match if the subdomain is API and the requested version equals the ' \
+       'version constraint' do
+
+      request = {
+        'API_APPLICATION_NAME' => 'matrix',
+        'HTTP_ACCEPT'          => 'application/vnd.matrix+zion;version=10.0',
+      }
+
+      matcher = VersionMatcher.new(version_constraint: '10.0')
+
+      expect(matcher.matches?(request)).to be_a TrueClass
+    end
+  end
+
+  context 'when the version is not passed in the accept header' do
+    it 'does not match if the subdomain is API but the requested version does not ' \
+       'equal the version constraint' do
+
+      request = {
+        'API_APPLICATION_NAME' => 'matrix',
+        'HTTP_ACCEPT'          => 'application/vnd.matrix+zion',
+      }
+
+      matcher = VersionMatcher.new(version_constraint: '10.1',
+                                   default_version:    '10.0')
+
+      expect(matcher.matches?(request)).to be_a FalseClass
+    end
+
+    it 'does match if the subdomain is API and the requested version equals the ' \
+       'version constraint' do
+
+      request = {
+        'API_APPLICATION_NAME' => 'matrix',
+        'HTTP_ACCEPT'          => 'application/vnd.matrix+zion',
+      }
+
+      matcher = VersionMatcher.new(version_constraint: '10.0',
+                                   default_version:    '10.0')
+
+      expect(matcher.matches?(request)).to be_a TrueClass
+    end
+  end
+end
+end
+end

data/spec/apill/middleware/api_request_spec.rb

@@ -0,0 +1,114 @@
+require 'rspectacular'
+require 'apill/middleware/api_request'
+
+HumanError.configure do |config|
+  config.api_error_documentation_url = 'http://error.com'
+  config.knowledgebase_url           = 'http://knowledge.com'
+  config.api_version                 = '1'
+end
+
+Apill.configure do |config|
+  config.allowed_subdomains = %w{api}
+  config.application_name   = 'matrix'
+end
+
+module    Apill
+module    Middleware
+describe  ApiRequest do
+  let(:app) { lambda { |env| [200, {}, 'response'] } }
+
+  it 'does not allow requests if they are not for an allowed subdomain' do
+    api_request_middleware = ApiRequest.new(app)
+
+    request = {
+      'HTTP_HOST'            => 'notvalid.example.com',
+      'HTTP_ACCEPT'          => '',
+      'QUERY_STRING'         => 'first=my_param&accept=application/vnd.silent+zion;version=1.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    status, headers, response = api_request_middleware.call(request)
+
+    expect(status).to   eql 404
+    expect(headers).to  eql Hash.new
+    expect(response).to eql(
+      [
+        '{' \
+          '"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":"notvalid.example.com"' \
+              '},' \
+            '"friendly_message_key":"errors.invalid.subdomain.error.friendly",' \
+            '"friendly_message":"Sorry! The resource you tried to access does not exist."' \
+          '}' \
+        '}'
+      ]
+    )
+  end
+
+  it 'does not allow requests if they are for an allowed subdomain but does ' \
+     'not have a valid accept header' do
+
+    api_request_middleware = ApiRequest.new(app)
+
+    request = {
+      'HTTP_HOST'            => 'api.example.com',
+      'HTTP_ACCEPT'          => '',
+      'QUERY_STRING'         => 'first=my_param&accept=application/vnd.silent+zion;version=1.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    status, headers, response = api_request_middleware.call(request)
+
+    expect(status).to   eql 400
+    expect(headers).to  eql Hash.new
+    expect(response).to eql(
+      [
+        '{' \
+          '"error":' \
+          '{' \
+            '"status":400,' \
+            '"code":1007,' \
+            '"developer_documentation_uri":"http://error.com/1007?version=1",' \
+            '"customer_support_uri":"http://knowledge.com/1234567890",' \
+            '"developer_message_key":"errors.invalid.api.request.error.developer",' \
+            '"developer_message":"The accept header that you passed in the request cannot be parsed, please refer to the documentation to verify.",' \
+            '"developer_details":' \
+              '{' \
+                '"accept_header":""' \
+              '},' \
+            '"friendly_message_key":"errors.invalid.api.request.error.friendly",' \
+            '"friendly_message":"Sorry! We couldn\'t understand what you were trying to ask us to do."' \
+          '}' \
+        '}'
+      ]
+    )
+  end
+
+  it 'does allow requests if both the subdomain and the accept header are valid' do
+    api_request_middleware = ApiRequest.new(app)
+
+    request = {
+      'HTTP_HOST'            => 'api.example.com',
+      'HTTP_ACCEPT'          => 'application/vnd.matrix+zion;version=1.0.0',
+      'QUERY_STRING'         => 'first=my_param&accept=application/vnd.matrix+zion;version=1.0.0',
+      'API_APPLICATION_NAME' => 'matrix',
+    }
+
+    status, headers, response = api_request_middleware.call(request)
+
+    expect(status).to   eql 200
+    expect(headers).to  eql Hash.new
+    expect(response).to eql 'response'
+  end
+end
+end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: apill
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 2.0.0
 platform: ruby
 authors:
 - jfelchner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-28 00:00:00.000000000 Z
+date: 2014-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: human_error
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.13'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -44,47 +44,66 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.38'
+        version: '0.50'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.38'
+        version: '0.50'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 description: ''
 email: accounts+git@thekompanee.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.md
-- LICENSE
+extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
 - Rakefile
 - lib/apill.rb
 - lib/apill/accept_header.rb
+- lib/apill/configuration.rb
 - lib/apill/errors/invalid_api_request_error.rb
+- lib/apill/errors/invalid_subdomain_error.rb
 - lib/apill/matchers/accept_header_matcher.rb
 - lib/apill/matchers/generic_matcher.rb
 - lib/apill/matchers/invalid_api_request_matcher.rb
 - lib/apill/matchers/subdomain_matcher.rb
 - lib/apill/matchers/version_matcher.rb
+- lib/apill/middleware/api_request.rb
 - lib/apill/responses/invalid_api_request_response.rb
+- lib/apill/responses/invalid_subdomain_response.rb
 - lib/apill/version.rb
-- spec/lib/apill/accept_header_spec.rb
-- spec/lib/apill/errors/invalid_api_request_error_spec.rb
-- spec/lib/apill/matchers/accept_header_matcher_spec.rb
-- spec/lib/apill/matchers/invalid_api_request_matcher_spec.rb
-- spec/lib/apill/matchers/subdomain_matcher_spec.rb
-- spec/lib/apill/matchers/version_matcher_spec.rb
+- spec/apill/accept_header_spec.rb
+- spec/apill/errors/invalid_api_request_error_spec.rb
+- spec/apill/errors/invalid_subdomain_error_spec.rb
+- spec/apill/invalid_subdomain_response_spec.rb
+- spec/apill/matchers/accept_header_matcher_spec.rb
+- spec/apill/matchers/invalid_api_request_matcher_spec.rb
+- spec/apill/matchers/subdomain_matcher_spec.rb
+- spec/apill/matchers/version_matcher_spec.rb
+- spec/apill/middleware/api_request_spec.rb
 homepage: https://github.com/jfelchner/apill
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
-rdoc_options:
-- "--charset = UTF-8"
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -98,16 +117,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: apill
-rubygems_version: 2.3.0
+rubyforge_project: 
+rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: Common API functionality
 test_files:
-- spec/lib/apill/accept_header_spec.rb
-- spec/lib/apill/errors/invalid_api_request_error_spec.rb
-- spec/lib/apill/matchers/accept_header_matcher_spec.rb
-- spec/lib/apill/matchers/invalid_api_request_matcher_spec.rb
-- spec/lib/apill/matchers/subdomain_matcher_spec.rb
-- spec/lib/apill/matchers/version_matcher_spec.rb
+- spec/apill/accept_header_spec.rb
+- spec/apill/errors/invalid_api_request_error_spec.rb
+- spec/apill/errors/invalid_subdomain_error_spec.rb
+- spec/apill/invalid_subdomain_response_spec.rb
+- spec/apill/matchers/accept_header_matcher_spec.rb
+- spec/apill/matchers/invalid_api_request_matcher_spec.rb
+- spec/apill/matchers/subdomain_matcher_spec.rb
+- spec/apill/matchers/version_matcher_spec.rb
+- spec/apill/middleware/api_request_spec.rb
 has_rdoc: 

data/spec/lib/apill/matchers/accept_header_matcher_spec.rb

@@ -1,92 +0,0 @@
-require 'ostruct'
-require 'rspectacular'
-require 'apill/matchers/accept_header_matcher'
-
-module    Apill
-module    Matchers
-describe  AcceptHeaderMatcher do
-  it 'matches if the subdomain is API and the accept header is valid' do
-    request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion;version=1.0.0' },
-                             params:      {},
-                             subdomains:  [ 'api' ])
-
-    matcher = AcceptHeaderMatcher.new(application: 'matrix')
-
-    expect(matcher.matches?(request)).to be_truthy
-  end
-
-  it 'matches if the subdomain is API and the accept header is passed in as a parameter' do
-    request = OpenStruct.new(headers:     {},
-                             params:      { 'accept' => 'application/vnd.matrix+zion;version=1.0.0'  },
-                             subdomains:  [ 'api' ])
-
-    matcher = AcceptHeaderMatcher.new(application: 'matrix')
-
-    expect(matcher.matches?(request)).to be_truthy
-  end
-
-  it 'matches the header accept header if the subdomain is API and the accept header is passed both as a valid header and as a parameter' do
-    request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion;version=1.0.0' },
-                             params:      { 'accept' => 'application/vnd.matrix+zion;version=2.0.0'  },
-                             subdomains:  [ 'api' ])
-
-    matcher = AcceptHeaderMatcher.new(application: 'matrix')
-    matcher.matches?(request)
-
-    expect(matcher.accept_header.version).to eql '1.0.0'
-  end
-
-  it "matches the parameter's accept header if the subdomain is API and the accept header is passed both as an invalid header as well as as a parameter" do
-    request = OpenStruct.new(headers:     { 'Accept' => 'application/vndmatrix+zion;version=1.0.0' },
-                             params:      { 'accept' => 'application/vnd.matrix+zion;version=2.0.0'  },
-                             subdomains:  [ 'api' ])
-
-    matcher = AcceptHeaderMatcher.new(application: 'matrix')
-    matcher.matches?(request)
-
-    expect(matcher.accept_header.version).to eql '2.0.0'
-  end
-
-  it "matches the parameter's accept header if the subdomain is API and the accept header is passed both as an invalid header as well as as a parameter" do
-    request = OpenStruct.new(headers:     { 'Accept' => 'application/vndmatrix+zion;version=1.0.0' },
-                             params:      {},
-                             subdomains:  [ 'api' ])
-
-    matcher = AcceptHeaderMatcher.new(application: 'matrix')
-    matcher.matches?(request)
-
-    expect(matcher.accept_header.raw_accept_header).to eql 'application/vndmatrix+zion;version=1.0.0'
-  end
-
-  it 'does not match if the subdomain is not API but the accept header is valid' do
-    request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion' },
-                             params:      {},
-                             subdomains:  [ 'not-api' ])
-
-    matcher = AcceptHeaderMatcher.new(application: 'matrix')
-
-    expect(matcher.matches?(request)).to be_falsey
-  end
-
-  it 'does not match if the subdomain is API but the accept header is invalid' do
-    request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.' },
-                             params:      {},
-                             subdomains:  [ 'api' ])
-
-    matcher = AcceptHeaderMatcher.new(application: 'matrix')
-
-    expect(matcher.matches?(request)).to be_falsey
-  end
-
-  it 'does not match if neither the subdomain is API nor the accept header is valid' do
-    request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.' },
-                             params:      {},
-                             subdomains:  [ 'not-api' ])
-
-    matcher = AcceptHeaderMatcher.new(application: 'matrix')
-
-    expect(matcher.matches?(request)).to be_falsey
-  end
-end
-end
-end

data/spec/lib/apill/matchers/invalid_api_request_matcher_spec.rb

@@ -1,19 +0,0 @@
-require 'ostruct'
-require 'rspectacular'
-require 'apill/matchers/invalid_api_request_matcher'
-
-module    Apill
-module    Matchers
-describe  InvalidApiRequestMatcher do
-  it 'is the inverse of whether the accept header matches' do
-    request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion;version=1.0.0' },
-                             subdomains:  [ 'api' ],
-                             params:      {})
-
-    matcher = InvalidApiRequestMatcher.new(application: 'matrix')
-
-    expect(matcher.matches?(request)).to be_falsey
-  end
-end
-end
-end

data/spec/lib/apill/matchers/subdomain_matcher_spec.rb

@@ -1,41 +0,0 @@
-require 'ostruct'
-require 'rspectacular'
-require 'apill/matchers/subdomain_matcher'
-
-module    Apill
-module    Matchers
-describe  SubdomainMatcher do
-  it 'matches if the subdomain is API' do
-    request = OpenStruct.new(subdomains:  [ 'api' ])
-
-    matcher = SubdomainMatcher.new
-
-    expect(matcher.matches?(request)).to be_truthy
-  end
-
-  it 'matches if the first subdomain is API' do
-    request = OpenStruct.new(subdomains:  [ 'api', 'matrix' ])
-
-    matcher = SubdomainMatcher.new
-
-    expect(matcher.matches?(request)).to be_truthy
-  end
-
-  it 'does not match if the first subdomain is not API' do
-    request = OpenStruct.new(subdomains:  [ 'matrix' ])
-
-    matcher = SubdomainMatcher.new
-
-    expect(matcher.matches?(request)).to be_falsey
-  end
-
-  it 'allows the matched subdomain to be specified' do
-    request = OpenStruct.new(subdomains:  [ 'matrix' ])
-
-    matcher = SubdomainMatcher.new(subdomain: 'matrix')
-
-    expect(matcher.matches?(request)).to be_truthy
-  end
-end
-end
-end

data/spec/lib/apill/matchers/version_matcher_spec.rb

@@ -1,92 +0,0 @@
-require 'ostruct'
-require 'rspectacular'
-require 'apill/matchers/version_matcher'
-
-module    Apill
-module    Matchers
-describe  VersionMatcher do
-  it 'raises an error when the accept header is not valid' do
-    request = OpenStruct.new(headers:     { 'Accept' => 'matrix' },
-                             subdomains:  [ 'api' ],
-                             params:      {})
-
-    matcher = VersionMatcher.new
-
-    expect { matcher.matches?(request) }.to raise_error Apill::Errors::InvalidApiRequestError
-  end
-
-  context 'when the version is passed in the accept header' do
-    it 'does not match if the subdomain is not API but the request version is equal to the version constraint' do
-      request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion;version=10.0' },
-                               subdomains:  [ 'not-api' ],
-                               params:      {})
-
-      matcher = VersionMatcher.new(application:        'matrix',
-                                   version_constraint: '10.0')
-
-      expect(matcher.matches?(request)).to be_falsey
-    end
-
-    it 'does not match if the subdomain is API but the requested version does not equal the version constraint' do
-      request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion;version=10.0' },
-                               subdomains:  [ 'api' ],
-                               params:      {})
-
-      matcher = VersionMatcher.new(application:        'matrix',
-                                   version_constraint: '10.1')
-
-      expect(matcher.matches?(request)).to be_falsey
-    end
-
-    it 'does match if the subdomain is API and the requested version equals the version constraint' do
-      request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion;version=10.0' },
-                               subdomains:  [ 'api' ],
-                               params:      {})
-
-      matcher = VersionMatcher.new(application:        'matrix',
-                                   version_constraint: '10.0')
-
-      expect(matcher.matches?(request)).to be_truthy
-    end
-  end
-
-  context 'when the version is not passed in the accept header' do
-    it 'does not match if the subdomain is not API but the request version is equal to the version constraint' do
-      request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion' },
-                               subdomains:  [ 'not-api' ],
-                               params:      {})
-
-      matcher = VersionMatcher.new(application:        'matrix',
-                                   version_constraint: '10.0',
-                                   default_version:    '10.0')
-
-      expect(matcher.matches?(request)).to be_falsey
-    end
-
-    it 'does not match if the subdomain is API but the requested version does not equal the version constraint' do
-      request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion' },
-                               subdomains:  [ 'api' ],
-                               params:      {})
-
-      matcher = VersionMatcher.new(application:        'matrix',
-                                   version_constraint: '10.1',
-                                   default_version:    '10.0')
-
-      expect(matcher.matches?(request)).to be_falsey
-    end
-
-    it 'does match if the subdomain is API and the requested version equals the version constraint' do
-      request = OpenStruct.new(headers:     { 'Accept' => 'application/vnd.matrix+zion' },
-                               subdomains:  [ 'api' ],
-                               params:      {})
-
-      matcher = VersionMatcher.new(application:        'matrix',
-                                   version_constraint: '10.0',
-                                   default_version:    '10.0')
-
-      expect(matcher.matches?(request)).to be_truthy
-    end
-  end
-end
-end
-end