interpol 0.3.2 → 0.3.3

data/lib/interpol/sinatra/request_params_parser.rb

@@ -1,4 +1,5 @@
 require 'interpol/request_params_parser'
+require 'forwardable'
 
 module Interpol
   module Sinatra
@@ -11,89 +12,110 @@ module Interpol
     # it can take a config block.
     class RequestParamsParser
       def initialize(app, &block)
-        @app = app
-        hook_into(app, &block)
+        @original_app_instance = app
+        hook_into_app(&block)
       end
 
       def call(env)
-        @app.call(env)
+        @original_app_instance.call(env)
+      end
+
+      ConfigurationError = Class.new(StandardError)
+
+      # Sinatra dups the app before each request, so we need to
+      # receive the app instance as an argument here.
+      def validate_and_parse_params(app)
+        return unless app.settings.parse_params?
+        SingleRequestParamsParser.parse_params(config, app)
       end
 
     private
 
-      def hook_into(app, &block)
-        return if defined?(app.settings.interpol_config)
-        config = Configuration.default.customized_duplicate(&block)
+      attr_reader :config, :original_app_instance
+
+      def hook_into_app(&block)
+        return if defined?(@config)
+        check_configuration_validity
+
+        @config = Configuration.default.customized_duplicate(&block)
+        parser = self
 
-        app.class.class_eval do
+        original_app_instance.class.class_eval do
           alias unparsed_params params
-          helpers SinatraHelpers
-          set :interpol_config, config
+          set :request_params_parser, parser
           enable :parse_params unless settings.respond_to?(:parse_params)
           include SinatraOverriddes
         end
       end
 
-      module SinatraHelpers
-        # Make the config available at the instance level for convenience.
-        def interpol_config
-          self.class.interpol_config
-        end
+      def check_configuration_validity
+        return if original_app_instance.class.ancestors.include?(::Sinatra::Base)
 
-        def endpoint_definition
-          @endpoint_definition ||= begin
-            version = available_versions = nil
-
-            definition = interpol_config.endpoints.find_definition \
-              env.fetch('REQUEST_METHOD'), request.path, 'request', nil do |endpoint|
-                available_versions ||= endpoint.available_versions
-                interpol_config.api_version_for(env, endpoint).tap do |_version|
-                  version ||= _version
-                end
-              end
-
-            if definition == DefinitionFinder::NoDefinitionFound
-              interpol_config.request_version_unavailable(self, version, available_versions)
-            end
+        raise ConfigurationError, "#{self.class} must come last in the Sinatra " +
+                                  "middleware list but #{original_app_instance.class} " +
+                                  "currently comes after."
+      end
 
-            definition
-          end
+      # Handles finding parsing request params for a single request.
+      class SingleRequestParamsParser
+        def self.parse_params(config, app)
+          new(config, app).parse_params
         end
 
-        def params
-          (@_use_parsed_params && @_parsed_params) || super
+        def initialize(config, app)
+          @config = config
+          @app = app
         end
 
-        def validate_params
-          @_parsed_params ||= endpoint_definition.parse_request_params(params_to_parse)
+        def parse_params
+          endpoint_definition.parse_request_params(params_to_parse)
         rescue Interpol::ValidationError => error
           request_params_invalid(error)
         end
 
-        def request_params_invalid(error)
-          interpol_config.sinatra_request_params_invalid(self, error)
-        end
+      private
 
-        def with_parsed_params
-          @_use_parsed_params = true
-          validate_params if settings.parse_params?
-          yield
-        ensure
-          @_use_parsed_params = false
+        attr_reader :app, :config
+        extend Forwardable
+        def_delegators :app, :request
+
+        def endpoint_definition
+          version = available_versions = nil
+
+          definition = config.endpoints.find_definition \
+            request.env.fetch('REQUEST_METHOD'), request.path, 'request', nil do |endpoint|
+              available_versions ||= endpoint.available_versions
+              config.api_version_for(request.env, endpoint).tap do |_version|
+                version ||= _version
+              end
+            end
+
+          if definition == DefinitionFinder::NoDefinitionFound
+            config.request_version_unavailable(app, version, available_versions)
+          end
+
+          definition
         end
 
         # Sinatra includes a couple of "meta" params that are always
         # present in the params hash even though they are not declared
         # as params: splat and captures.
         def params_to_parse
-          unparsed_params.dup.tap do |p|
+          app.unparsed_params.dup.tap do |p|
             p.delete('splat')
             p.delete('captures')
           end
         end
+
+        def request_params_invalid(error)
+          config.sinatra_request_params_invalid(app, error)
+        end
       end
 
       module SinatraOverriddes
+        extend Forwardable
+        def_delegators :settings, :request_params_parser
+
         # We cannot access the full params (w/ path params) in a before hook,
         # due to the order that sinatra runs the hooks in relation to route
         # matching.
@@ -115,6 +137,17 @@ module Interpol
           return true unless block.respond_to?(:source_location)
           block.source_location.first.end_with?('sinatra/base.rb')
         end
+
+        def params
+          @_parsed_params || super
+        end
+
+        def with_parsed_params
+          @_parsed_params = request_params_parser.validate_and_parse_params(self)
+          yield
+        ensure
+          @_parsed_params = nil
+        end
       end
     end
   end

data/lib/interpol/stub_app.rb

@@ -13,29 +13,17 @@ module Interpol
       builder.app
     end
 
-    module Helpers
-      def interpol_config
-        self.class.interpol_config
-      end
-
-      def example_for(endpoint, version, message_type)
-        example = endpoint.find_example_for!(version, message_type)
-      rescue NoEndpointDefinitionFoundError
-        interpol_config.request_version_unavailable(self, version, endpoint.available_versions)
-      else
-        example.apply_filters(interpol_config.filter_example_data_blocks, request.env)
-      end
-    end
-
     # Private: Builds a stub sinatra app for the given interpol
     # configuration.
     class Builder
-      attr_reader :app
+      attr_reader :app, :config
 
       def initialize(config)
+        builder = self
+        @config = config
+
         @app = ::Sinatra.new do
-          set            :interpol_config, config
-          helpers        Helpers
+          set            :stub_app_builder, builder
           not_found      { JSON.dump(:error => "The requested resource could not be found") }
           before         { content_type "application/json;charset=utf-8" }
           get('/__ping') { JSON.dump(:message => "Interpol stub app running.") }
@@ -47,21 +35,31 @@ module Interpol
       end
 
       def build
-        @app.interpol_config.endpoints.each do |endpoint|
+        config.endpoints.each do |endpoint|
           app.send(endpoint.method, endpoint.route, &endpoint_definition(endpoint))
         end
       end
 
       def endpoint_definition(endpoint)
         lambda do
-          version = interpol_config.api_version_for(request.env, endpoint)
-          message_type = 'response'
-          example = example_for(endpoint, version, message_type)
+          example, version = settings.
+                             stub_app_builder.
+                             example_and_version_for(endpoint, self)
           example.validate!
           status endpoint.find_example_status_code_for!(version)
           JSON.dump(example.data)
         end
       end
+
+      def example_and_version_for(endpoint, app)
+        version = config.api_version_for(app.request.env, endpoint)
+        example = endpoint.find_example_for!(version, 'response')
+      rescue NoEndpointDefinitionFoundError
+        config.request_version_unavailable(app, version, endpoint.available_versions)
+      else
+        example.apply_filters(config.filter_example_data_blocks, app.request.env)
+        return example, version
+      end
     end
   end
 end

data/lib/interpol/version.rb

@@ -1,3 +1,3 @@
 module Interpol
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interpol
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
   prerelease: 
 platform: ruby
 authors:
@@ -223,7 +223,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4117955588587785690
+      hash: 2654545236171025309
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -232,7 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4117955588587785690
+      hash: 2654545236171025309
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24