cp-sparrow 0.0.11

data/lib/sparrow/strategies/form_hash.rb

@@ -0,0 +1,42 @@
+require 'active_support/core_ext/object/blank'
+require 'sparrow/transformable'
+
+module Sparrow
+  module Strategies
+    class FormHash
+      REQUEST_FORM_HASH_KEY = 'rack.request.form_hash'
+      include Transformable
+
+      attr_reader :env, :type
+
+      def self.handle(env, type)
+        self.new(env, type).handle
+      end
+
+      def initialize(env, type = :request, params = nil)
+        @env    = env
+        @params = params
+        @type   = type
+      end
+
+      def handle
+        super
+        handle_form_hash
+      end
+
+      def params
+        @params || env[REQUEST_FORM_HASH_KEY]
+      end
+
+      private
+
+      def handle_form_hash
+        if params.present?
+          transformed_params = transform_params
+          @env[REQUEST_FORM_HASH_KEY] = transformed_params
+        end
+      end
+    end
+  end
+end
+

data/lib/sparrow/strategies/ignore.rb

@@ -0,0 +1,42 @@
+module Sparrow
+  module Strategies
+    class Ignore
+      include Transformable
+
+      def initialize(env, type = :request, params = nil)
+        @env    = env
+        @params = params
+        @type   = type
+      end
+
+      def params
+        ret = @params || @env['rack.input'].send(:read)
+        @env['rack.input'].rewind
+        ret
+      end
+
+      def self.handle(env, type)
+        new(env, type).handle
+      end
+
+      def handle
+        # synchronize rack.input and form hash values
+        input = @env['rack.input'].gets
+
+        begin
+          @env['rack.request.form_hash'] = MultiJson.load(input)
+        rescue MultiJson::ParseError
+          # ignore
+        ensure
+          @env['rack.input'].rewind
+        end if input.present?
+
+        @env
+      end
+
+      def transform_params
+        ensure_json
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/json_format_strategies/array_strategy.rb

@@ -0,0 +1,17 @@
+require 'sparrow/strategies/json_format_strategies/json_format_strategy'
+
+module Sparrow
+  module Strategies
+    class ArrayStrategy < JsonFormatStrategy
+      register_json_format
+
+      def match?(input)
+        input.is_a? Array
+      end
+
+      def convert(input)
+        input.first
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/json_format_strategies/default_json_format_strategy.rb

@@ -0,0 +1,17 @@
+require 'singleton'
+
+module Sparrow
+  module Strategies
+    class DefaultJsonFormatStrategy
+      include Singleton
+
+      def match?(input)
+        true
+      end
+
+      def convert(input)
+        input.to_s
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/json_format_strategies/json_format_strategy.rb

@@ -0,0 +1,35 @@
+require 'sparrow/strategies/json_format_strategies/default_json_format_strategy'
+require 'active_support/core_ext/object/blank'
+
+module Sparrow
+  module Strategies
+    class JsonFormatStrategy
+      def initialize(*args)
+
+      end
+
+      def self.register_json_format(*args)
+        init(args)
+        @@json_format_strategies << self.new(args)
+      end
+
+      def self.convert(body)
+        strategy = json_format_strategies.select do |strategy|
+          strategy.match?(body)
+        end.first
+        strategy.convert(body)
+      end
+
+      private
+      def self.init(*args)
+        @@json_format_strategies ||= Array.new(args)
+      end
+
+      def self.json_format_strategies
+        init
+        default = Sparrow::Strategies::DefaultJsonFormatStrategy.instance
+        @@json_format_strategies.reject(&:blank?) + [default]
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/json_format_strategies/rack_body.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/json_format_strategy'
+
+module Sparrow
+  module Strategies
+    class RackBody < JsonFormatStrategy
+      register_json_format
+
+      def match?(input)
+        input.respond_to?(:body)
+      end
+
+      def convert(input)
+        input.body
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/key_transformation/camelize_key.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/key_normalizer'
+
+module Sparrow
+  module Strategies
+    class CamelizeKey
+      include KeyNormalizer
+
+      attr_accessor :strategy
+
+      def initialize(strategy = :lower)
+        self.strategy = strategy
+      end
+
+      def transform_key(key)
+        # dont touch all_Upper Keys (like "DE")
+        # unless configuration.default_ignore_all_uppercase_keys
+        # is set to false
+        if Sparrow.configuration.camelize_ignore_uppercase_keys &&
+           key.upcase == key
+          normalize_key(key)
+        else
+          normalize_key(key).camelize(strategy)
+        end
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/key_transformation/key_normalizer.rb

@@ -0,0 +1,9 @@
+module Sparrow
+  module Strategies
+    module KeyNormalizer
+      def normalize_key(key)
+        key.to_s
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/key_transformation/underscore_key.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/key_normalizer'
+
+module Sparrow
+  module Strategies
+    class UnderscoreKey
+      include KeyNormalizer
+
+      def transform_key(key)
+        normalize_key(key).underscore
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/raw_input.rb

@@ -0,0 +1,48 @@
+require 'active_support/core_ext/object/blank'
+
+module Sparrow
+  module Strategies
+    class RawInput
+      include Transformable
+
+      attr_reader :env, :type
+
+      def self.handle(env, type)
+        self.new(env, type).handle
+      end
+
+      def initialize(env, type = :request, params = nil)
+        @env    = env || {}
+        @params = params
+        @type   = type
+      end
+
+      def handle
+        super
+        handle_raw_rack
+      end
+
+      def params
+        if @params
+          @params
+        else
+          input_io = @env['rack.input']
+          params   = input_io.send(:read)
+          input_io.rewind
+          params
+        end
+      end
+
+      private
+
+      def handle_raw_rack
+        if params.present?
+          new_raw_input      = json_body.force_encoding("BINARY")
+          @env['rack.input'] = StringIO.new(new_raw_input)
+          @env['rack.input'].rewind
+          @env['CONTENT_LENGTH'] = new_raw_input.length
+        end
+      end
+    end
+  end
+end

data/lib/sparrow/strategies/transform_params.rb

@@ -0,0 +1,38 @@
+require 'active_support/core_ext/string'
+if ActiveSupport::VERSION::STRING.match(/3\.\d+\.\d+/)
+  require 'sparrow/core_ext/hash'
+end
+
+require 'sparrow/strategies/key_transformation/underscore_key'
+require 'sparrow/strategies/key_transformation/camelize_key'
+
+module Sparrow
+  module Strategies
+    class TransformParams
+      attr_accessor :key_transformation_strategy
+
+      def initialize(key_transformation_strategy_buzzword)
+        key_transformation_strategy = create_key_transformation_strategy(
+            key_transformation_strategy_buzzword)
+        self.key_transformation_strategy = key_transformation_strategy
+      end
+
+      def transform(collection_or_hash)
+        case collection_or_hash
+        when Array
+          collection_or_hash.map { |element| transform(element) }
+        when Hash
+          collection_or_hash.deep_transform_keys do |key|
+            key_transformation_strategy.transform_key(key)
+          end
+        end
+      end
+
+      def create_key_transformation_strategy(key_transformation_strategy_buzzword)
+        class_name = "#{key_transformation_strategy_buzzword.to_s}_key".camelize
+        strategy_class = "Sparrow::Strategies::#{class_name}".constantize
+        strategy_class.new
+      end
+    end
+  end
+end

data/lib/sparrow/transformable.rb

@@ -0,0 +1,76 @@
+require 'sparrow/strategies/transform_params'
+require 'sparrow/strategies/json_format_strategies/json_format_strategy'
+
+if ActiveSupport::VERSION::STRING.match(/3\.\d+\.\d+/)
+  require 'active_support/core_ext/object/to_param'
+  require 'active_support/core_ext/object/to_query'
+end
+
+module Sparrow
+  module Transformable
+    def transform_params
+      transform_params_strategy.transform(ensure_json)
+    end
+
+    def transform_strategy
+      default  =
+          Sparrow.configuration.default_json_key_transformation_strategy(type)
+      strategy = json_format || default
+      strategy.to_sym
+    end
+
+    def handle
+      transform_query_string
+    end
+
+    def json_body
+      json = parsable_json_string(transform_params)
+      MultiJson.load(json)
+      json
+    rescue MultiJson::ParseError
+      MultiJson.dump(ensure_json)
+    end
+
+    private
+    def json_format
+      if respond_to?(:env) then
+        env[Sparrow.configuration.json_format_header(type)]
+      else
+        nil
+      end
+    end
+
+    def ensure_json
+      json_params = if !params.is_a?(Hash)
+                      Sparrow::Strategies::JsonFormatStrategy.convert(params)
+                    elsif params.is_a?(Hash) && params.values == [nil] &&
+                      params.keys.length == 1
+                      params.keys.first
+                    else
+                      params
+                    end
+      return MultiJson.load(json_params) if json_params.is_a?(String)
+      json_params
+    end
+
+    def parsable_json_string(transformable_params)
+      if [Hash, Array].include? transformable_params.class
+        MultiJson.dump(transformable_params)
+      else
+        transformable_params
+      end
+    end
+
+    def transform_params_strategy
+      transform_params = Sparrow::Strategies::TransformParams
+      transform_params.new(transform_strategy)
+    end
+
+    def transform_query_string
+      env_query_hash      = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
+      transformed_hash    = transform_params_strategy.transform(env_query_hash)
+      env['QUERY_STRING'] = transformed_hash.to_param
+    end
+
+  end
+end

data/lib/sparrow/version.rb

@@ -0,0 +1,3 @@
+module Sparrow
+  VERSION = '0.0.11'
+end

data/sparrow.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+rails_version = ENV["RAILS_VERSION"] || "3.2.21"
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sparrow/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = "cp-sparrow"
+  spec.version     = Sparrow::VERSION
+  spec.authors     = ["Daniel Schmidt", "Andreas Müller"]
+  spec.email       = ["dsci@code79.net", "anmuel86@gmail.com"]
+  spec.summary     = %q{A POC to have a Rack middleware parsing the params keys into underscore}
+  spec.description = %q{
+    A collection of 2 middlewares to convert json formats to other formats
+such as camelCase and snake_case. Both converting responses and requests are
+supported.
+  }
+  spec.homepage    = ""
+  spec.license     = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport", ">= 3.2.17"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", '~> 3'
+  spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "multi_json"
+  spec.add_development_dependency "rails", rails_version
+end

data/spec/integration/apps/rack_app/app.rb

@@ -0,0 +1,28 @@
+class App
+
+  def call(env)
+    params = env["rack.input"].gets
+    response = Rack::Response.new
+    response['Content-Type'] = 'application/json'
+    response.write(json_response(params))
+    response.finish
+  end
+
+  private
+
+  def json_response(params)
+    hsh_params = MultiJson.load(params)
+    keys = hsh_params.reduce([]) do |result, (key, value)|
+      result << key
+      if value.is_a?(Hash)
+        result << value.keys
+      end
+      result
+    end.flatten
+    MultiJson.dump({
+                       keys: keys,
+                       fakeKey: true,
+                       fake_key: false
+                   })
+  end
+end