active_merchant_payumoney_com 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+# please add general patterns to your global ignore list
+# see https://github.com/github/gitignore#readme

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org" unless ENV['QUICK']
+gemspec

data/License

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Ram Singla
+
+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/Rakefile

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+begin
+  require 'bundler'
+  Bundler::GemHelper.install_tasks
+rescue LoadError => e
+  $stderr.puts e
+end
+
+desc "run specs"
+task(:spec) { ruby '-S rspec spec' }
+
+desc "generate gemspec"
+task 'active_merchant_payu_in.gemspec' do
+  require 'active_merchant_payu_in/version'
+  content = File.read 'active_merchant_payu_in.gemspec'
+
+  fields = {
+    :authors => `git shortlog -sn`.scan(/[^\d\s].*/),
+    :email   => `git shortlog -sne`.scan(/[^<]+@[^>]+/),
+    :files   => `git ls-files`.split("\n").reject { |f| f =~ /^(\.|Gemfile)/ }
+  }
+
+  fields.each do |field, values|
+    updated = "  s.#{field} = ["
+    updated << values.map { |v| "\n    %p" % v }.join(',')
+    updated << "\n  ]"
+    content.sub!(/  s\.#{field} = \[\n(    .*\n)*  \]/, updated)
+  end
+
+  content.sub! /(s\.version.*=\s+).*/, "\\1\"#{ActiveMerchantPayuIn::VERSION}\""
+  File.open('active_merchant_payu_in.gemspec', 'w') { |f| f << content }
+end
+
+task :gemspec => 'active_merchant_payu_in.gemspec'
+task :default => :spec
+task :test    => :spec

data/active_merchant_payu_in.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_merchant/payu_in/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_merchant_payumoney_com"
+  s.version     = ActiveMerchant::Billing::Integrations::PayuIn::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ram Singla"]
+  s.email       = ["ram.singla@gmail.com"]
+  s.homepage    = "http://www.payumoney.com"
+  s.summary     = %q{PayUMoney.com Payment Gateweay Integration Kit}
+  s.description = %q{PayUMoney.com Payment Gateway integration for ActiveMerchant}
+
+  s.rubyforge_project = "active_merchant_payumoney_com"
+
+  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"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.7.0"])
+      s.add_runtime_dependency(%q<activemerchant>, ["~> 1.8"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.7.0"])
+      s.add_dependency(%q<activemerchant>, ["~> 1.8"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.7.0"])
+    s.add_dependency(%q<activemerchant>, ["~> 1.8"])
+  end
+end

data/lib/active_merchant/payu_in/helper.rb

@@ -0,0 +1,70 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module PayuIn
+        class Helper < ActiveMerchant::Billing::Integrations::Helper
+
+          mapping :amount, 'amount'
+          mapping :account, 'key'
+          mapping :order, 'txnid'
+          mapping :credential2, 'productinfo'
+
+          mapping :customer, :first_name => 'firstname',
+            :last_name  => 'lastname',
+            :email => 'email',
+            :phone => 'phone'
+
+          mapping :billing_address, :city => 'city',
+            :address1 => 'address1',
+            :address2 => 'address2',
+            :state => 'state',
+            :zip => 'zip',
+            :country => 'country'
+
+          # Which	tab	you	want	to	be	open	default	on	PayU
+          # CC (CreditCard) or NB (NetBanking)
+          mapping :mode, 'pg'
+
+          mapping :notify_url, 'notify_url'
+          mapping :return_url, :success => 'surl',
+            :failure => 'furl'
+          mapping :cancel_return_url, 'curl'
+          mapping :checksum, 'hash'
+
+          mapping :user_defined, { :var1 => 'udf1',
+            :var2 => 'udf2',
+            :var3 => 'udf3',
+            :var4 => 'udf4',
+            :var5 => 'udf5',
+            :var6 => 'udf6',
+            :var7 => 'udf7',
+            :var8 => 'udf8',
+            :var9 => 'udf9',
+            :var10 => 'udf10'
+          }
+
+          # Computes the checksum for the form data and add it to the field
+          def add_checksum(  options = {} )
+            checksum_fields = [ :order, :amount, :credential2, { :customer => [ :first_name, :email ] },
+              { :user_defined => [ :var1, :var2, :var3, :var4, :var5, :var6, :var7, :var8, :var9, :var10 ] } ]
+            checksum_payload_items = checksum_fields.inject( [] ) do | items, field |
+              if Hash === field then
+                key = field.keys.first
+                field[key].inject( items ){ |s,x| items.push( form_fields[ mappings[key][x] ] ) }
+                # items.push( form_fields[ field.values.each{ |x| mappings[ key ][ x ] } ] )
+              else
+                items.push( form_fields[ mappings[field] ] )
+              end
+            end
+            checksum_payload_items.push( options )
+            checksum = PayuIn.checksum( *checksum_payload_items )
+            add_field( mappings[:checksum], checksum )
+            return checksum_payload_items
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/active_merchant/payu_in/notification.rb

@@ -0,0 +1,154 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module PayuIn
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+
+          # Was the transaction complete?
+          def complete?
+            status == "success"
+          end
+
+          # Status of the transaction. List of possible values:
+          # <tt>invalid</tt>:: transaction id is not present
+          # <tt>tampered</tt>:: transaction data has been tampered
+          # <tt>success</tt>:: transaction successful
+          # <tt>pending</tt>:: transaction is pending for some approval
+          # <tt>failure</tt>:: transaction failure
+          def status
+            @status ||= if checksum_ok?
+              if transaction_id.blank?
+                'invalid'
+              else
+                transaction_status.downcase
+              end
+            else
+              'tampered'
+            end.freeze
+          end
+
+          def invoice_ok?( order_id )
+            order_id.to_s == invoice.to_s
+          end
+
+          # Order amount should be equal to gross - discount
+          def amount_ok?( order_amount, order_discount = BigDecimal.new( '0.0' ) )
+            BigDecimal.new( gross ) == order_amount && BigDecimal.new( discount ) == order_discount
+          end
+
+          # Status of transaction return from the PayU. List of possible values:
+          # <tt>SUCCESS</tt>::
+          # <tt>PENDING</tt>::
+          # <tt>FAILURE</tt>::
+          def transaction_status
+            params['status']
+          end
+
+          # ID of this transaction (PayU.in number)
+          def transaction_id
+            params['mihpayid']
+          end
+
+          # Mode of Payment
+          #
+          # 'CC' for credit-card
+          # 'NB' for net-banking
+          # 'CD' for cheque or DD
+          # 'CO' for Cash Pickup
+          def type
+            params['mode']
+          end
+
+          # What currency have we been dealing with
+          def currency
+            'INR'
+          end
+
+          # This is the invoice which you passed to PayU.in
+          def invoice
+            params['txnid']
+          end
+
+          # Merchant Id provided by the PayU.in
+          def account
+            params['key']
+          end
+
+          # original amount send by merchant
+          def gross
+            params['amount']
+          end
+
+          # This is discount given to user - based on promotion set by merchants.
+          def discount
+            params['discount']
+          end
+
+          # Description offer for what PayU given the offer to user - based on promotion set by merchants.
+          def offer_description
+            params['offer']
+          end
+
+          # Information about the product as send by merchant
+          def product_info
+            params['productinfo']
+          end
+
+          # Email of the customer
+          def customer_email
+            params['email']
+          end
+
+          # Phone of the customer
+          def customer_phone
+            params['phone']
+          end
+
+          # Firstname of the customer
+          def customer_first_name
+            params['firstname']
+          end
+
+          # Lastname of the customer
+          def customer_last_name
+            params['lastname']
+          end
+
+          # Full address of the customer
+          def customer_address
+            { :address1 => params['address1'], :address2 => params['address2'],
+              :city => params['city'], :state => params['state'],
+              :country => params['country'], :zipcode => params['zipcode'] }
+          end
+
+          def user_defined
+            return @user_defined if @user_defined
+            @user_defined = []
+            10.times{ |i| @user_defined.push( params[ "udf#{i+1}" ] ) }
+            @user_defined
+          end
+
+          def checksum
+            params['hash']
+          end
+
+          def message
+            @message || params['error']
+          end
+
+          def checksum_ok?
+            fields = user_defined.dup.push( customer_email, customer_first_name, product_info, gross, invoice, :reverse => true )
+            fields.unshift( transaction_status )
+            unless PayuIn.checksum( *fields ) == checksum
+              @message = 'Return checksum not matching the data provided'
+              return false
+            end
+            return true
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/active_merchant/payu_in/return.rb

@@ -0,0 +1,56 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module PayuIn
+        class Return < ActiveMerchant::Billing::Integrations::Return
+
+          def initialize(query_string, options = {})
+            @notification = Notification.new(query_string, options)
+          end
+
+          # PayU Transaction Id
+          #
+          def transaction_id
+            @notification.transaction_id
+          end
+
+          # Returns the status of the transaction as a string
+          # The status can be one of the following
+          #
+          # invalid - transaction id not present
+          # tampered - checksum does not mismatch
+          # mismatch - order id mismatch
+          # success - transaction success
+          # pending - transaction pending
+          # failure - transaction failure
+          #
+          # payu does not put the discount field in the checksum
+          # it can be easily forged by the attacker without detection
+          #
+          def status( order_id, order_amount )
+            if @notification.invoice_ok?( order_id ) && @notification.amount_ok?( order_amount )
+              @notification.status
+            else
+              'mismatch'.freeze
+            end
+          end
+
+          # check success of the transaction
+          # check order_id and
+          def success?( order_id, order_amount )
+            status( order_id, order_amount ) == 'success'
+          end
+
+          def cancelled?
+            false
+          end
+
+          def message
+            @notification.message
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/payu_in/version.rb

@@ -0,0 +1,48 @@
+module ActiveMerchant
+  module Billing
+    module Integrations
+      module PayuIn
+        def self.version
+          VERSION
+        end
+
+        module VERSION
+          extend Comparable
+
+          MAJOR     = 0
+          MINOR     = 0
+          TINY      = 1
+          SIGNATURE = [MAJOR, MINOR, TINY]
+          STRING    = SIGNATURE.join '.'
+
+          def self.major; MAJOR  end
+          def self.minor; MINOR  end
+          def self.tiny;  TINY   end
+          def self.to_s;  STRING end
+
+          def self.hash
+            STRING.hash
+          end
+
+          def self.<=>(other)
+            other = other.split('.').map { |i| i.to_i } if other.respond_to? :split
+            SIGNATURE <=> Array(other)
+          end
+
+          def self.inspect
+            STRING.inspect
+          end
+
+          def self.respond_to?(meth, *)
+            meth.to_s !~ /^__|^to_str$/ and STRING.respond_to? meth unless super
+          end
+
+          def self.method_missing(meth, *args, &block)
+            return super unless STRING.respond_to?(meth)
+            STRING.send(meth, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/payu_in/web_service.rb

@@ -0,0 +1,89 @@
+require 'net/http'
+require 'php_serialize'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module PayuIn
+
+        # PayU.in provides web services to help you with reconciliation of your transactions in real time.
+        class WebService < Hash
+
+          # Add helper method to make api calls using ssl_post, ssl_get
+          include PostsData
+
+          # Whether the invoice is success or not
+          # Invoice id is required when multiple invoices are queried at once
+          def complete?( invoice_id = nil )
+            status( invoice_id ).to_s.downcase == 'success'
+          end
+
+          # Whether the invoice is pending confirmation
+          # Invoice id is required when multiple invoices are queried at once
+          def pending?( invoice_id = nil )
+            status( invoice_id ).to_s.downcase == 'pending'
+          end
+
+          # Returns the payment status of the invoice
+          # invoice_id is required if multiple invoices are queried at once
+          def status( invoice_id = nil )
+            ( invoice_id ? self[ invoice_id.to_s ] : self )[ 'status']
+          end
+
+          # Returns whether the order amount and order discount matches
+          # generally in third party shopping carts order discount is handle by the application
+          # and should generally by 0.0
+          def amount_ok?( order_amount, order_discount = BigDecimal.new( '0.0' ), invoice_id = nil )
+            hash = ( invoice_id ? self[ invoice_id.to_s ] : self )
+            ( BigDecimal.new( hash[ 'amt' ] ) == order_amount ) && ( BigDecimal.new( hash[ 'disc' ] ) == order_discount )
+          end
+
+          # Returns whether the nett amount after reducing the discounts
+          def nett_amount( invoice_id = nil )
+            hash = ( invoice_id ? self[ invoice_id.to_s ] : self )
+            BigDecimal.new( hash[ 'amt' ] ) - BigDecimal.new( hash[ 'disc' ] )
+          end
+
+          # Returns the PayU.in transaction if for the invocie
+          # invoice_id is required if multiple invoices are queried at once
+          def transaction_id( invoice_id = nil )
+            ( invoice_id ? self[ invoice_id.to_s ] : self )[ 'mihpayid']
+          end
+
+          # Makes verify payment API call to PayU.in web service
+          # Params - any number of invoice ids ( provided by the merchant )
+          def self.verify_payment( *invoice_ids )
+            invoice_string = invoice_ids.join( '|' )
+            checksum = PayuIn.checksum( 'verify_payment', invoice_string )
+            new.web_service_call( :command => 'verify_payment', :var1 => invoice_string, :hash => checksum, :key => PayuIn.merchant_id )
+          end
+
+          # Makes check payment API call to PayU.in web service
+          # Params - PayU.in transaction id
+          def self.check_payment( payu_id )
+            checksum = PayuIn.checksum( 'check_payment', payu_id )
+            new.web_service_call( :command => 'check_payment', :var1 => payu_id, :hash => checksum, :key => PayuIn.merchant_id )
+          end
+
+          # Utility method which makes the web service call and
+          # parse the response into WebService object
+          def web_service_call( params = {} )
+            payload_hash = ActiveMerchant::PostData.new
+            payload_hash.merge!( params )
+            payload = payload_hash.to_post_data
+            response = PHP.unserialize(
+              ssl_post(
+                PayuIn.web_service_url, payload,
+                'Content-Length' => "#{payload.size}",
+                'User-Agent'     => "Active Merchant -- http://activemerchant.org",
+                'service_provider' => "payu_paisa"
+              )
+            )
+            merge!( response["transaction_details"] && response["transaction_details"].size == 1 ? response["transaction_details"].values.first : ( response["transaction_details"] || { :status => response['msg'] } ) )
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant_payu_in.rb

@@ -0,0 +1,108 @@
+require 'active_merchant'
+require 'active_merchant/billing/integrations'
+require 'digest/sha2'
+require 'bigdecimal'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module PayuIn
+        autoload :Return, 'active_merchant/payu_in/return.rb'
+        autoload :Helper, 'active_merchant/payu_in/helper.rb'
+        autoload :Notification, 'active_merchant/payu_in/notification.rb'
+        autoload :WebService, 'active_merchant/payu_in/web_service.rb'
+
+        mattr_accessor :merchant_id
+        mattr_accessor :secret_key
+
+        # Overwrite this if you want to change the PayU.in test url
+        mattr_accessor :test_url
+        self.test_url = 'https://test.payu.in/_payment.php'
+
+        # Overwrite this if you want to change the PayU.in test web
+        # service url
+        mattr_accessor :test_web_service_url
+        self.test_web_service_url = 'https://test.payu.in/merchant/postservice.php'
+
+        # Overwrite this if you want to change the PayU.in production url
+        mattr_accessor :production_url
+        self.production_url = 'https://secure.payu.in/_payment.php'
+
+        # Overwrite this if you want to change the PayU.in production web
+        # service url
+        mattr_accessor :production_web_service_url
+        self.production_web_service_url = 'https://info.payu.in/merchant/postservice.php'
+
+        def self.new( options = {} )
+          self.merchant_id = options[:merchant_id]
+          self.secret_key = options[:secret_key]
+          self
+        end
+
+        def self.service_url
+          mode = ActiveMerchant::Billing::Base.integration_mode
+          case mode
+          when :production
+            self.production_url
+          when :test
+            self.test_url
+          else
+            raise StandardError, "Integration mode set to an invalid value: #{mode}"
+          end
+        end
+
+        def self.web_service_url
+          mode = ActiveMerchant::Billing::Base.integration_mode
+          case mode
+          when :production
+            self.production_web_service_url
+          when :test
+            self.test_web_service_url
+          else
+            raise StandardError, "Integration mode set to an invalid value: #{mode}"
+          end
+        end
+
+        # Query the PayU server using there web services
+        def self.query( command, *args )
+          WebService.send( command, *args )
+        end
+
+        def self.return(query_string, options = {})
+          Return.new(query_string, options)
+        end
+
+        def self.checksum( *payload_items )
+          options = payload_items.pop if Hash === payload_items.last
+          options ||= {}
+          payload = if options[:reverse] then
+            payload_items.dup.push( self.merchant_id || "" ).unshift( self.secret_key || "" ).collect{ |x| trim(x) }.join("|")
+          else
+            payload_items.dup.unshift( self.merchant_id || "" ).push( self.secret_key || "" ).collect{ |x| trim(x) }.join("|")
+          end
+          if options[:debug]
+            puts "-"*80
+            puts payload
+            puts "-"*80
+          end
+          Digest::SHA512.hexdigest( payload )
+        end
+
+        # PayU uses php trim when building the string to compute the checksum
+        # trim removes whitespaces from start and end of the string
+        # and floats cannot have trailing zeros
+        def self.trim(obj)
+          # if (BigDecimal === obj)
+          #   obj.to_s('F')
+          # else
+          #   obj.to_s
+          # end.strip.gsub(/(\\d+)\\.0$/){ $1 }.gsub(/(\\d+)(\\.[1-9]+)0+$/){ $1+$2 }
+          obj.to_s
+        end
+
+      end
+    end
+  end
+end
+
+require 'active_merchant/payu_in/version'

data/lib/php_serialize.rb

@@ -0,0 +1,313 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2003-2009 Thomas Hurst <tom@hur.st>
+#
+# 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.
+
+# PHP serialize() and unserialize() workalikes
+#
+# Release History:
+#  1.0.0 - 2003-06-02 - First release.
+#  1.0.1 - 2003-06-16 - Minor bugfixes.
+#  1.0.2 - 2004-09-17 - Switch all {}'s to explicit Hash.new's.
+#  1.1.0 - 2009-04-01 - Pass assoc to recursive calls (thanks to Edward Speyer).
+#                     - Serialize Symbol like String.
+#                     - Add testsuite.
+#                     - Instantiate auto-generated Structs properly (thanks
+#                       to Philip Hallstrom).
+#                     - Unserialize arrays properly in assoc mode.
+#                     - Add PHP session support (thanks to TJ Vanderpoel).
+#                     - Release as tarball and gem.
+#
+# See http://www.php.net/serialize and http://www.php.net/unserialize for
+# details on the PHP side of all this.
+module PHP
+  # string = PHP.serialize(mixed var[, bool assoc])
+  #
+  # Returns a string representing the argument in a form PHP.unserialize
+  # and PHP's unserialize() should both be able to load.
+  #
+  # Array, Hash, Fixnum, Float, True/FalseClass, NilClass, String and Struct
+  # are supported; as are objects which support the to_assoc method, which
+  # returns an array of the form [['attr_name', 'value']..].  Anything else
+  # will raise a TypeError.
+  #
+  # If 'assoc' is specified, Array's who's first element is a two value
+  # array will be assumed to be an associative array, and will be serialized
+  # as a PHP associative array rather than a multidimensional array.
+  def PHP.serialize(var, assoc = false) # {{{
+    s = ''
+    case var
+    when Array
+      s << "a:#{var.size}:{"
+      if assoc and var.first.is_a?(Array) and var.first.size == 2
+        var.each { |k,v|
+          s << PHP.serialize(k, assoc) << PHP.serialize(v, assoc)
+        }
+      else
+        var.each_with_index { |v,i|
+          s << "i:#{i};#{PHP.serialize(v, assoc)}"
+        }
+      end
+
+      s << '}'
+
+    when Hash
+      s << "a:#{var.size}:{"
+      var.each do |k,v|
+        s << "#{PHP.serialize(k, assoc)}#{PHP.serialize(v, assoc)}"
+      end
+      s << '}'
+
+    when Struct
+      # encode as Object with same name
+      s << "O:#{var.class.to_s.length}:\"#{var.class.to_s.downcase}\":#{var.members.length}:{"
+      var.members.each do |member|
+        s << "#{PHP.serialize(member, assoc)}#{PHP.serialize(var[member], assoc)}"
+      end
+      s << '}'
+
+    when String, Symbol
+      s << "s:#{var.to_s.bytesize}:\"#{var.to_s}\";"
+
+    when Fixnum # PHP doesn't have bignums
+      s << "i:#{var};"
+
+    when Float
+      s << "d:#{var};"
+
+    when NilClass
+      s << 'N;'
+
+    when FalseClass, TrueClass
+      s << "b:#{var ? 1 :0};"
+
+    else
+      if var.respond_to?(:to_assoc)
+        v = var.to_assoc
+        # encode as Object with same name
+        s << "O:#{var.class.to_s.length}:\"#{var.class.to_s.downcase}\":#{v.length}:{"
+        v.each do |k,v|
+          s << "#{PHP.serialize(k.to_s, assoc)}#{PHP.serialize(v, assoc)}"
+        end
+        s << '}'
+      else
+        raise TypeError, "Unable to serialize type #{var.class}"
+      end
+    end
+
+    s
+  end # }}}
+
+  # string = PHP.serialize_session(mixed var[, bool assoc])
+  #
+  # Like PHP.serialize, but only accepts a Hash or associative Array as the root
+  # type.  The results are returned in PHP session format.
+  def PHP.serialize_session(var, assoc = false) # {{{
+    s = ''
+    case var
+    when Hash
+      var.each do |key,value|
+        if key.to_s =~ /\|/
+          raise IndexError, "Top level names may not contain pipes"
+        end
+        s << "#{key}|#{PHP.serialize(value, assoc)}"
+      end
+    when Array
+      var.each do |x|
+        case x
+        when Array
+          if x.size == 2
+            s << "#{x[0]}|#{PHP.serialize(x[1])}"
+          else
+            raise TypeError, "Array is not associative"
+          end
+        end
+      end
+    else
+      raise TypeError, "Unable to serialize sessions with top level types other than Hash and associative Array"
+    end
+    s
+  end # }}}
+
+  # mixed = PHP.unserialize(string serialized, [hash classmap, [bool assoc]])
+  #
+  # Returns an object containing the reconstituted data from serialized.
+  #
+  # If a PHP array (associative; like an ordered hash) is encountered, it
+  # scans the keys; if they're all incrementing integers counting from 0,
+  # it's unserialized as an Array, otherwise it's unserialized as a Hash.
+  # Note: this will lose ordering.  To avoid this, specify assoc=true,
+  # and it will be unserialized as an associative array: [[key,value],...]
+  #
+  # If a serialized object is encountered, the hash 'classmap' is searched for
+  # the class name (as a symbol).  Since PHP classnames are not case-preserving,
+  # this *must* be a .capitalize()d representation.  The value is expected
+  # to be the class itself; i.e. something you could call .new on.
+  #
+  # If it's not found in 'classmap', the current constant namespace is searched,
+  # and failing that, a new Struct(classname) is generated, with the arguments
+  # for .new specified in the same order PHP provided; since PHP uses hashes
+  # to represent attributes, this should be the same order they're specified
+  # in PHP, but this is untested.
+  #
+  # each serialized attribute is sent to the new object using the respective
+  # {attribute}=() method; you'll get a NameError if the method doesn't exist.
+  #
+  # Array, Hash, Fixnum, Float, True/FalseClass, NilClass and String should
+  # be returned identically (i.e. foo == PHP.unserialize(PHP.serialize(foo))
+  # for these types); Struct should be too, provided it's in the namespace
+  # Module.const_get within unserialize() can see, or you gave it the same
+  # name in the Struct.new(<structname>), otherwise you should provide it in
+  # classmap.
+  #
+  # Note: StringIO is required for unserialize(); it's loaded as needed
+  def PHP.unserialize(string, classmap = nil, assoc = false) # {{{
+    if classmap == true or classmap == false
+      assoc = classmap
+      classmap = {}
+    end
+    classmap ||= {}
+
+    require 'stringio'
+    string = StringIO.new(string)
+    def string.read_until(char)
+      val = ''
+      while (c = self.read(1)) != char
+        val << c
+      end
+      val
+    end
+
+    if string.string =~ /^(\w+)\|/ # session_name|serialized_data
+      ret = Hash.new
+      loop do
+        if string.string[string.pos, 32] =~ /^(\w+)\|/
+          string.pos += $&.size
+          ret[$1] = PHP.do_unserialize(string, classmap, assoc)
+        else
+          break
+        end
+      end
+      ret
+    else
+      PHP.do_unserialize(string, classmap, assoc)
+    end
+  end
+
+  private
+  def PHP.do_unserialize(string, classmap, assoc)
+    val = nil
+    # determine a type
+    type = string.read(2)[0,1]
+    case type
+    when 'a' # associative array, a:length:{[index][value]...}
+      count = string.read_until('{').to_i
+      val = vals = Array.new
+      count.times do |i|
+        vals << [do_unserialize(string, classmap, assoc), do_unserialize(string, classmap, assoc)]
+      end
+      string.read(1) # skip the ending }
+
+      # now, we have an associative array, let's clean it up a bit...
+      # arrays have all numeric indexes, in order; otherwise we assume a hash
+      array = true
+      i = 0
+      vals.each do |key,value|
+        if key != i # wrong index -> assume hash
+          array = false
+          break
+        end
+        i += 1
+      end
+
+      if array
+        vals.collect! do |key,value|
+          value
+        end
+      else
+        if assoc
+          val = vals.map {|v| v }
+        else
+          val = Hash.new
+          vals.each do |key,value|
+            val[key] = value
+          end
+        end
+      end
+
+    when 'O' # object, O:length:"class":length:{[attribute][value]...}
+      # class name (lowercase in PHP, grr)
+      len = string.read_until(':').to_i + 3 # quotes, seperator
+      klass = string.read(len)[1...-2].capitalize.intern # read it, kill useless quotes
+
+      # read the attributes
+      attrs = []
+      len = string.read_until('{').to_i
+
+      len.times do
+        attr = (do_unserialize(string, classmap, assoc))
+        attrs << [attr.intern, (attr << '=').intern, do_unserialize(string, classmap, assoc)]
+      end
+      string.read(1)
+
+      val = nil
+      # See if we need to map to a particular object
+      if classmap.has_key?(klass)
+        val = classmap[klass].new
+      elsif Struct.const_defined?(klass) # Nope; see if there's a Struct
+        classmap[klass] = val = Struct.const_get(klass)
+        val = val.new
+      else # Nope; see if there's a Constant
+        begin
+          classmap[klass] = val = Module.const_get(klass)
+
+          val = val.new
+        rescue NameError # Nope; make a new Struct
+          classmap[klass] = Struct.new(klass.to_s, *attrs.collect { |v| v[0].to_s })
+          val = val.new
+        end
+      end
+
+      attrs.each do |attr,attrassign,v|
+        val.__send__(attrassign, v)
+      end
+
+    when 's' # string, s:length:"data";
+      len = string.read_until(':').to_i + 3 # quotes, separator
+      val = string.read(len)[1...-2] # read it, kill useless quotes
+
+    when 'i' # integer, i:123
+      val = string.read_until(';').to_i
+
+    when 'd' # double (float), d:1.23
+      val = string.read_until(';').to_f
+
+    when 'N' # NULL, N;
+      val = nil
+
+    when 'b' # bool, b:0 or 1
+      val = (string.read(2)[0] == ?1 ? true : false)
+
+    else
+      raise TypeError, "Unable to unserialize type '#{type}'"
+    end
+
+    val
+  end # }}}
+end

data/spec/active_merchant_payu_in_spec.rb

@@ -0,0 +1,5 @@
+require 'active_merchant_payu_in'
+
+describe ActiveMerchantPayuIn do
+  it "should behave"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: active_merchant_payumoney_com
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ram Singla
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+- !ruby/object:Gem::Dependency
+  name: activemerchant
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: PayUMoney.com Payment Gateway integration for ActiveMerchant
+email:
+- ram.singla@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- License
+- Rakefile
+- active_merchant_payu_in.gemspec
+- lib/active_merchant/payu_in/helper.rb
+- lib/active_merchant/payu_in/notification.rb
+- lib/active_merchant/payu_in/return.rb
+- lib/active_merchant/payu_in/version.rb
+- lib/active_merchant/payu_in/web_service.rb
+- lib/active_merchant_payu_in.rb
+- lib/php_serialize.rb
+- pkg/active_merchant_payu_in-0.0.1.gem
+- spec/active_merchant_payu_in_spec.rb
+homepage: http://www.payumoney.com
+licenses: []
+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: active_merchant_payumoney_com
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: PayUMoney.com Payment Gateweay Integration Kit
+test_files: []
+has_rdoc: