wepay-rails 1.1.0 → 2.0.0

data/README.rdoc

@@ -6,13 +6,6 @@ To install it, add this to your Gemfile
 
     gem 'wepay-rails'
 
-Since Wepay uses Oauth2 to authenticate, wepay-rails has been built to handle this for you. You will need to
-add a column to one of your models to hold the authentication token. For example, if you have a user model:
-
-Your migration:
-
-    add_column :users, :wepay_auth_code, :string
-
 You need to also create a new model called WepayCheckoutRecord. It will be updated by wepay's IPN system as changes to the checkout change - such as the status.
 Wepay-rails handles those IPN notifications for you. You can write observers watching the WepayCheckoutRecord model if you need to have
 something specific occur when the checkout changes.
@@ -25,12 +18,23 @@ This will create 3 files for you, a migration file for a table to hold the check
 
     rake db:migrate
 
-Modify config/wepay.yml.example to your needs. You will need to set the model and column where you are storing your wepay auth code:
+Modify config/wepay.yml.example to your needs and copy it to config/wepay.yml.
+
+Assuming that you have:
+
+1. created an account on wepay
+2. created a user to accept the payments
+3. created your application for your account
+4. set your wepay.yml file with the info it needs to talk to the wepay api minus the access_token
+
+You can now get your access token.
 
-Snippet of wepay.yml showing the auth_code_location directive:
+To fetch your access_token, open a browser and go to:
 
-    production:
-      auth_code_location: User.wepay_auth_code
+    your.railsapp.com/wepay/authorize
+
+Login at the prompt or register. You will be sent back to your app and you should have gotten an access_token. Copy it to your wepay.yml
+file and restart your app.
 
 You will have to set up a few new controllers in your rails app to handle callbacks and redirects from wepay.
 I created one called finalize_controller and I use it for a landing page when the customer is finished paying
@@ -44,24 +48,20 @@ For now, here's what I am doing in my rails app to handle it...
                         |_ checkout_controller.rb
                         |_ finalize_controller.rb
 
-Finally, your checkout controller (or some controller that will interact with the Wepay API):
+You will need to set the location of these files in your wepay.yml file. The directives are:
 
-    class Purchase::CheckoutController < Purchase::PurchaseController
-        before_filter :authenticate_user! # I am using devise - this line depends on your authentication scheme
+    after_authorize_redirect_uri: "http://www.example.com/purchase/checkout"
+    after_checkout_redirect_uri: "http://www.example.com/purchase/finalize"
 
-        # PLEASE READ
-        # I am saving the wepay_auth_code in my Profile model. Somewhere in my rails app, I have a method called
-        # current_profile which I use to return the Profile object of my user. I pass that object through the
-        # init_checkout_and_send_user_to_wepay method along with my checkout parameters.
+Finally, your checkout controller (or some controller that will interact with the Wepay API) - notice it includes WepayRails::Payments:
 
-        # After the customer is sent to wepay, when they are done paying you, they will be redirected
-        # back to your application - you will set the location they will be redirected back to using the redirect_uri directive
-        # either here - or in wepay.yml. Using it here overrides wepay.yml.
+    class Purchase::CheckoutController < ApplicationController
+        include WepayRails::Payments
 
-        def index
+        before_filter :authenticate_user! # I am using devise - this line depends on your authentication scheme
 
+        def index
             cart = current_user.cart # EXAMPLE - get my shopping cart
-            tx_id = cart.transaction_id # EXAMPLE - I use a column in my cart to have a way to look up the cart upon the user's return from wepay
 
             checkout_params = {
                 :amount => cart.grand_total,
@@ -70,14 +70,14 @@ Finally, your checkout controller (or some controller that will interact with th
             }
 
             # Finally, send the user off to wepay so you can get paid! - CASH MONEY
-            init_checkout_and_send_user_to_wepay(checkout_params, current_user)
+            init_checkout_and_send_user_to_wepay(checkout_params)
         end
     end
 
 The controller I use for finalizing the checkout - AKA - the controller the user is sent back to after his/her trip to
 wepay to checkout.
 
-    class Purchase::FinalizeController < Wepay::ApplicationController
+    class Purchase::FinalizeController < ApplicationController
       def index
         wcr  = WepayCheckoutRecord.find_by_checkout_id(params[:checkout_id])
 
@@ -89,7 +89,7 @@ wepay to checkout.
         # Convert cart to an order?? Move to observer of WepayCheckoutRecord??
         cart.convert_cart_to_order if wcr.state == 'authorized'
 
-        render :text => wcr.inspect
+        render :text => "Hooray - you bought some widgets!"
       end
     end
 

data/VERSION

@@ -1 +1 @@
-1.1.0
+2.0.0

data/app/controllers/wepay/application_controller.rb

@@ -1,11 +1,2 @@
 class Wepay::ApplicationController < ApplicationController
-  include WepayRails::Payments
-
-  def wepayable_class
-    WepayRails::Configuration.wepayable_class
-  end
-
-  def wepayable_column
-    WepayRails::Configuration.wepayable_column
-  end
 end

data/app/controllers/wepay/authorize_controller.rb

@@ -1,17 +1,19 @@
+require 'digest/sha2'
 class Wepay::AuthorizeController < Wepay::ApplicationController
+
   def index
-    ref_id = session[unique_wepay_auth_token_key]
+    wepay_gateway = WepayRails::Payments::Gateway.new
 
-    if WepayRails::Configuration.settings[:orm] == 'mongoid'
-      wepayable = wepayable_class.where(wepayable_column => ref_id)[0]
+    if params[:code].present?
+      access_token = wepay_gateway.get_access_token(params[:code], redirect_uri)
+      render :text => "Copy this access token, #{access_token} to the access_token directive in your wepay.yml"
     else
-      wepayable = wepayable_class.all(:conditions => ["#{wepayable_column} = ?", ref_id])[0]
+      redirect_to wepay_gateway.auth_code_url redirect_uri
     end
+  end
 
-    wepayable.update_attribute(wepayable_column.to_sym, params[:code])
-    redirect_to session[:after_authorize_redirect_uri] and return if session[:after_authorize_redirect_uri]
-    redirect_to WepayRails::Configuration.settings[:after_authorize_redirect_uri]
-  rescue => e
-    raise AuthorizationError.new("WepayRails was unable to find the record to save the auth code to. : #{e.message}") unless wepayable.present?
+  private
+  def redirect_uri
+    "#{WepayRails::Configuration.settings[:root_callback_uri]}/wepay/authorize"
   end
 end

data/app/controllers/wepay/ipn_controller.rb

@@ -1,10 +1,10 @@
 class Wepay::IpnController < Wepay::ApplicationController
-  def index
+  def create
 
     record = WepayCheckoutRecord.find_by_checkout_id(params[:checkout_id])
 
     if record.present?
-      wepay_gateway.wepay_access_token = record.access_token
+      wepay_gateway = WepayRails::Payments::Gateway.new
       checkout = wepay_gateway.lookup_checkout(record.checkout_id)
       record.update_attributes(checkout)
       render :text => "ok"

data/lib/api/account_methods.rb

@@ -2,27 +2,27 @@ module WepayRails
   module Api
     module AccountMethods
       def create_account(params)
-        self.call("/account/create", {:body => params})
+        self.call_api("/account/create", params)
       end
 
       def get_account(account_id)
-        self.call("/account", {:body => {:account_id => account_id}})
+        self.call_api("/account", {:account_id => account_id})
       end
 
       def find_account(args)
-        self.call("/account/find", {:body => args})
+        self.call_api("/account/find", args)
       end
 
       def modify_account(args)
-        self.call("/account/modify", {:body => args})
+        self.call_api("/account/modify", args)
       end
 
       def delete_account(account_id)
-        self.call("/account/delete", {:body => {:account_id => account_id}})
+        self.call_api("/account/delete", {:account_id => account_id})
       end
 
       def get_account_balance(account_id)
-        self.call("/account/balance", {:body => {:account_id => account_id}})
+        self.call_api("/account/balance", {:account_id => account_id})
       end
     end
   end

data/lib/api/checkout_methods.rb

@@ -38,23 +38,33 @@ module WepayRails
       # :charge_tax	No	A boolean value (0 or 1). If set to 1 and the account has a relevant tax entry (see /account/set_tax), then tax will be charged.
       def perform_checkout(parms)
         defaults = {
-            :callback_uri => (@wepay_config[:ipn_callback_uri].present? ? @wepay_config[:ipn_callback_uri] : "#{@wepay_config[:root_callback_uri]}/wepay/ipn"),
-            :redirect_uri => (@wepay_config[:checkout_redirect_uri].present? ? @wepay_config[:checkout_redirect_uri] : "#{@wepay_config[:root_callback_uri]}/wepay/checkout"),
-            :fee_payer => @wepay_config[:fee_payer],
-            :type => @wepay_config[:checkout_type],
-            :charge_tax => @wepay_config[:charge_tax] ? 1 : 0,
-            :app_fee => @wepay_config[:app_fee],
-            :auto_capture => @wepay_config[:auto_capture] ? 1 : 0,
+            :callback_uri     => ipn_callback_uri,
+            :redirect_uri     => checkout_redirect_uri,
+            :fee_payer        => @wepay_config[:fee_payer],
+            :type             => @wepay_config[:checkout_type],
+            :charge_tax       => @wepay_config[:charge_tax] ? 1 : 0,
+            :app_fee          => @wepay_config[:app_fee],
+            :auto_capture     => @wepay_config[:auto_capture] ? 1 : 0,
             :require_shipping => @wepay_config[:require_shipping] ? 1 : 0,
-            :shipping_fee => @wepay_config[:shipping_fee],
-            :account_id => @wepay_config[:account_id]
+            :shipping_fee     => @wepay_config[:shipping_fee],
+            :account_id       => @wepay_config[:account_id]
         }.merge(parms)
 
-        self.call("/checkout/create", {:body => defaults})
+        self.call_api("/checkout/create", defaults)
       end
 
       def lookup_checkout(checkout_id)
-        self.call("/checkout", {:body => {:checkout_id => checkout_id}})
+        self.call_api("/checkout", {:checkout_id => checkout_id})
+      end
+
+      def ipn_callback_uri
+        return @wepay_config[:ipn_callback_uri] if @wepay_config[:ipn_callback_uri].present?
+        "#{@wepay_config[:root_callback_uri]}/wepay/ipn"
+      end
+
+      def checkout_redirect_uri
+        return @wepay_config[:checkout_redirect_uri] if @wepay_config[:checkout_redirect_uri].present?
+        "#{@wepay_config[:root_callback_uri]}/wepay/checkout"
       end
     end
   end

data/lib/generators/wepay_rails/install/templates/create_wepay_checkout_records.rb

@@ -4,8 +4,6 @@ class CreateWepayCheckoutRecords < ActiveRecord::Migration
         create_table :wepay_checkout_records do |t|
             t.integer :checkout_id
             t.integer :account_id
-            t.string :auth_code
-            t.string :access_token
             t.string :state
             t.string :short_description
             t.text :long_description

data/lib/generators/wepay_rails/install/templates/wepay.yml

@@ -2,13 +2,13 @@ production:
   client_id: <your client id from wepay>
   client_secret: <your client secret from wepay>
   account_id: <your account id from wepay>
-  auth_code_location: MyModel.wepay_auth_code #model and column where you store the auth code for each of your customers eg. Profile.wepay_auth_code
+  access_token: <your access token that you recieved when you went to http://your.domain.com/wepay/authorize>
   root_callback_uri: "http://www.example.com"
   after_authorize_redirect_uri: "http://www.example.com/purchase/checkout"
   after_checkout_redirect_uri: "http://www.example.com/purchase/finalize"
+  registration_confirmation_uri: "http://www.example.com/purchase/cart?msg=Please confirm your wepay account."
   scope: [refund_payments,collect_payments,view_balance,view_user]
-  wepay_api_uri: "https://api.wepay.com"
-  wepay_api_version: "v2"
+  wepay_api_uri: "https://api.wepay.com/v2"
   fee_payer: Payee
   checkout_type: GOODS
   charge_tax: false

data/lib/helpers/controller_helpers.rb

@@ -2,77 +2,6 @@ module WepayRails
   module Helpers
     module ControllerHelpers
 
-      def redirect_to_wepay_for_auth(wepayable_object, params = {})
-        # Initially set a reference ID to the column created for the wepayable
-        # so that when the redirect back from wepay happens, we can reference
-        # the original wepayable, and then save the new auth code into the reference ID's
-        # place
-        ref_id = Digest::SHA1.hexdigest("#{Time.now.to_i+rand(4)}")
-        session[unique_wepay_auth_token_key] = ref_id
-        wepayable_object.update_attribute(WepayRails::Configuration.wepayable_column.to_sym, ref_id)
-
-        redirect_to wepay_gateway.auth_code_url(params)
-      end
-
-      # @deprecated Use wepay_gateway instead of gateway
-      def gateway
-        warn "[DEPRECATION] Use wepay_gateway instead of gateway"
-        wepay_gateway
-      end
-
-      def wepay_gateway
-        @gateway ||= WepayRails::Payments::Gateway.new(wepay_access_token)
-      end
-
-      # From https://stage.wepay.com/developer/tutorial/authorization
-      # Request
-      # https://stage.wepay.com/v2/oauth2/token
-      # ?client_id=[your client id]
-      # &redirect_uri=[your redirect uri ex. 'http://exampleapp.com/wepay']
-      # &client_secret=[your client secret]
-      # &code=[the code you got in step one]
-      #
-      # Response
-      # {"user_id":"123456","access_token":"1337h4x0rzabcd12345","token_type":"BEARER"} Example
-      def initialize_wepay_access_token(wepayable_object)
-        return if wepay_access_token_exists?
-        begin
-          # check to see if they have an auth code
-          # If not, send them to wepay to get one
-          wepayable_column = WepayRails::Configuration.wepayable_column
-          raise unless wepayable_object.send(wepayable_column.to_sym).present?
-
-          # It's possible that we raise an exception here - probably the auth code
-          # was too old and they need an updated one. Send them to wepay to
-          # get a new one if a raise happens while we run the following line of code.
-          session[unique_wepay_access_token_key] = wepay_gateway.access_token(wepayable_object)
-        rescue
-          redirect_to_wepay_for_auth(wepayable_object)
-        end
-        return
-      end
-
-      # Since we are saving the access token in the session,
-      # ensure key uniqueness. Might be a good idea to have this
-      # be a setting in the wepay.yml file.
-      def unique_wepay_access_token_key
-        :IODDR8856UUFG6788
-      end
-
-      def unique_wepay_auth_token_key
-        :J8876GFUU6588RDDO
-      end
-
-      # Access token is the OAUTH access token that is used for future
-      # comunique
-      def wepay_access_token
-        session[unique_wepay_access_token_key]
-      end
-
-      def wepay_access_token_exists?
-        wepay_access_token.present?
-      end
-
       # Many of the settings you pass in here are already factored in from
       # the wepay.yml file and only need to be overridden if you insist on doing
       # so when this method is called. The following list of key values are pulled
@@ -108,28 +37,16 @@ module WepayRails
       # :require_shipping	No	A boolean value (0 or 1). If set to 1 then the payer will be asked to enter a shipping address when they pay. After payment you can retrieve this shipping address by calling /checkout
       # :shipping_fee	No	The amount that you want to charge for shipping.
       # :charge_tax	No	A boolean value (0 or 1). If set to 1 and the account has a relevant tax entry (see /account/set_tax), then tax will be charged.
-      def init_checkout_and_send_user_to_wepay(params, wepayable_object)
-        initialize_wepay_access_token(wepayable_object)
-        response = wepay_gateway.perform_checkout(params)
-
-        unless response && response.has_key?('checkout_uri')
-          raise WepayRails::Exceptions::InitializeCheckoutError.new("A problem occurred while trying to checkout.
-          Wepay didn't send us back a checkout uri. Response was: #{response.inspect},
-          Params were: #{params}, Token was: #{wepay_access_token}")
-        end
-
-        wepayable_column = WepayRails::Configuration.wepayable_column
-        raise unless wepayable_object.send(wepayable_column.to_sym).present?
-
-        wcr_params = {
-            :auth_code    => wepayable_object.send(wepayable_column),
-            :access_token => wepay_access_token,
+      def init_checkout_and_send_user_to_wepay(params, access_token=nil)
+        wepay_gateway = WepayRails::Payments::Gateway.new(access_token)
+        response      = wepay_gateway.perform_checkout(params)
+        params.merge!({
+            :access_token => wepay_gateway.access_token,
             :checkout_id  => response['checkout_id']
-        }
-
-        params.merge!(wcr_params)
+        })
 
         WepayCheckoutRecord.create(params)
+
         redirect_to response['checkout_uri'] and return
       end
     end

data/lib/wepay-rails.rb

@@ -4,23 +4,12 @@ require 'api/account_methods'
 require 'api/checkout_methods'
 module WepayRails
   class Configuration
-    @@wepayable_class = nil
-    @@wepayable_column = nil
     @@settings = nil
 
-    def self.init_conf(klass, column, settings)
-      @@wepayable_class, @@wepayable_column = klass, column
+    def self.init_conf(settings)
       @@settings = settings
     end
 
-    def self.wepayable_class
-      @@wepayable_class
-    end
-
-    def self.wepayable_column
-      @@wepayable_column
-    end
-
     def self.settings
       @@settings
     end
@@ -31,8 +20,7 @@ module WepayRails
     initializer "WepayRails.initialize_wepay_rails" do |app|
       yml = Rails.root.join('config', 'wepay.yml').to_s
       settings = YAML.load_file(yml)[Rails.env].symbolize_keys
-      klass, column = settings[:auth_code_location].split('.')
-      Configuration.init_conf(eval(klass), column, settings)
+      Configuration.init_conf(settings)
     end
   end
 
@@ -49,72 +37,52 @@ module WepayRails
 
       base_uri @base_uri
 
-      attr_accessor :wepay_access_token, :wepay_auth_code, :scope
+      attr_accessor :access_token
 
       # Pass in the wepay access token that we got after the oauth handshake
       # and use it for ongoing comunique with Wepay.
       # This also relies heavily on there being a wepay.yml file in your
       # rails config directory - it must look like this:
-      #
-      #
       def initialize(*args)
-        @wepay_access_token = args.first
-
         @wepay_config = WepayRails::Configuration.settings
-
-        # Build the base uri
-        # Default if there isn't a setting for version and/or api uri
-        version = @wepay_config[:wepay_api_version].present? ? @wepay_config[:wepay_api_version] : "v2"
-        api_uri = @wepay_config[:wepay_api_uri].present? ? @wepay_config[:wepay_api_uri] : "https://wepayapi.com"
-
-        @base_uri = "#{api_uri}/#{version}"
+        @access_token = args.first || @wepay_config[:access_token]
+        @base_uri     = @wepay_config[:wepay_api_uri] || "https://www.wepay.com/v2"
       end
 
-      def access_token(wepayable_object)
-        w_column = WepayRails::Configuration.wepayable_column.to_s.to_sym
-        auth_code = if wepayable_object.is_a?(String)
-                      wepayable_object
-                    elsif wepayable_object.respond_to?(w_column)
-                      wepayable_object.send(w_column)
-                    end
-
-        unless auth_code.present?
-          raise WepayRails::Exceptions::AccessTokenError.new("The argument, #{wepayable_object.inspect}, passed into the
-          access_token method cannot be used to get an access token. It is neither a string,
-          nor an object containing the auth_code column you specified in wepay.yml.")
-        end
+      # Fetch the access token from wepay for the auth code
+      def get_access_token(auth_code, redirect_uri)
 
         params = {
-          :client_id => @wepay_config[:client_id],
+          :client_id     => @wepay_config[:client_id],
           :client_secret => @wepay_config[:client_secret],
-          :redirect_uri => (@wepay_config[:redirect_uri].present? ? @wepay_config[:redirect_uri] : "#{@wepay_config[:root_callback_uri]}/wepay/authorize"),
-          :code => auth_code
+          :redirect_uri  => redirect_uri,
+          :code          => auth_code
         }
 
-        response = self.call("/oauth2/token", {:body => params})
+        response = self.class.post("#{@base_uri}/oauth2/token", {:body => params})
+        json = JSON.parse(response.body)
 
-        if response.has_key?("error")
-          if response.has_key?("error_description")
-            if ['invalid code parameter','the code has expired'].include?(response['error_description'])
-              raise WepayRails::Exceptions::ExpiredTokenError.new("Token either expired or invalid: #{response["error_description"]}")
+        if json.has_key?("error")
+          if json.has_key?("error_description")
+            if ['invalid code parameter','the code has expired','this access_token has been revoked'].include?(json['error_description'])
+              raise WepayRails::Exceptions::ExpiredTokenError.new("Token either expired, revoked or invalid: #{json["error_description"]}")
             end
-            raise WepayRails::Exceptions::AccessTokenError.new(response["error_description"])
+            raise WepayRails::Exceptions::AccessTokenError.new(json["error_description"])
           end
         end
 
-        raise WepayRails::Exceptions::AccessTokenError.new("A problem occurred trying to get the access token: #{response.inspect}") unless response.has_key?("access_token")
+        raise WepayRails::Exceptions::AccessTokenError.new("A problem occurred trying to get the access token: #{json.inspect}") unless json.has_key?("access_token")
 
-        @wepay_auth_code    = auth_code
-        @wepay_access_token = response["access_token"]
+        @access_token = json["access_token"]
       end
 
       # Get the auth code url that will be used to fetch the auth code for the customer
       # arguments are the redirect_uri and an array of permissions that your application needs
       # ex. ['manage_accounts','collect_payments','view_balance','view_user']
-      def auth_code_url(params = {})
+      def auth_code_url(redirect_uri, params = {})
         params[:client_id]    ||= @wepay_config[:client_id]
-        params[:redirect_uri] ||= (@wepay_config[:redirect_uri].present? ? @wepay_config[:redirect_uri] : "#{@wepay_config[:root_callback_uri]}/wepay/authorize")
-        params[:scope]        ||= WepayRails::Configuration.settings[:scope].join(',')
+        params[:scope]        ||= @wepay_config[:scope].join(',')
+        params[:redirect_uri]   = redirect_uri
 
         query = params.map do |k, v|
           "#{k.to_s}=#{v}"
@@ -124,21 +92,14 @@ module WepayRails
       end
 
       def wepay_auth_header
-        unless @wepay_access_token
+        unless @access_token
           raise WepayRails::Exceptions::AccessTokenError.new("No access token available")
         end
-        {'Authorization' => "Bearer: #{@wepay_access_token}"}
-      end
-
-      # Make a call to wepay to get the user info. This will only make one call
-      # per request. Any subsequent calls to wepay_user will return the data
-      # retrieved from the first call.
-      def wepay_user
-        @wepay_user ||= self.call("/user")
+        {'Authorization' => "Bearer: #{@access_token}"}
       end
 
-      def call(api_path, params={})
-        response = self.class.post("#{@base_uri}#{api_path}", {:headers => wepay_auth_header}.merge!(params))
+      def call_api(api_path, params={})
+        response = self.class.post("#{@base_uri}#{api_path}", {:headers => wepay_auth_header}.merge!({:body => params}))
         JSON.parse(response.body)
       end
 

data/wepay-rails.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "wepay-rails"
-  s.version = "1.1.0"
+  s.version = "2.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adam Medeiros"]
-  s.date = "2011-11-26"
+  s.date = "2011-11-27"
   s.description = "Rails gem that interfaces with the WePay API"
   s.email = "adammede@gmail.com"
   s.extra_rdoc_files = [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wepay-rails
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-26 00:00:00.000000000Z
+date: 2011-11-27 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
-  requirement: &10731560 !ruby/object:Gem::Requirement
+  requirement: &9095360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *10731560
+  version_requirements: *9095360
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &10729980 !ruby/object:Gem::Requirement
+  requirement: &9093080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10729980
+  version_requirements: *9093080
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &10728420 !ruby/object:Gem::Requirement
+  requirement: &9091480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *10728420
+  version_requirements: *9091480
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &10726600 !ruby/object:Gem::Requirement
+  requirement: &9090080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *10726600
+  version_requirements: *9090080
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &10704300 !ruby/object:Gem::Requirement
+  requirement: &9088680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10704300
+  version_requirements: *9088680
 description: Rails gem that interfaces with the WePay API
 email: adammede@gmail.com
 executables: []
@@ -114,7 +114,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1601135752143681885
+      hash: -431317544786585156
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: