transformers 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+.idea/*
+log/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in transformers.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,97 @@
+PATH
+  remote: .
+  specs:
+    transformers (0.0.1)
+      activesupport (~> 3.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionmailer (3.0.5)
+      actionpack (= 3.0.5)
+      mail (~> 2.2.15)
+    actionpack (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.4)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.13)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.5)
+      activesupport (= 3.0.5)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+    activesupport (3.0.5)
+    arel (2.0.9)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    i18n (0.5.0)
+    mail (2.2.17)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    mocha (0.9.12)
+    polyglot (0.3.1)
+    rack (1.2.2)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rails (3.0.5)
+      actionmailer (= 3.0.5)
+      actionpack (= 3.0.5)
+      activerecord (= 3.0.5)
+      activeresource (= 3.0.5)
+      activesupport (= 3.0.5)
+      bundler (~> 1.0)
+      railties (= 3.0.5)
+    railties (3.0.5)
+      actionpack (= 3.0.5)
+      activesupport (= 3.0.5)
+      rake (>= 0.8.7)
+      thor (~> 0.14.4)
+    rake (0.8.7)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    rspec-rails (2.5.0)
+      actionpack (~> 3.0)
+      activesupport (~> 3.0)
+      railties (~> 3.0)
+      rspec (~> 2.5.0)
+    thor (0.14.6)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.26)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 3.0.0)
+  mocha (~> 0.9.10)
+  rails (~> 3.0.0)
+  rspec (~> 2.5.0)
+  rspec-rails (~> 2.5.0)
+  transformers!

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Deepak N
+
+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,114 @@
+Transformers [![Build Status](http://travis-ci.org/endeepak/transformers.png)](http://travis-ci.org/endeepak/transformers)
+============
+
+Transformers is an extension to hash to allow various transformations using simple DSL. It also has optional rails extension to dry up frequently applied transformations on controller params.
+
+Install
+=======
+
+[not yet released]
+
+Usage
+=====
+
+        gem install transformers
+
+OR Add dependency in gem file for projects using bundler
+
+        gem transformers
+
+Available Transformations
+=========================
+
+* Convert values
+
+        hash = {:foo => 'bar'}
+
+        hash.convert :eric, :to => lambda { |value| value.upcase }
+
+      OR use short hand notation to call a method on the value
+
+        hash.convert :foo, :to => :upcase
+
+* Combine keys
+
+        hash.convert :begin, :end, :as => :range
+
+* Rename keys
+
+        hash.rename :foo, :to => :bar
+
+      OR
+
+        hash.convert :foo, :as => :bar
+
+* Alias key
+
+        hash.copy :foo, :to => :bar
+
+* Convert and combine
+
+        hash.convert :first_name, :last_name, :as => :name, :to => lambda { |first_name, last_name| first_name + ' '+ last_name }
+
+* Conversion using type converters
+
+        hash = {:foo => 'true'}
+
+        hash.convert :foo, :to => :boolean         #built-in
+
+* Using Custom converters : You can pass a lambda or define a module or an object which has a call method. This method will receive values for given keys and should return the converted value.
+
+        module Transformers::Name
+          def self.call(first_name, last_name)
+            return first_name + ' '+ last_name
+          end
+        end
+
+  Register the converter
+
+        Transformers.register(:name, Transformers::Name)
+
+  Usage
+
+        hash.convert :first_name, :last_name, :as => :name, :to => :name
+
+* Use them together in a transform block
+
+        hash.transform do
+          delete :unwanted
+          rename :foo, :to => :bar
+          convert :first_name, :last_name, :as => :name, :to => :name
+        end
+
+
+Rails Extensions
+================
+
+To Include rails extensions add the below line in a config/initializer/transformers.rb. You can register the custom transformers in the same file.
+
+        require 'transformers/rails'
+
+This adds _transform\_params_ extension to action controller. You can define the transformations for any action as,
+
+        transform_params :search, :only => :index do
+          convert :first_name, :last_name, :as => :name, :to => :name
+        end
+
+This will add a before\_filter in the controller to apply transformations on params[:search]. If the first argument is omitted, the transformations will be applied directly on the params. The options for transform\_params are same as before\_filter options.
+
+Rspec Matcher
+=============
+This gem has a rspec matcher for testing the custom converters. To use this, add the below line in the _spec\_helper_
+
+        require 'rspec/transformers'
+
+The converter spec can be written as
+
+        describe Transformers::Boolean do
+          it { should convert('true').to(true)}
+          it { should convert('false').to(false)}
+        end
+
+
+
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(--format documentation --color)
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => ["spec"]

data/lib/rspec/support/convert_to_matcher.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :convert do |value|
+  chain :to do |expected_value|
+    @expected_value = expected_value
+  end
+
+  match do
+    @converted_value = subject.call(value)
+    @converted_value == @expected_value
+  end
+
+  failure_message_for_should do |model|
+    "expected #{subject} to convert #{value.inspect} to #{@expected_value.inspect} but was #{@converted_value.inspect}"
+  end
+
+  description do
+    "convert #{value.inspect} to #{@expected_value.inspect}"
+  end
+end

data/lib/rspec/transformers.rb

@@ -0,0 +1 @@
+require 'rspec/support/convert_to_matcher'

data/lib/transformers.rb

@@ -0,0 +1,31 @@
+require 'active_support/core_ext/array/extract_options'
+
+require 'transformers/boolean'
+require 'transformers/method_call'
+require 'transformers/missing_option'
+require 'transformers/unknown_transformer'
+require 'transformers/extensions/hash'
+
+module Transformers
+  STANDARD = { :boolean => Transformers::Boolean }.freeze
+
+  def self.custom
+    @custom ||= {}
+  end
+
+  def self.all
+    custom.merge(STANDARD)
+  end
+
+  def self.get(transformer)
+    case transformer
+      when Module, Proc: transformer
+      when Symbol: all.has_key?(transformer) ? all[transformer] : MethodCall.new(transformer)
+      else raise UnknownTransformer.new(transformer)
+    end
+  end
+
+  def self.register(name, transformer)
+    custom[name] = transformer
+  end
+end

data/lib/transformers/boolean.rb

@@ -0,0 +1,9 @@
+module Transformers
+  module Boolean
+    TRUE_VALUES = ['true', true].freeze
+
+    def self.call(value)
+      TRUE_VALUES.include?(value)
+    end
+  end
+end

data/lib/transformers/extensions/action_controller.rb

@@ -0,0 +1,20 @@
+require "action_controller/railtie"
+
+module Transformers
+  module Extensions
+    module ActionController
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def transform_params(*args, &block)
+          options = args.extract_options!
+          before_filter(options) { params.transform(args.first, &block) }
+        end
+      end
+    end
+  end
+end
+
+ActionController::Base.send(:include, Transformers::Extensions::ActionController)

data/lib/transformers/extensions/hash.rb

@@ -0,0 +1,37 @@
+module Transformers
+  module Extensions
+    module Hash
+      def transform(key = nil, &block)
+        target = key.nil? ? self : self[key]
+        if target
+          raise TypeError.new("Can't apply transformations on #{target.inspect}. Expected a Hash") unless target.is_a?(Hash)
+          target.instance_eval(&block)
+        end
+      end
+
+      def convert(*keys)
+        options = keys.extract_options!
+        return unless keys.any? { |key| self.has_key?(key) }
+        new_key = options[:as] || keys.first
+        converter = options[:to]
+        values = keys.collect { |key| delete(key) }
+        new_value = converter ? Transformers.get(converter).call(*values) : (values.length == 1 ? values.first : values)
+        self[new_key] = new_value
+      end
+
+      def rename(key, options = {})
+        new_key = options[:to]
+        raise MissingOption.new(:to) if new_key.nil?
+        self[new_key] = self.delete(key)
+      end
+
+      def copy(key, options = {})
+        new_key = options[:to]
+        raise MissingOption.new(:to) if new_key.nil?
+        self[new_key] = self[key]
+      end
+    end
+  end
+end
+
+Hash.send(:include, Transformers::Extensions::Hash)

data/lib/transformers/method_call.rb

@@ -0,0 +1,17 @@
+module Transformers
+  class MethodCall
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def call(value)
+      value.send(self.name)
+    end
+
+    def ==(other)
+      self.name.to_s == other.name.to_s
+    end
+  end
+end

data/lib/transformers/missing_option.rb

@@ -0,0 +1,7 @@
+module Transformers
+  class MissingOption < Exception
+    def initialize(*options)
+      super("Missing options : #{options.collect(&:inspect).join(', ')}")
+    end
+  end
+end

data/lib/transformers/rails.rb

@@ -0,0 +1 @@
+require 'transformers/extensions/action_controller'

data/lib/transformers/unknown_transformer.rb

@@ -0,0 +1,7 @@
+module Transformers
+  class UnknownTransformer < Exception
+    def initialize(transformer)
+      super("The #{transformer.inspect} transformer is not supported")
+    end
+  end
+end

data/lib/transformers/version.rb

@@ -0,0 +1,3 @@
+module Transformers
+  VERSION = "0.0.1"
+end

data/spec/rails_spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rails/all'
+
+class Transformers::Application < Rails::Application
+end
+
+require 'rspec/rails'
+
+Transformers::Application.routes.draw do
+  match ':controller(/:action(/:id(.:format)))'
+end
+
+include Rails.application.routes.url_helpers

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'transformers'
+require 'transformers/rails'
+require 'rspec/transformers'
+
+require 'rails_spec_helper'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/transformers/boolean_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Transformers::Boolean do
+  it { should convert('true').to(true)}
+  it { should convert(true).to(true)}
+
+  it { should convert(false).to(false)}
+  it { should convert('false').to(false)}
+  it { should convert(nil).to(false)}
+  it { should convert('').to(false)}
+  it { should convert('  ').to(false)}
+  it { should convert('anything else').to(false)}
+end

data/spec/transformers/extensions/action_controller_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+#TODO: Find why adding transform_params in individual spec definition fails and fix it.
+class TestActionController < ActionController::Base
+  transform_params { convert :foo, :to => :upcase }
+
+  transform_params :bar do
+    convert :foo, :to => :upcase
+  end
+
+  transform_params :baz, :only => :index do
+     convert :foo, :to => :upcase
+  end
+
+  def index; head :ok; end
+  def show; head :ok; end
+end
+
+describe TestActionController, :type => :controller do
+  describe "transform_params" do
+    context "without args" do
+      it "transforms params by default" do
+        get :index, :foo => "hello"
+
+        controller.params[:foo].should == "HELLO"
+      end
+    end
+
+    context "with a key name as param" do
+      it "transforms params[key]" do
+        get :index, :bar => {:foo => "hello"}
+
+        controller.params[:bar][:foo].should == "HELLO"
+      end
+    end
+
+    context "with additional options" do
+      it "should pass the options to before filter" do
+        get :index, :baz => {:foo => "hello"}
+        controller.params[:baz][:foo].should == "HELLO"
+
+        get :show, :baz => {:foo => "hello"}
+        controller.params[:baz][:foo].should == "hello"
+      end
+    end
+  end
+end

data/spec/transformers/extensions/hash_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe Hash do
+  describe "#transform" do
+    context "without any arguments" do
+      it "should execute the transformations in the context of hash" do
+        hash = {:key => 'value'}
+
+        hash.transform { delete :key }
+
+        hash.should_not have_key(:key)
+      end
+    end
+
+    context "with key as argument" do
+      context "when value is not a hash" do
+        it "should execute the transformations in the context of value" do
+          hash = {:key => { :nested_key => 'value'} }
+
+          hash.transform(:key) { delete :nested_key }
+
+          hash[:key].should_not have_key(:nested_key)
+        end
+      end
+
+      context "when value in nil" do
+        it "should not execute any transformations" do
+          hash = {:key => nil }
+
+          hash.transform(:key) { delete :nested_key }
+
+          hash[:key].should be_nil
+        end
+      end
+
+      context "when value is not a hash" do
+        it "should raise error" do
+          hash = {:key => 'value' }
+
+          expect {
+            hash.transform(:key) do
+              convert :foo, :as => :bar
+            end
+          }.should raise_error(/Can't apply transformations on "value". Expected a Hash/)
+        end
+      end
+    end
+  end
+
+  describe "#convert" do
+    context "with :as option" do
+      context "for single key" do
+        it "should rename the key" do
+          hash = {:stan => 'marsh'}
+
+          hash.convert :stan, :as => :eric
+
+          hash.should_not have_key(:stan)
+          hash.should have_key(:eric)
+          hash[:eric].should == 'marsh'
+        end
+      end
+
+      context "for multiple keys" do
+        it "should combine the keys to single key" do
+          hash = {:begin => 12, :end => 22}
+
+          hash.convert :begin, :end, :as => :range
+
+          hash.should_not have_key(:begin)
+          hash.should_not have_key(:end)
+          hash.should have_key(:range)
+          hash[:range].should == [12, 22]
+        end
+      end
+    end
+
+    context "with :to option" do
+      it "should call 'call' on the converter obtained from transformer to set converted value" do
+        hash = {:key => :value}
+        converter = mock
+        Transformers.expects(:get).with(:converter).returns(converter)
+        converter.expects(:call).with(:value).returns(:converted_value)
+
+        hash.convert :key, :to => :converter
+
+        hash[:key].should == :converted_value
+      end
+
+      context "for single key" do
+        context "when key exists" do
+          it "should replace value with converted value" do
+            hash = {:eric => 'cartman'}
+
+            hash.convert :eric, :to => lambda { |value| value.upcase }
+
+            hash[:eric].should == 'CARTMAN'
+          end
+        end
+
+        context "when key does not exist" do
+          it "should not apply conversion" do
+            hash = {:eric => 'cartman'}
+
+            hash.convert :stan, :to => :kyle
+
+            hash[:eric].should == 'cartman'
+            hash.should_not have_key(:stan)
+          end
+        end
+      end
+
+      context "when hash has indifferent access" do
+        it "should apply conversion" do
+          hash = {'eric' => 'cartman'}.with_indifferent_access
+
+          hash.convert :eric, :to => :upcase
+
+          hash['eric'].should == 'CARTMAN'
+        end
+      end
+
+      context "for multiple keys" do
+        context "when all keys exists" do
+          it "should pass multiple values to converter and set converted vlaue for key given in :as option" do
+            hash = {:first_name => 'eric', :last_name => 'cartman' }
+
+            hash.convert :first_name, :last_name, :as => :name, :to => lambda { |first_name, last_name| "#{first_name} #{last_name}" }
+
+            hash[:name].should == 'eric cartman'
+          end
+        end
+
+        context "when one of keys exists" do
+          it "should pass multiple values to converter and set converted vlaue for key given in :as option" do
+            hash = {:first_name => 'eric' }
+
+            hash.convert :first_name, :last_name, :as => :name, :to => lambda { |first_name, last_name| "#{first_name} #{last_name}" }
+
+            hash[:name].should == 'eric '
+          end
+        end
+
+        context "when none of keys exists" do
+          it "should not apply conversion" do
+            hash = {}
+
+            hash.convert :first_name, :last_name, :as => :name, :to => lambda { |first_name, last_name| "#{first_name} #{last_name}" }
+
+            hash.should_not have_key(:name)
+          end
+        end
+      end
+    end
+  end
+
+  describe "rename" do
+    it "should rename the key" do
+      hash = {:stan => 'marsh'}
+
+      hash.rename :stan, :to => :eric
+
+      hash.should_not have_key(:stan)
+      hash.should have_key(:eric)
+      hash[:eric].should == 'marsh'
+    end
+
+    it "should raise error if :to option is missing" do
+      hash = {:stan => 'marsh'}
+
+      expect { hash.rename :stan }.should raise_error(/Missing options : :to/)
+    end
+  end
+
+  describe "copy" do
+    it "should copy the value to another key" do
+      hash = {:stan => 'southpark'}
+
+      hash.copy :stan, :to => :eric
+
+      hash.should have_key(:eric)
+      hash.should have_key(:stan)
+      hash[:eric].should == hash[:stan]
+    end
+
+    it "should raise error if :to option is missing" do
+      hash = {:stan => 'marsh'}
+
+      expect { hash.copy :stan }.should raise_error(/Missing options : :to/)
+    end
+  end
+end
+

data/spec/transformers/method_call_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Transformers::MethodCall do
+  context "with method name :upcase" do
+    subject  { Transformers::MethodCall.new(:upcase) }
+
+    it { should convert('hello').to('HELLO') }
+    it { should == Transformers::MethodCall.new(:upcase) }
+    it { should == Transformers::MethodCall.new('upcase') }
+  end
+end

data/spec/transformers_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Transformers do
+  describe ".get" do
+    context "when key is a proc" do
+      it "should return proc" do
+        transformer = lambda { |value| return :converted_value }
+
+        Transformers.get(transformer).should == transformer
+      end
+    end
+
+    context "when key is a module" do
+      it "should return module" do
+        Transformers.get(Transformers::Boolean).should == Transformers::Boolean
+      end
+    end
+
+    context "when key is symbol" do
+      context "standard transformer" do
+        it "should return standard transformer" do
+          Transformers.get(:boolean).should == Transformers::Boolean
+        end
+      end
+
+      context "registered transformer" do
+        it "should return registered transformer" do
+          transformer = lambda {|value| value.downcase }
+          Transformers.register(:downcase, transformer)
+
+          Transformers.get(:downcase).should == transformer
+        end
+      end
+
+      context "not registered" do
+        it "should return method call transformer" do
+          Transformers.get(:upcase).should == Transformers::MethodCall.new(:upcase)
+        end
+      end
+    end
+
+    context "when key is anything else" do
+      it "should raise error" do
+        expect { Transformers.get("UNKNOWN") }.should raise_error('The "UNKNOWN" transformer is not supported')
+      end
+    end
+  end
+end

data/transformers.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "transformers/version"
+
+Gem::Specification.new do |s|
+  s.name        = "transformers"
+  s.version     = Transformers::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Deepak N"]
+  s.email       = ["endeep123@gmail.com"]
+  s.homepage    = "https://github.com/endeepak/transformers"
+  s.summary     = %q{DSL to transform a hash}
+  s.description = %q{An extension to hash to allow various transformations using simple DSL. Also has optional rails extension to dry up frequently applied transformations on controller params.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_runtime_dependency("activesupport", "~> 3.0.0")
+  s.add_development_dependency("rails", "~> 3.0.0")
+  s.add_development_dependency("rspec", "~> 2.5.0")
+  s.add_development_dependency("rspec-rails", "~> 2.5.0")
+  s.add_development_dependency("mocha", "~> 0.9.10")
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification 
+name: transformers
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Deepak N
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-15 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec-rails
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 0
+        - 9
+        - 10
+        version: 0.9.10
+  type: :development
+  version_requirements: *id005
+description: An extension to hash to allow various transformations using simple DSL. Also has optional rails extension to dry up frequently applied transformations on controller params.
+email: 
+- endeep123@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- TODO.md
+- lib/rspec/support/convert_to_matcher.rb
+- lib/rspec/transformers.rb
+- lib/transformers.rb
+- lib/transformers/boolean.rb
+- lib/transformers/extensions/action_controller.rb
+- lib/transformers/extensions/hash.rb
+- lib/transformers/method_call.rb
+- lib/transformers/missing_option.rb
+- lib/transformers/rails.rb
+- lib/transformers/unknown_transformer.rb
+- lib/transformers/version.rb
+- spec/rails_spec_helper.rb
+- spec/spec_helper.rb
+- spec/transformers/boolean_spec.rb
+- spec/transformers/extensions/action_controller_spec.rb
+- spec/transformers/extensions/hash_spec.rb
+- spec/transformers/method_call_spec.rb
+- spec/transformers_spec.rb
+- transformers.gemspec
+has_rdoc: true
+homepage: https://github.com/endeepak/transformers
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: DSL to transform a hash
+test_files: 
+- spec/rails_spec_helper.rb
+- spec/spec_helper.rb
+- spec/transformers/boolean_spec.rb
+- spec/transformers/extensions/action_controller_spec.rb
+- spec/transformers/extensions/hash_spec.rb
+- spec/transformers/method_call_spec.rb
+- spec/transformers_spec.rb