midpay 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format d

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@midpay --create

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://ruby.taobao.org'
+
+gemspec
+
+group :test do
+  gem 'rspec', '~> 2.11'
+  gem "rack-test", require: "rack/test"
+  gem 'simplecov'
+  gem 'simplecov-rcov'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 xixilive
+
+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,78 @@
+# Midpay
+
+A Rack Middleware for E-Commerce Payment Base-Strategy
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'midpay'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install midpay
+
+## Usage
+
+For example, we have a strategy named Foo as following:
+```ruby
+class Foo
+  include ::Midpay::Strategy
+
+  def request_phase response
+    response.write("You are being redirected to a payment gateway......")
+    response.redirect a_url_for_payment_gateway_with_some_parameters
+  end
+
+  def callback_phase payment_info
+    payment_info.extra = EXTRA_INFO #... whatever
+    payment_info.raw_data = RAW_DATA #... whatever
+    payment_info.success = true
+  end
+end
+
+#register your strategy
+::Midpay[:foo] = ::Foo
+```
+
+In your rack app:
+
+```ruby
+use ::Midpay[:foo], YOUR_APPID, YOUR_KEY, :request_params_proc => {|params| 
+  obj = BarModel.find(params[:bar_id])
+  {
+    :key1 => obj.value1,
+    :key2 => obj.value2
+    # all of the params to be sent to your payment gateway on request phase
+  } 
+}
+```
+
+Send a request to Payment Gateway:
+
+```ruby
+get '/midpay/foo?bar_id=123'
+```
+
+Handle gateway callback request in your controller:
+```ruby
+  def callback
+    current_strategy = request.env['midpay.strategy']
+    callback_data = request.env['midpay.callback']
+    # handle the callback logic
+  end
+```
+
+For more details at WIKI
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/midpay.rb

@@ -0,0 +1,60 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "midpay/version"
+require 'logger'
+require 'singleton'
+require 'rack'
+require 'uri'
+require 'hashie'
+
+module Midpay
+  class << self
+    def strategies
+      @@strategies ||= {}
+    end
+
+    def []= name, value
+      strategies[name.to_sym] = value
+    end
+
+    def [] name
+      strategies[name.to_sym]
+    end
+  end
+
+  class Configuration
+    include Singleton
+
+    attr_accessor :root_path, :logger
+
+    def initialize
+      @root_path = "/midpay"
+      @logger = ::Logger.new(STDOUT)
+      logger.progname = "midpay"
+    end
+  end
+
+  def self.config
+    Configuration.instance
+  end
+
+  def self.logger
+    config.logger
+  end
+
+  def self.configure
+    yield config
+  end
+
+  autoload :Builder, 'midpay/builder.rb'
+  autoload :Strategy, "midpay/strategy.rb"
+  autoload :HashExtensions, "midpay/hash_extensions.rb"
+  autoload :SignableHash, "midpay/signable_hash.rb"
+  
+  module Errors
+    class InvalidPaymentInfo < ::StandardError; end
+    class InvalidSignature < ::StandardError; end
+  end
+
+end

data/lib/midpay/builder.rb

@@ -0,0 +1,14 @@
+module Midpay
+  class Builder < ::Rack::Builder
+    
+    def midpay klass, *args, &block
+      raise "Invalid Middleware" unless (middleware = klass.is_a?(Class) ? klass : Midpay[klass])
+      use middleware, *args, &block
+    end
+
+    def call(env)
+      to_app.call(env)
+    end
+
+  end
+end

data/lib/midpay/hash/indifferent_access.rb

@@ -0,0 +1,84 @@
+module Midpay
+  module HashExtensions
+    module IndifferentAccess
+      def self.included(base)
+        base.class_eval do
+          alias_method :regular_writer, :[]=
+          alias_method :[]=, :indifferent_writer
+          %w(default update fetch delete key? values_at).each do |m|
+            alias_method "regular_#{m}", m
+            alias_method m, "indifferent_#{m}"
+          end
+
+          %w(include? member? has_key?).each do |key_alias|
+            alias_method key_alias, :indifferent_key?
+          end
+        end
+      end
+
+      def self.inject!(hash)
+        (class << hash; self; end).send :include, IndifferentAccess
+        hash.convert!
+      end
+
+      def self.inject(hash)
+        inject!(hash.dup)
+      end
+
+      def convert_key(key)
+        key.to_s
+      end
+
+      def convert!
+        keys.each do |k|
+          regular_writer convert_key(k), convert_value(self.regular_delete(k))
+        end
+        self
+      end
+
+      def convert_value(value)
+        if hash_lacking_indifference?(value)
+          IndifferentAccess.inject(value.dup)
+        elsif value.is_a?(::Array)
+          value.dup.replace(value.map { |e| convert_value(e) })
+        else
+          value
+        end
+      end
+      
+      def indifferent_default(key = nil)
+        return self[convert_key(key)] if key?(key)
+        regular_default(key)
+      end
+
+      def indifferent_update(other_hash)
+        return regular_update(other_hash) if hash_with_indifference?(other_hash)
+        other_hash.each_pair do |k,v|
+          self[k] = v
+        end
+      end
+      
+      def indifferent_writer(key, value);  regular_writer convert_key(key), convert_value(value) end
+      def indifferent_fetch(key, *args);   regular_fetch  convert_key(key), *args                end
+      def indifferent_delete(key);         regular_delete convert_key(key)                       end
+      def indifferent_key?(key);           regular_key?   convert_key(key)                       end
+      def indifferent_values_at(*indices); indices.map{|i| self[i] }                             end
+
+      def indifferent_access?; true end
+      
+      protected
+
+      def hash_lacking_indifference?(other)
+        other.is_a?(::Hash) &&
+        !(other.respond_to?(:indifferent_access?) &&
+          other.indifferent_access?)
+      end
+
+      def hash_with_indifference?(other)
+        other.is_a?(::Hash) &&
+        other.respond_to?(:indifferent_access?) &&
+        other.indifferent_access?
+      end
+    end
+  end
+end

data/lib/midpay/hash/key_conversion.rb

@@ -0,0 +1,92 @@
+module Midpay
+  module HashExtensions
+    module StringifyKeys
+      # Convert all keys in the hash to strings.
+      #
+      # @example
+      #   test = {:abc => 'def'}
+      #   test.stringify_keys!
+      #   test # => {'abc' => 'def'}
+      def stringify_keys!
+        keys.each do |k|
+          stringify_keys_recursively!(self[k])
+          self[k.to_s] = self.delete(k)
+        end
+        self
+      end
+
+      # Return a new hash with all keys converted
+      # to strings.
+      def stringify_keys
+        dup.stringify_keys!
+      end
+
+      protected
+
+      # Stringify all keys recursively within nested
+      # hashes and arrays.
+      def stringify_keys_recursively!(object)
+        if self.class === object
+          object.stringify_keys!
+        elsif ::Array === object
+          object.each do |i|
+            stringify_keys_recursively!(i)
+          end
+          object
+        elsif object.respond_to?(:stringify_keys!)
+          object.stringify_keys!
+        else
+          object
+        end
+      end
+    end
+
+    module SymbolizeKeys
+      # Convert all keys in the hash to symbols.
+      #
+      # @example
+      #   test = {'abc' => 'def'}
+      #   test.symbolize_keys!
+      #   test # => {:abc => 'def'}
+      def symbolize_keys!
+        keys.each do |k|
+          symbolize_keys_recursively!(self[k])
+          self[k.to_sym] = self.delete(k)
+        end
+        self
+      end
+
+      # Return a new hash with all keys converted
+      # to symbols.
+      def symbolize_keys
+        dup.symbolize_keys!
+      end
+
+      protected
+
+      # Symbolize all keys recursively within nested
+      # hashes and arrays.
+      def symbolize_keys_recursively!(object)
+        if self.class === object
+          object.symbolize_keys!
+        elsif ::Array === object
+          object.each do |i|
+            symbolize_keys_recursively!(i)
+          end
+          object
+        elsif object.respond_to?(:symbolize_keys!)
+          object.symbolize_keys!
+        else
+          object
+        end
+      end
+    end
+    
+    module KeyConversion
+      def self.included(base)
+        base.send :include, SymbolizeKeys
+        base.send :include, StringifyKeys
+      end
+    end
+  end
+end

data/lib/midpay/hash/merge_initializer.rb

@@ -0,0 +1,12 @@
+module Midpay
+  module HashExtensions
+    module MergeInitializer
+      def initialize(hash = {}, default = nil, &block)
+        default ? super(default) : super(&block)
+        hash.each do |key, value|
+          self[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/midpay/hash_extensions.rb

@@ -0,0 +1,25 @@
+module Midpay
+  module HashExtensions
+    require 'hashie/version'
+
+    def self.included base
+      if ::Hashie::VERSION.to_i >= 2
+        base.send :include, ::Hashie::Extensions::MergeInitializer
+        base.send :include, ::Hashie::Extensions::StringifyKeys
+        base.send :include, ::Hashie::Extensions::SymbolizeKeys
+        base.send :include, ::Hashie::Extensions::IndifferentAccess
+      else
+
+        require 'midpay/hash/merge_initializer'
+        require 'midpay/hash/indifferent_access'
+        require 'midpay/hash/key_conversion'
+
+        base.send :include, ::Midpay::HashExtensions::MergeInitializer
+        base.send :include, ::Midpay::HashExtensions::IndifferentAccess
+        base.send :include, ::Midpay::HashExtensions::StringifyKeys
+        base.send :include, ::Midpay::HashExtensions::SymbolizeKeys
+      end
+      
+    end
+  end
+end

data/lib/midpay/signable_hash.rb

@@ -0,0 +1,42 @@
+module Midpay
+  class SignableHash < ::Hash
+    require 'digest'
+
+    include ::Midpay::HashExtensions
+
+    def sign algorithm, &block
+      data = yield(self.dup)
+      begin
+        algorithm_const(algorithm).send(:hexdigest, data)
+      rescue
+        nil
+      end
+    end
+
+    def sign! key, algorithm, &block
+      self[key] = self.sign(algorithm, &block)
+      self
+    end
+
+    def to_query
+      collect{|k,v| "#{::URI.encode_www_form_component(k.to_s)}=#{::URI.encode_www_form_component(v.to_s)}" }.sort.join("&")
+    end
+
+    def merge_if! hash
+      hash.each do |i|
+        self[i[0]] = i[1] unless self.key?(i[0])
+      end if hash.respond_to?(:each)
+      self
+    end
+
+    def algorithm_const algorithm
+      algorithm = self[algorithm] if key?(algorithm) && self[algorithm]
+      begin
+        ::Digest.const_get(algorithm.to_s.upcase)
+      rescue
+        #
+      end
+    end
+
+  end
+end

data/lib/midpay/strategy.rb

@@ -0,0 +1,151 @@
+module Midpay
+  module Strategy
+
+    class Options < ::Hashie::Mash; end
+
+    class PaymentInfo
+      require 'json'
+      attr_accessor :pay, :raw_data, :extra, :success
+      def initialize pay, &block
+        @pay = pay
+        @raw_data = {}
+        @extra = {}
+        @success = nil
+        yield(self) if block_given?
+      end
+
+      def valid?
+        !pay.to_s.empty? && raw_data.is_a?(::Hash) && !raw_data.empty?
+      end
+
+      def to_hash
+        {
+          :pay => pay,
+          :raw_data => raw_data,
+          :extra => extra,
+          :success => success?
+        }
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      def success?
+        !!success
+      end
+    end
+
+    def self.included base
+      base.extend ClassMethods
+      Midpay[base.strategy_name.to_sym] = base
+    end
+
+    module ClassMethods
+      def default_options
+        @default_options ||= Options.new(name: self.strategy_name)
+      end
+
+      def default_arguments
+        @default_arguments ||= Options.new
+      end
+
+      def option name, value = nil
+        default_options[name] = value
+      end
+
+      def set name, value = nil
+        default_arguments[name] = value
+      end
+
+      def strategy_name
+        self.name.split("::").last.to_s.gsub(/(?!(^))([A-Z])/,'_\1\2').downcase
+      end
+    end
+
+    attr_reader :app, :env, :options, :arguments
+
+    def initialize app, *args, &block
+      @app, @env = app, nil
+      opts = args.last.is_a?(::Hash) ? args.pop : {}
+      @options = self.class.default_options.dup
+      [:app_key, :app_secret, :request_params_proc].each do |k|
+        options[k] = opts.delete(k)
+      end
+      @arguments = self.class.default_arguments.dup.merge(opts)
+      options.request_params_proc ||= block
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      @env = env;
+      on_path?(callback_path) ? callback_call! : (on_path?(request_path) ? request_call! : app.call(env))
+    end
+
+    def root_path
+      ::Midpay.config.root_path.to_s.sub(/\/$/,'')
+    end
+
+    def request_path
+      path = options.request_path || "#{root_path}/#{options.name}"
+      path.sub(/\/$/,'')
+    end
+
+    def callback_path
+      path = options.callback_path || "#{root_path}/#{options.name}/callback"
+      path.sub(/\/$/,'')
+    end
+
+    def current_path
+      request.path_info.downcase.sub(/\/$/,'')
+    end
+
+    def on_path? path
+      current_path.casecmp(path) == 0
+    end
+
+    def callback_url
+      URI.join(request.url, callback_path).to_s
+    end
+
+    def request_call!
+      log :info, "midpay request_call!"
+      response = ::Rack::Response.new
+      request_phase(response)
+      response.finish
+    end
+
+    def request_data
+      proc = options.request_params_proc
+      @request_data ||= ::Midpay::SignableHash.new(proc.respond_to?(:call) ? proc.call(request.params.dup) : {})
+    end
+
+    def callback_call!
+      log :info, "midpay callback_call!"
+      pi = PaymentInfo.new(options.name)
+      callback_phase(pi)
+      raise ::Midpay::Errors::InvalidPaymentInfo.new unless pi.valid?
+      env['midpay.strategy'] = self
+      env['midpay.callback'] = pi
+      app.call(env)
+    end
+
+    def request
+      @request ||= ::Rack::Request.new(@env)
+    end
+
+    def request_params
+      @request_params ||= ::Midpay::SignableHash.new(@request.params || {})
+    end
+
+    def log(l ,msg)
+      ::Midpay.logger.send(l, msg)
+    end
+
+    def request_phase(response); raise NotImplementedError.new; end
+    def callback_phase; raise NotImplementedError.new; end
+  end
+end

data/lib/midpay/version.rb

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

data/midpay.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'midpay/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "midpay"
+  spec.version       = Midpay::VERSION
+  spec.authors       = ["xixilive"]
+  spec.email         = ["xixilive@gmail.com"]
+  spec.description   = %q{midpay}
+  spec.summary       = %q{midpay}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency 'hashie'
+  spec.add_dependency 'rack', ">= 1.4"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/spec/midpay/signable_hash_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Midpay::SignableHash do
+  let(:signable){ 
+    Midpay::SignableHash.new({:foo => "Foo", :bar => "Bar", :url => "http://example.com"}, "default")
+  }
+
+  context '#sign' do
+    it 'should return a signature-value that generated by algorithm' do
+      #foo=Foo&bar=Bar&url=http://example.comSECRET MD5=cc2f3b4894dd34fe101df3d06184c386
+      sign = signable.sign('MD5'){|hash| hash.to_a.collect{|i| i.join("=") }.join("&") + "SECRET" }
+      expect(sign).to eq('cc2f3b4894dd34fe101df3d06184c386')
+    end
+  end
+
+  context '#sign!' do
+    it "should append a new specified key with signature-value to current hash" do
+      signable.sign!(:sign, 'MD5'){|hash| hash.to_a.collect{|i| i.join("=") }.join("&") + "SECRET" }
+      expect(signable[:sign]).to eq('cc2f3b4894dd34fe101df3d06184c386')
+    end
+  end
+
+  context '#to_query' do
+    it 'should return a URL formatted string in order' do
+      expect(signable.to_query).to eq("bar=Bar&foo=Foo&url=http%3A%2F%2Fexample.com")
+    end
+  end
+
+  context '#merge_if!' do
+  end
+end

data/spec/midpay/strategy_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class TestStrategy
+  include Midpay::Strategy
+
+  option :name, "test"
+
+  def request_phase response
+    response.write("You are being redirected to /?return_url=#{request_data[:return_url]}&callback=#{callback_url}")
+  end
+
+  def callback_phase pi
+    pi.raw_data = request.params
+    pi.success = true
+  end
+end
+
+describe TestStrategy do
+  include Rack::Test::Methods
+
+  let(:request_params_proc){
+    Proc.new do |params| 
+      {
+        :return_url =>'/return'
+      }
+    end
+  }
+
+  let(:inner_app){
+    lambda {|env| [200, {'Content-Type' => 'text/html'}, ['body']] }
+  }
+
+  let(:app){
+    TestStrategy.new(inner_app, :app_key => "APPKEY", :app_secret => "APPSECRET", :request_params_proc => request_params_proc)
+  }
+
+  it "on request phase" do
+    get '/midpay/test'
+    expect(last_response.body).to eq("You are being redirected to /?return_url=/return&callback=http://example.org/midpay/test/callback")
+  end
+
+  it "on callback_phase" do
+    get '/midpay/test/callback?success=1'
+    expect(last_request.env['midpay.callback'].pay).to eq("test")
+    expect(last_request.env['midpay.callback'].raw_data).to eq({"success" => "1"})
+    expect(last_request.env['midpay.callback'].success?).to be_true
+  end
+
+  it 'out of midpay phases' do
+    get '/'
+    expect(last_response.body).to eq("body")
+  end
+end
+
+describe Midpay::Strategy::Options do
+  let(:options){
+    Midpay::Strategy::Options.new :foo=>'foo', :bar=>'bar'
+  }
+
+  it 'indifferent access' do
+    expect(options['bar']).to eq(options[:bar])
+    options[:another] = 'another'
+    expect(options['another']).to eq('another')
+  end
+
+  it 'method access' do
+    expect(options.bar).to eq(options[:bar])
+    options.another = 'another'
+    expect(options[:another]).to eq('another')
+  end
+end
+
+describe Midpay::Strategy::PaymentInfo do
+  let(:pi){
+    Midpay::Strategy::PaymentInfo.new('test'){|pi|
+      pi.raw_data = {"foo"=>"bar"}
+      pi.extra = {"extra"=>"data"}
+      pi.success = true
+    }
+  }
+
+  it 'should be valid given pay and raw_data are NOT blank' do
+    expect(pi.valid?).to be_true
+    expect(Midpay::Strategy::PaymentInfo.new('test').valid?).to be_false
+  end
+
+  it '#to_hash' do
+    expect(pi.to_hash).to eq({pay: 'test', raw_data: {"foo"=>"bar"}, extra: {"extra"=>"data"}, success: true})
+  end
+
+  it '#to_json' do
+    expect(pi.to_json).to eq('{"pay":"test","raw_data":{"foo":"bar"},"extra":{"extra":"data"},"success":true}')
+  end
+
+  it '#success?' do
+    expect(pi.success?).to be_true
+    expect(Midpay::Strategy::PaymentInfo.new('test').success?).to be_false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+# encoding:utf-8
+require 'rspec'
+require 'rspec/autorun'
+require 'midpay'
+require 'rack/test'
+
+if %W[on yes true 1].include?(ENV['RCOV'])
+  require 'simplecov'
+  require 'simplecov-rcov'
+  class SimpleCov::Formatter::MergedFormatter
+    def format(result)
+      SimpleCov::Formatter::HTMLFormatter.new.format(result)
+      SimpleCov::Formatter::RcovFormatter.new.format(result)
+    end
+  end
+  SimpleCov.formatter = SimpleCov::Formatter::MergedFormatter
+
+  SimpleCov.start "test_frameworks" do 
+    #add_filter ''
+  end
+end
+
+Dir["spec/support/**/*.rb"].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |c|
+  c.before(:suite) do
+    
+  end
+
+  c.before(:each) do
+    
+  end
+
+  c.after(:suite) do
+    
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: midpay
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- xixilive
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: midpay
+email:
+- xixilive@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/midpay.rb
+- lib/midpay/builder.rb
+- lib/midpay/hash/indifferent_access.rb
+- lib/midpay/hash/key_conversion.rb
+- lib/midpay/hash/merge_initializer.rb
+- lib/midpay/hash_extensions.rb
+- lib/midpay/signable_hash.rb
+- lib/midpay/strategy.rb
+- lib/midpay/version.rb
+- midpay.gemspec
+- spec/midpay/signable_hash_spec.rb
+- spec/midpay/strategy_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: midpay
+test_files:
+- spec/midpay/signable_hash_spec.rb
+- spec/midpay/strategy_spec.rb
+- spec/spec_helper.rb