authorize_net_reporting 0.0.1 → 1.0.0

data/README.md

@@ -1,52 +1,153 @@
-# WORK IN PROGRESS!!!! 
-# AuhtorizeNetReporting
-
-AuthorizeNetReporting allows you to retrieve Authorize.net transaction details through the [Transaction Details API](http://developer.authorize.net/api/transaction_details/)
-
-# Sample Usage
-**Go to [Authorize.net](http://authorize.net) to obtain your key/login**
-
-````ruby
-require 'rubygems'
-
-require 'authorize_net_reporting'
-
-report = AuthorizeNetReporting::Report.new({ :mode => ['test'|'live'], :key => 'your_api_key', :login => 'your_api_login' })  
-````
-
-**All settled batched with a date range**
-
-
-````ruby
-#It will default to the last 12 hours if no date range is provided
-report.settled_batch_list({ :first_settlement_date => "2011/04/20", :last_settlement_date => "2011/05/20", :include_statistics => true })
-````
-
-**Statistics for a specific batch**
-
-````ruby
-report.batch_statistics(1049686)
-````
-
-**Data for all transactions in a specified batch**
-
-````ruby
-report.transaction_list(1049686)
-````
-
-**Unsettled Transactions**
-
-````ruby
-    report.unsettled_transaction_list
-````
-
-**Detailed information about one specific transaction**
-
-````ruby
-report.transaction_details(2157585857)
-````
-  
-# LICENSE:
+# Authorize.Net Transaction Details  API 
+
+In order to use the Transaction Details API you must have enabled Transaction Details API in the Merchant Interface account settings where you will find
+your developer and production credentials. 
+
+For more information about the API visit [Authorize.net Reporting API](http://developer.authorize.net/api/transaction_details/).
+
+Note: You will be able to view test transactions at [https://sandbox.authorize.net](https://sandbox.authorize.net/).
+ 
+# Installation
+    # Gemfile
+    
+    gem 'authorize_net_reporting'
+    
+
+# Documentation
+[Click here to view the Documentation](http://rubydoc.info/github/jazminschroeder/authorize_net_reporting/master/frames/)
+
+# Usage example
+
+Build a new AuthorizeNetReporting::Report object for test or production mode by passing your credentials as follows:
+
+    ~$ require 'rubygems'
+    ~$ require 'authorize_net_reporting'
+    ~$ report = AuthorizeNetReporting::Report.new({ :mode => 'test', :key => 'your_developer_api_key', :login => 'your_developer_api_login' })   
+    => #<AuthorizeNetReporting::Report:0x007fd94b2dd7b0 @mode="test", @key="XXXXXXX", @login="XXXXX"> 
+    
+    # In Production Mode
+    ~$ report = AuthorizeNetReporting::Report.new({ :mode => 'production', :key => 'your_production_api_key', :login => 'your_production_api_login' })  
+    => #<AuthorizeNetReporting::Report:0x007fd94b2dd7b0 @mode="production", @key="XXXXXXX", @login="XXXXX"> 
+
+**Retrieve Settled Batches within a date range**
+
+*Note: If no dates are specified, then the default is the last 24 hours.*
+   
+    ~$ batches = report.settled_batch_list({ :first_settlement_date => "2011/04/20", :last_settlement_date => "2011/05/20"})
+    
+    # Result
+    [
+        [0] #<AuthorizeNetReporting::Batch:0x007fc099a08488 @batch_id="1033266", @settlement_time_utc="2011-04-21T05:17:52Z", @settlement_time_local="2011-04-21T00:17:52", @settlement_state="settledSuccessfully", @payment_method="creditCard">,
+        [1] #<AuthorizeNetReporting::Batch:0x007fc099a07010 @batch_id="1039515", @settlement_time_utc="2011-04-26T05:17:34Z", @settlement_time_local="2011-04-26T00:17:34", @settlement_state="settledSuccessfully", @payment_method="creditCard">,
+        [2] #<AuthorizeNetReporting::Batch:0x007fc099a061d8 @batch_id="1049686", @settlement_time_utc="2011-05-03T05:13:09Z", @settlement_time_local="2011-05-03T00:13:09", @settlement_state="settledSuccessfully", @payment_method="creditCard">,
+        [3] #<AuthorizeNetReporting::Batch:0x007fc099a05210 @batch_id="1075905", @settlement_time_utc="2011-05-20T05:13:57Z", @settlement_time_local="2011-05-20T00:13:57", @settlement_state="settledSuccessfully", @payment_method="creditCard">
+    ]
+
+    
+**Include statistics for each batch**
+
+If you pass *:include_statistics => true* to the settled_batch_list resquest you will also receive batch statistics by payment type.
+    
+    ~$ batches = report.settled_batch_list({ :first_settlement_date => "2011/04/20", :last_settlement_date => "2011/05/20", :include_statistics => true})
+    
+    #Result
+    ~ $ batches.first 
+    => #<AuthorizeNetReporting::Batch:0x007fd94b271f38 
+        @batch_id="1033266", 
+        @settlement_time_utc="2011-04-21T05:17:52Z", 
+        @settlement_time_local="2011-04-21T00:17:52", 
+        @settlement_state="settledSuccessfully", 
+        @payment_method="creditCard", 
+        @statistics=[ { :account_type=>"Visa", 
+                        :charge_amount=>"14526.00", 
+                        :charge_count=>"1", 
+                        :refund_amount=>"0.00", 
+                        :refund_count=>"0", 
+                        :void_count=>"0", 
+                        :decline_count=>"0", 
+                        :error_count=>"0" } ]>
+    
+    
+
+**Retrieve information for a specified Batch ID**
+
+    ~$ batch = report.batch_statistics(1049686)
+    
+    => #<AuthorizeNetReporting::Batch:0x007fdb83966048 @batch_id="1049686", 
+          @settlement_time_utc="2011-05-03T05:13:09Z", 
+          @settlement_time_local="2011-05-03T00:13:09", 
+          @settlement_state="settledSuccessfully", 
+          @payment_method="creditCard", 
+          @statistics=[ { :account_type=>"AmericanExpress", 
+                          :charge_amount=>"1.00", 
+                          :charge_count=>"1", 
+                          :refund_amount=>"0.00", 
+                          :refund_count=>"0", 
+                          :void_count=>"0", 
+                          :decline_count=>"0", 
+                          :error_count=>"0" }, 
+                        { :account_type=>"Visa", 
+                          :charge_amount=>"899.52", 
+                          :charge_count=>"3", 
+                          :refund_amount=>"0.00", 
+                          :refund_count=>"0", 
+                          :void_count=>"0", 
+                          :decline_count=>"0", 
+                          :error_count=>"0" } ] >
+
+**Retrieve Transaction details for a specified Batch ID**
+
+    ~$ report.transaction_list(1049686)
+    
+    # Result
+    
+    [
+      [1] #<AuthorizeNetReporting::AuthorizeNetTransaction:0x007fc3c392f8e0 @trans_id="2159639081", @submit_time_utc="2011-05-02T18:11:50Z", @submit_time_local="2011-05-02T13:11:50", @transaction_status="settledSuccessfully", @first_name="Max", @last_name="Schroeder", @account_type="Visa", @account_number="XXXX8888", @settle_amount="299.84">,
+      [2] #<AuthorizeNetReporting::AuthorizeNetTransaction:0x007fc3c392bf10 @trans_id="2159639020", @submit_time_utc="2011-05-02T18:08:10Z", @submit_time_local="2011-05-02T13:08:10", @transaction_status="settledSuccessfully", @first_name="American", @last_name="Express", @account_type="AmericanExpress", @account_number="XXXX0002", @settle_amount="1.00">
+    ]
+
+**Retrieve Transaction Details for Unsettled Transactions**
+
+Retrieve up to 1000 of the most recent transactions
+
+    ~$ report.unsettled_transaction_list
+    
+    => [#<AuthorizeNetReporting::AuthorizeNetTransaction:0x007fc3c38b9960 @trans_id="2157217187", @submit_time_utc="2011-01-28T16:30:57Z", @submit_time_local="2011-01-28T10:30:57", @transaction_status="authorizedPendingCapture", @account_type="Visa", @account_number="XXXX0027", @settle_amount="25.45">] 
+
+
+**Retrieve Detailed information about one specific transaction**
+
+    ~$ report.transaction_details(2157585857)
+    
+    => #<AuthorizeNetReporting::AuthorizeNetTransaction:0x007fc3c2883668 
+        @trans_id="2157585857", 
+        @submit_time_utc="2011-02-16T21:51:10.953Z", 
+        @submit_time_local="2011-02-16T15:51:10.953", 
+        @transaction_status="settledSuccessfully", 
+        @settle_amount="50.23", 
+        @transaction_type="authCaptureTransaction", 
+        @response_code="1", 
+        @response_reason_code="1", 
+        @response_reason_description="Approval",
+        @auth_code="S1ZRPA", 
+        @avs_response="Y", 
+        @auth_amount="50.23", 
+        @tax_exempt="false", 
+        @recurring_billing="false"> 
+
+**Debug**
+
+To view the response from the API directly set debug to true
+    
+    ~$ report.debug = true
+    ~$ report.transaction_details(2157585857)
+    
+
+#Notes:
+
+Tested with Ruby 1.8.7 and 1.9.2
+
+# Copyright/License:
 
 (The MIT License)
 
@@ -54,21 +155,4 @@ Copyright (c) 2011:
 
 [Jazmin Schroeder](http://jazminschroeder.com)
 
-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, sub license, 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/authorize_net_reporting.gemspec

@@ -10,12 +10,12 @@ Gem::Specification.new do |s|
   s.email       = ["jazminschroeder@gmail.com"]
   s.homepage    = ""
   s.summary     = %q{Authorize.net Transaction Details API }
-  s.description = %q{Retrieve transaction details through the Authorize.net Transaction Details API }
+  s.description = %q{Ruby Library to interact with the Authorize.net Transaction Details API }
 
   s.rubyforge_project = "authorize_net_reporting"
-  s.add_dependency 'httparty'
-  s.add_dependency 'builder'
-  s.add_development_dependency "rspec"  
+  s.add_dependency 'httparty', '>= 0.6.1'
+  s.add_dependency 'builder', '>= 2.1.2'
+  s.add_development_dependency "rspec", '~> 2.0'  
   
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/authorize_net_reporting.rb

@@ -1,6 +1,5 @@
 # @author: Jazmin Schroeder
 # July/20011
-require 'authorize_net_reporting/common'
 require 'authorize_net_reporting/gateway'
 require 'authorize_net_reporting/report'
 require 'authorize_net_reporting/response'

data/lib/authorize_net_reporting/report.rb

@@ -1,10 +1,12 @@
 # AuthorizeNetReporting::Report
 module AuthorizeNetReporting
+  #Handeling Errors
+  class Error < StandardError; end
   # Initialize AuthorizeNetReporting::Report class
   #
   # report = AuthorizeNetReporting::Report.new({ :mode => ['test'|'live'], :key => 'your api key', :login => 'your api_login' })  
   class Report < Gateway
-    include Common
+    attr_accessor :debug
     # Set API login, password and mode(live/test)
     #
     # AuthorizeNetReporting::Report.new({ :mode => ['test'|'live'], :key => 'your api key', :login => 'your api_login' })    
@@ -62,8 +64,14 @@ module AuthorizeNetReporting
     # @param [Hash] options, options to be passed to API request, '{:batch_id => 12345}'  
     def process_request(api_function, options = {})
       xml = build_request(api_function, options)
-      response = send_xml(xml)
-      handle_response(api_function,response)
+      api_response = send_xml(xml)
+      puts api_response if @debug 
+      response = parse_response(api_response)
+      if success?(response["get_#{api_function.to_s}_response".to_sym])
+        AuthorizeNetReporting::Response.send("parse_#{api_function}", response)
+      else
+        raise AuthorizeNetReporting::Error, error_message(response["get_#{api_function.to_s}_response".to_sym])
+      end  
     end
   
     # Validates that required parameters are present
@@ -71,7 +79,7 @@ module AuthorizeNetReporting
     # @param [Symbol] params required :mode, :key
     def requires!(hash, *params)
       params.each do |param|
-        raise ArgumentError, "Missing Required Parameter #{param}" unless hash.has_key?(param) 
+        raise AuthorizeNetReporting::Error, "Missing Required Parameter #{param}" unless hash.has_key?(param) 
       end
     end
   
@@ -87,14 +95,14 @@ module AuthorizeNetReporting
           xml.tag!('name', @login)
           xml.tag!('transactionKey', @key)
         end
-        send("build_#{underscore(api_request)}", xml, options)
+        send("build_#{underscorize(api_request)}", xml, options)
       end  
     end
   
     def build_get_settled_batch_list_request(xml, options) #:nodoc:
       xml.tag!("includeStatistics", true) if options[:include_statistics]
       if options[:first_settlement_date] and options[:last_settlement_date]
-        xml.tag!("firstSettlementDate", Date.parse(options[:first_settlement_date]).strftime("%Y-%m-%dT00:00:00Z"))
+        xml.tag!("firstSettlementDate", Date.parse(options[:first_settlement_date]).strftime("%Y-%m-%dT00:00:00Z")) 
         xml.tag!("lastSettlementDate", Date.parse(options[:last_settlement_date]).strftime("%Y-%m-%dT00:00:00Z"))
       end  
       xml.target!
@@ -119,27 +127,41 @@ module AuthorizeNetReporting
       xml.target!
     end
   
-    # Call to Response.parse to handle response if transaction is successful, otherwise raise StandardError  
-    def handle_response(api_function, response) 
-      response_message = get_response_message(api_function, response)
-      if response_message =~ /successful/
-        eval("AuthorizeNetReporting::Response.parse_#{api_function}(#{response.parsed_response})")
-      elsif response_message =~ /found/
-        ["transaction_details", "batch_statistics"].include?(api_function.to_s) ? nil : []
+    # Extract response message from response for specified api_function
+    def success?(api_response_message)
+      !api_response_message.nil? and (!api_response_message[:messages][:result_code].match(/ok/i).nil? or api_response_message[:messages][:message][:text].match(/cannot be found/i))
+    end
+    
+    # @returns error message from API if request is not successful
+    def error_message(api_response_message)
+      api_response_message[:messages][:message][:text] rescue "Unable to process request. Try with debug = true"
+    end
+    
+    # Parse response, convert keys to underscore symbols
+    def parse_response(response)
+      response = sanitize_response_keys(response.parsed_response)
+    end
+
+    # Recursively sanitizes the response object by clenaing up any hash keys.
+    def sanitize_response_keys(response)
+      if response.is_a?(Hash)
+        response.inject({}) { |result, (key, value)| result[underscorize(key).to_sym] = sanitize_response_keys(value); result } 
+      elsif response.is_a?(Array)
+        response.collect { |result| sanitize_response_keys(result) }
       else
-        raise StandardError, response_message
+        response
       end
     end
-  
-    # Extract response message from response for specified api_function
-    def get_response_message(api_function, response)
-      api_response = "get#{camelize(api_function.to_s)}Response"
-      if response.parsed_response[api_response] 
-        message = response.parsed_response[api_response]["messages"]["message"]["text"]
-      else
-        message = response.parsed_response["ErrorResponse"]["messages"]["message"]["text"] rescue "Unable to execute transaction"
-      end    
-      message.downcase
+    
+    #helper method
+    def underscorize(key) #:nodoc:
+      key.to_s.sub(/^(v[0-9]+|ns):/, "").gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+    end
+    
+    #helper method
+    def camelize(str)
+      str.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
     end
+    
   end
 end

data/lib/authorize_net_reporting/response.rb

@@ -2,99 +2,92 @@ module AuthorizeNetReporting
   # AuthorizeNetReporting::Response parses the response from Authorize.net API and turns results into objects setting attributes for easy integration
   
   class Response 
-    extend Common
     # Parse response for settled_batch_list 
     def self.parse_settled_batch_list(response)
-      batch_list = response["getSettledBatchListResponse"]["batchList"]["batch"]
       batches = []
-      batch_list.each do |batch|
-        statistics = extract_batch_statistics(batch)
-        params = to_single_hash(batch)
-        params.merge!("statistics" => statistics) unless statistics.blank?
-        batches << create_class("Batch", params)
+      unless response[:get_settled_batch_list_response][:batch_list].nil?
+        batch_list = [response[:get_settled_batch_list_response][:batch_list][:batch]].flatten
+        batch_list.each do |batch|
+          batch.merge!(:statistics => [batch[:statistics][:statistic]].flatten) unless batch[:statistics].nil?
+          batches << create_class("Batch", batch)
+        end
       end
       batches
     end
     
     # Parse response for batch_statistics
     def self.parse_batch_statistics(response)
-      batch = response["getBatchStatisticsResponse"]["batch"]
-      statistics = extract_batch_statistics(batch)
-      params = to_single_hash(batch)
-      params.merge!("statistics" => statistics) unless statistics.blank?
-      create_class("Batch", params)
+      return nil if response[:get_batch_statistics_response][:batch].nil?
+      batch = response[:get_batch_statistics_response][:batch]
+      batch.merge!(:statistics => [batch[:statistics][:statistic]].flatten) unless batch[:statistics].nil?
+      create_class("Batch", batch)
     end
      
     # Parse response for transaction_list 
     def self.parse_transaction_list(response)
-      transactions = [response["getTransactionListResponse"]["transactions"]["transaction"]].flatten
-      transaction_list = []
-      transactions.each do |transaction|
-        transaction_list << create_class("AuthorizeNetTransaction", to_single_hash(transaction))
+      transactions = []
+      unless response[:get_transaction_list_response][:transactions].nil?
+        transaction_list = [response[:get_transaction_list_response][:transactions][:transaction]].flatten
+        transaction_list.each do |transaction|
+          transactions << create_class("AuthorizeNetTransaction", transaction)
+        end  
       end
-      transaction_list
+     transactions
     end
 
      
     # Parse response unsettled_transaction 
     def self.parse_unsettled_transaction_list(response)
-      unsettled_transactions = [response["getUnsettledTransactionListResponse"]["transactions"]["transaction"]]
       transactions = []
-      unsettled_transactions.each do |transaction|
-        transactions << create_class("AuthorizeNetTransaction", to_single_hash(transaction))
-      end
-      transactions
+      unless response[:get_unsettled_transaction_list_response][:transactions].nil?
+        unsettled_transactions = [response[:get_unsettled_transaction_list_response][:transactions][:transaction]].flatten
+        unsettled_transactions.each do |transaction|
+          transactions << create_class("AuthorizeNetTransaction", transaction)
+        end
+      end  
+     transactions
     end
     
     
     # Parse response transaction_details 
     def self.parse_transaction_details(response)
-      params = response["getTransactionDetailsResponse"]["transaction"]
-      create_class("AuthorizeNetTransaction", to_single_hash(params))
+      return nil if response[:get_transaction_details_response][:transaction].nil?
+      transaction =  response[:get_transaction_details_response][:transaction] 
+      create_class("AuthorizeNetTransaction", transaction)
     end
     
-    # Handle batch statistics
-    def self.extract_batch_statistics(batch)
-      statistics = []
-      if batch["statistics"]
-        batch_statistics = [batch["statistics"]["statistic"]].flatten
-        batch_statistics.each do |statistic|   
-          statistic = statistic.inject({}) {|h, (key,value)| h[underscore(key)] = value; h}
-          statistics << statistic 
-        end
-      end
-        statistics
-    end
-             
     # Convert response nested hash into a single hash
     # param[Hash] hash
-    def self.to_single_hash(hash)
+    def self.to_single_hash(hash, first_iteration = true)
+      temp_hash = {}  if first_iteration == true
       hash.each do |key, value|
         case value       
           when Hash then to_single_hash(value)
-          when String, Integer then   (@temp_hash||={})[underscore(key)] = value          
+          when String, Integer, Array then temp_hash[key] = value          
         end  
       end
-      @temp_hash
+      temp_hash
     end
     
-    #Create objects dinamicaly 
+    #Create objects dinamically 
     def self.create_class(class_name, params)
-        if AuthorizeNetReporting.const_defined?(class_name)
-          klass = AuthorizeNetReporting.const_get(class_name)
-        else  
-          klass = AuthorizeNetReporting.const_set(class_name, Class.new) 
-          klass.class_eval do
-            define_method(:initialize) do |params|
-              params.each do |key, value| 
-                self.class.__send__(:attr_accessor, key)
-                instance_variable_set("@#{key}", value) 
-              end  
+      params = to_single_hash(params)
+      if AuthorizeNetReporting.const_defined?(class_name)
+        klass = AuthorizeNetReporting.const_get(class_name)
+      else  
+        klass = AuthorizeNetReporting.const_set(class_name, Class.new) 
+        klass.class_eval do
+          define_method(:initialize) do |params|
+            params.each do |key, value| 
+              self.class.__send__(:attr_accessor, key)
+              instance_variable_set("@#{key}", value) 
             end  
-          end
-        end   
-        klass.new(params)
+          end  
+        end
+      end   
+      klass.new(params)
     end
+    
   end  
 end  
 

data/lib/authorize_net_reporting/version.rb

@@ -1,3 +1,3 @@
 module AuthorizeNetReporting
-  VERSION = "0.0.1" #:nodoc:
+  VERSION = "1.0.0" #:nodoc:
 end

data/spec/authorize_net_reporting_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
 describe AuthorizeNetReporting::Report do
   let(:test_mode) do
-     #TEST API LOGIN: 3vk59E5BgM - API KEY:4c8FeAW7ebq5U733
-    { :mode => "test", :login=>"3vk59E5BgM", :key => "4c8FeAW7ebq5U733" }
+    { :mode => "test", :login=>"xxxx", :key => "xxxx" }
   end
   
   let(:live_mode) do
-    { :mode => "live", :key=>"key", :login => "login" }
+    { :mode => "live", :key=>"xxxxx", :login => "xxxxx" }
   end  
   context "missing requirements" do
     it "should raise exception" do
-      lambda { AuthorizeNetReporting::Report.new }.should raise_error(ArgumentError)
+      lambda { AuthorizeNetReporting::Report.new }.should raise_error(AuthorizeNetReporting::Error)
     end
   end
   describe "API URL in live mode" do
@@ -33,7 +32,7 @@ describe AuthorizeNetReporting::Report do
   describe "settled_batch_list" do
     context "when there are not batches settled" do
       it "should return an empty array" do
-        @authorize_net_reporting.settled_batch_list.should be_empty
+        @authorize_net_reporting.settled_batch_list({:first_settlement_date => "2011/11/16", :last_settlement_date => "2011/11/16"}).should be_empty
       end
     end
     context "when there are settled batches" do
@@ -54,29 +53,36 @@ describe AuthorizeNetReporting::Report do
     it "should return an array statistics for given batch" do
       @authorize_net_reporting.batch_statistics(1049686).statistics.should be_an_instance_of(Array)
     end
+    it "should return nil if batch is not found" do 
+      @authorize_net_reporting.batch_statistics(11111).should eql(nil)
+    end  
   end
-  
+    
   describe "transactions_list" do
+    it "should return empty array if no transactions are found" do 
+      transactions = @authorize_net_reporting.transaction_list(10000)
+      transactions.should be_empty
+    end  
     it "should return all transactions in a specified batch" do
       transactions = @authorize_net_reporting.transaction_list(1049686)
       transactions.size.should eql(4)
     end
   end  
-
+  
   describe "unsettled_transaction_list" do
     it "should return unsettled transactions" do
       transactions = @authorize_net_reporting.unsettled_transaction_list
       transactions.should be_an_instance_of(Array)
     end  
   end  
-  
+
   describe "transaction_details" do
     it "should return transaction if transaction_exists" do
       transaction = @authorize_net_reporting.transaction_details(2157585857)
       transaction.should be_an_instance_of(AuthorizeNetReporting::AuthorizeNetTransaction)
     end
     it "should return nil if transaction doesn't exist" do
-      @authorize_net_reporting.transaction_details(0).should be_nil
+       @authorize_net_reporting.transaction_details(0).should be_nil
     end
   end
 end

metadata

@@ -1,61 +1,57 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: authorize_net_reporting
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 1.0.0
   prerelease: 
-  version: 0.0.1
 platform: ruby
-authors: 
+authors:
 - Jazmin Schroeder
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-07-04 00:00:00 -05:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-21 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: httparty
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70143284072100 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.1
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: builder
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70143284072100
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: &70143284071600 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.2
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70143284071600
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70143284071140 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :development
-  version_requirements: *id003
-description: "Retrieve transaction details through the Authorize.net Transaction Details API "
-email: 
+  prerelease: false
+  version_requirements: *70143284071140
+description: ! 'Ruby Library to interact with the Authorize.net Transaction Details
+  API '
+email:
 - jazminschroeder@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .rspec
 - Gemfile
@@ -63,40 +59,36 @@ files:
 - Rakefile
 - authorize_net_reporting.gemspec
 - lib/authorize_net_reporting.rb
-- lib/authorize_net_reporting/common.rb
 - lib/authorize_net_reporting/gateway.rb
 - lib/authorize_net_reporting/report.rb
 - lib/authorize_net_reporting/response.rb
 - lib/authorize_net_reporting/version.rb
 - spec/authorize_net_reporting_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
-homepage: ""
+homepage: ''
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: authorize_net_reporting
-rubygems_version: 1.5.0
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Authorize.net Transaction Details API
-test_files: []
-
+test_files:
+- spec/authorize_net_reporting_spec.rb
+- spec/spec_helper.rb

data/lib/authorize_net_reporting/common.rb

@@ -1,12 +0,0 @@
-# Helper methods   
-module Common
-  # Converts string to underscore
-  def underscore(str)
-    str.gsub(/(.)([A-Z])/,'\1_\2').downcase
-  end
-  # Converts string to camelCase format
-  def camelize(str)
-    str.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-  end
-end
-