cp-sparrow 0.0.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9052fb54e2eab83298497e0037a54c517bd7429a
+  data.tar.gz: 3c871cad86f27adf06bbdcc2cbf35bac4ed479fe
+SHA512:
+  metadata.gz: 92ec954024212d99c3e5d606072f1703131301774de50721360057aaffd256bfa5ef5659e62599153a2672720f5014c33d9023961351b9595e65237cfece1c55
+  data.tar.gz: 7c8ffca7814f4968e898b37d0a827871ce41d311795c92aca695076e6fd408741148f7ba1dafd3f5108dce76d83fee3f877c5c3da9de74c3a41a9cd165d1cd07

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+*.swo
+*.swp
+*.log
+spec/integration/apps/rails_app/log
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+.project

data/.ruby-gemset

@@ -0,0 +1 @@
+sparrow

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sparrow.gemspec
+gemspec
+
+gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw]

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Daniel Schmidt
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# Sparrow
+
+A Rack middleware for converting the params keys and JSON response keys of a Rack application.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cp-sparrow', require: 'sparrow'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sparrow
+
+## Usage
+
+If you're using Rails, that's it. You haven't to do anything more. If you're not using Rails, you will have to add to your config.ru:
+
+```rb
+require 'sparrow'
+
+use Sparrow::Middleware
+```
+
+## Configuration
+
+There are various configuration options as well as HTTP headers available to
+make the middleware act as you want it to.
+
+in your configuration file (such as application.rb if you are using Rails)
+
+```ruby
+Sparrow.configure do |config|
+  config.excluded_routes = [
+    Regexp.new('api/model/certificates')
+  ]
+end
+```
+
+There are several options available
+
+| Option | Example | Meaning |
+|---------|---------|----------------------|
+| excluded_routes | see above | An Array of Strings and/or Regexps defining which paths should not be touched by the middleware. The entries should matchs paths for your application. They should *not* start with a leading slash. |
+| default_json_request_key_transformation_strategy | "underscore" | Defines how the middleware should treat incoming parameters via Request. Which means how they get tranformed, i.e. defining _underscore_ here means that incoming parameters get underscore. Possible values are _underscore_ and _camelize_ |
+| default_json_response_key_transformation_strategy | "camelize" | Same as *default_json_request_key_transformation_strategy, but for responses. I.e. this defines to which format the keys get transformed when the response gets sent.
+| json_request_format_header| "request-json-format" | Defines the HTTP Header key which sets the request transformation strategy as in default_json_request_key_transformation_strategy*. This definition has higher priority than the default definition. Any valid HTTP Header String value is possible. Defaults to 'request-json-format' |
+| json_response_format_header| "response-json-format" | Same as *json_request_format_header*, but for the response handling. Defaults to 'response-json-format' |
+| camelize_ignore_uppercase_keys | `true` | A boolean that indicates to not camelize keys that are all Uppercase, like CountryCodes "EN" ... |
+| allowed_content_types |`['application/json', 'text/x-json']` | A list of HTTP content types upon which the middleware shall trigger and possibly start  conversion. Defaults to `['application/json', 'application/x-www-form-urlencoded', 'text/x-json']`. If `nil` is present in the list, requests/responses with *no* Content-Type header will be processed as well. Possible values can also be the start of the content-type-header like ```application/``` which matches everything which starts with ```application/``` like ```application/json```  |
+| allowed_accepts | `['application/json', 'text/x-json']` | Same as **allowed_content_types**, but reacts to the HTTP Accept Header. Applies to the same possible options, behavior. Defaults to the same set of MIME types, but also includes `nil` by default, which ignores checking the Accept header in default configuration |
+
+## Tests
+
+Just run `rake` and you are off to go. This runs the whole suite including
+specs for unit- & integrationtests for Rails and Rack including different versions of Rails.
+
+If you want to test a specific version of Rails:
+
+```
+export RAILS_VERSION=3.2.17; bundle update; bundle exec rspec
+```

data/Rakefile

@@ -0,0 +1,32 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+RAILS_VERSIONS = [
+  "3.2.17",
+  "4.0.13"
+]
+
+def run_tests_for_version(version)
+  commands = []
+
+  commands << "rm Gemfile.lock"
+  commands << "export RAILS_VERSION=#{version}"
+  commands << "bundle update"
+  commands << "bundle exec rspec"
+
+  system(commands.join(';'))
+end
+
+task :default do
+  RAILS_VERSIONS.each do |version|
+    puts "Testing gem for rails version: #{version}"
+    success = run_tests_for_version(version)
+
+    if not success
+      puts "Test suite aborted, errors occured."
+      exit($?.exitstatus)
+    end
+  end
+end

data/lib/sparrow.rb

@@ -0,0 +1,25 @@
+require 'active_support/version'
+require 'sparrow/version'
+require 'sparrow/configuration'
+require 'sparrow/route_parser'
+require 'sparrow/request_middleware'
+require 'sparrow/response_middleware'
+require 'sparrow/strategies/json_format_strategies/rack_body'
+require 'sparrow/strategies/json_format_strategies/array_strategy'
+require 'sparrow/railtie' if defined?(Rails)
+
+module Sparrow
+  class << self
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration
+      @configuration = nil
+    end
+  end
+end

data/lib/sparrow/configuration.rb

@@ -0,0 +1,36 @@
+module Sparrow
+  class Configuration
+    attr_accessor :json_request_format_header,
+                  :json_response_format_header,
+                  :excluded_routes,
+                  :default_json_request_key_transformation_strategy,
+                  :default_json_response_key_transformation_strategy,
+                  :camelize_ignore_uppercase_keys,
+                  :allowed_content_types,
+                  :allowed_accepts
+
+    def initialize
+      @json_request_format_header                        = 'request-json-format'
+      @json_response_format_header                       = 'response-json-format'
+      @excluded_routes                                   = []
+      @default_json_request_key_transformation_strategy  = :camelize
+      @default_json_response_key_transformation_strategy = :camelize
+      @camelize_ignore_uppercase_keys                    = true
+      @allowed_content_types                             = %w[
+        application/json
+        application/x-www-form-urlencoded
+        text/x-json
+      ]
+
+      @allowed_accepts = @allowed_content_types + [nil]
+    end
+
+    def json_format_header(type)
+      public_send("json_#{type}_format_header")
+    end
+
+    def default_json_key_transformation_strategy(type)
+      public_send("default_json_#{type}_key_transformation_strategy")
+    end
+  end
+end

data/lib/sparrow/core_ext/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  def deep_transform_keys(&block)
+    deep_transform_in_object(self, &block)
+  end
+
+  private 
+
+  def deep_transform_in_object(obj, &block)
+    case obj 
+      when Hash
+        obj.each_with_object({}) do |(key,value), result|
+          result[yield(key)] = deep_transform_in_object(value, &block)
+        end
+      when Array
+        obj.map { |el| deep_transform_in_object(el, &block) }
+      else
+        obj
+    end
+  end
+end
+

data/lib/sparrow/middleware.rb

@@ -0,0 +1,99 @@
+require 'active_support/core_ext/object/blank'
+require 'sparrow/strategies/form_hash'
+require 'sparrow/strategies/raw_input'
+require 'sparrow/strategies/ignore'
+
+module Sparrow
+  class Middleware
+    attr_reader :app, :body, :status, :headers
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @last_env                = env
+      @status, @headers, @body = @app.call(convert(env))
+    end
+
+    def convert(env)
+      env
+    end
+
+    private
+
+    def strategy
+      if is_processable?
+        if last_env[Strategies::FormHash::REQUEST_FORM_HASH_KEY]
+          Strategies::FormHash
+        else
+          Strategies::RawInput
+        end
+      else
+        Strategies::Ignore
+      end
+    end
+
+    def is_processable?
+      accepted_content_type? && accepted_accept_header? && includes_route?
+    end
+
+    def includes_route?
+      path = request.path || last_env['PATH_INFO']
+      RouteParser.new.allow?(path)
+    end
+
+    def accepted_content_type?
+      content_type_equals?(request_content_type) || content_type_matches?(request_content_type)
+    end
+
+    def accepted_accept_header?
+      allowed_accepts = Sparrow.configuration.allowed_accepts
+      accept_header = last_env['ACCEPT'] || last_env['Accept']
+
+      allowed_accepts.include?(nil) || accept_type_matches?(allowed_accepts, accept_header)
+    end
+
+    def last_env
+      @last_env || {}
+    end
+
+    def request
+      request_class = if defined?(Rails) then
+                        ActionDispatch::Request
+                      else
+                        Rack::Request
+                      end
+
+      request_class.new(last_env)
+    end
+
+    def request_content_type
+      content_type = request.content_type ||
+          last_env['CONTENT-TYPE'] ||
+          last_env['Content-Type'] ||
+          last_env['CONTENT_TYPE']
+
+      content_type.present? ? content_type : nil
+    end
+
+    def content_type_equals?(type)
+      Sparrow.configuration.allowed_content_types.include?(type)
+    end
+
+    def content_type_matches?(type)
+      matches = Sparrow.configuration.allowed_content_types.map do |acceptable_content_type|
+        (acceptable_content_type && type.to_s.starts_with?(acceptable_content_type.to_s))
+      end
+
+      matches.any?
+    end
+
+    def accept_type_matches?(accepted_headers, type)
+      accepted_headers.detect do |accept|
+        type.include?(accept)
+      end
+    end
+  end
+end
+

data/lib/sparrow/path_normalizer.rb

@@ -0,0 +1,10 @@
+require 'active_support/core_ext/string/starts_ends_with'
+
+module Sparrow
+  module PathNormalizer
+    def normalize_path(path)
+      path[/./m] = '' if path.starts_with?('/')
+      path
+    end
+  end
+end

data/lib/sparrow/railtie.rb

@@ -0,0 +1,11 @@
+module Sparrow
+  class Railtie < Rails::Railtie
+    initializer 'sparrow.insert_middleware' do |app|
+      # handle request
+      app.config.middleware.insert_after 'Rails::Rack::Logger',
+                                          'Sparrow::RequestMiddleware'
+      # handle response
+      app.config.middleware.use 'Sparrow::ResponseMiddleware'
+    end
+  end
+end

data/lib/sparrow/request_middleware.rb

@@ -0,0 +1,11 @@
+require 'sparrow/middleware'
+
+module Sparrow
+  class RequestMiddleware < Middleware
+    def convert(env)
+      super
+      strategy.handle(env, :request)
+      env
+    end
+  end
+end

data/lib/sparrow/response_middleware.rb

@@ -0,0 +1,37 @@
+require 'active_support/core_ext/object/inclusion'
+require 'sparrow/middleware'
+require 'sparrow/strategies/json_format_strategies/json_format_strategy'
+
+module Sparrow
+  class ResponseMiddleware < Middleware
+    def call(env)
+      @last_env                = env
+      @status, @headers, @body = @app.call(env)
+      [status, headers, converted_response_body]
+    end
+
+    def converted_response_body
+      response_body = Sparrow::Strategies::JsonFormatStrategy.convert(body)
+
+      # just pass the response if something went wrong inside the application
+      return response_body if unprocessable_status?
+
+      if response_body.present?
+        response_strategy = strategy.new(last_env, :response, response_body)
+        response_strategy.handle
+
+        if response_body.is_a?(Array) then
+          response_body
+        else
+          Array(response_strategy.json_body)
+        end
+      else
+        []
+      end
+    end
+
+    def unprocessable_status?
+      @status.in?(500..511) || @status == 404
+    end
+  end
+end

data/lib/sparrow/route_parser.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext/string/starts_ends_with'
+require 'sparrow/path_normalizer'
+
+module Sparrow
+  class RouteParser
+    include PathNormalizer
+
+    attr_accessor :excluded_routes
+
+    def initialize(excluded_routes = Sparrow.configuration.excluded_routes)
+      self.excluded_routes = excluded_routes.map do |route|
+        if route.is_a?(Regexp)
+          route
+        else
+          Regexp.new(route.to_s)
+        end
+      end
+    end
+
+    def allow?(path)
+      not exclude?(path)
+    end
+
+    def exclude?(path)
+      normalized_path = normalize_path(path)
+      excluded_routes.each do |route|
+        return true if normalized_path =~ route
+      end
+      return false
+    end
+  end
+end