cheddargetter_client 0.0.0

data/Gemfile

@@ -0,0 +1,9 @@
+source 'http://rubygems.org'
+gem 'httparty'
+gem "crack"
+
+group :development do
+  gem 'rspec'
+  gem "bundler"
+  gem "jeweler"
+end

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    crack (0.3.2)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    httparty (0.10.0)
+      multi_json (~> 1.0)
+      multi_xml
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.6)
+    multi_json (1.5.0)
+    multi_xml (0.5.2)
+    rake (10.0.3)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  crack
+  httparty
+  jeweler
+  rspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Brent Wooden
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+This project borrows highly from cheddargetter_client_ruby.
+I completely reuse their response object.
+
+I felt however their implementation of calls to the Cheddargetter api were too static,
+so I implemented a wrapper using method missing.  This way if methods
+are added to the api, they can be easily accessed.  Here are some mappings. 
+There should be a noticable pattern.
+
+
+-    #/customers/get                 
+--   cg_client_object.customers_get({:customer_code => 'ABCD'}) (code optional)
+-    #/customers/new                 
+--   cg_client_object.customers_new({
+    :customer_code => CustomerCode, 
+    :firstName => 'W Pain', 
+    :lastName => 'Alemeda', 
+    :email => 'w_pain@example.com',  
+    :subscription => {:planCode => PlanCodes.last}
+  })
+
+-    #/customers/edit
+-- cg_client.customers_edit({:customer_code => 'ABCD'}, *valid_customer_attributes_hash*)    
+-    #/customers/edit-customer       
+-- cg_client.customers_edit_customer({:customer_code => 'ABCD'}, *valid_customer_attributes_hash*) 
+-    #/customers/edit-subscription      
+-- cg_client.customers_edit_subscription({:customer_code => 'ABCD'}, {:subscription => *ValidSubscription*}) 
+-    #/customers/delete         
+-- cg_client.customers_delete({:customer_code => 'ABCD'})    
+-    #/customers/cancel               
+-- cg_client.customers_cancel({:customer_code => 'ABCD'})    
+-    #/customers/add-item-quantity  
+-- cg_client.customers_add_item_quantity({:customer_code => CustomerCode, :itemCode => item_code} 
+-    #/customers/remove-item-quantity  
+-- cg_client.customers_remove_item_quantity({:customer_code => CustomerCode, :itemCode => item_code}, {:quantity => 5})
+-    #/customers/set-item-quantity   
+  cg_client.customers_set_item_quantity({:customer_code => CustomerCode, :itemCode => item_code}, {:quantity => 13}
+
+See the specs more examples. These are copied from them.

data/Rakefile

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "cheddargetter_client"
+  gem.homepage = "http://github.com/BrentW/cheddargetter_client"
+  gem.license = "MIT"
+  gem.summary = %Q{A ruby wrapper for the Cheddargetter API}
+  gem.description = %Q{A more flexible solution for accessing the Cheddargetter API}
+  gem.email = "brent.wooden@gmail.com"
+  gem.authors = ["Brent Wooden"]
+  # dependencies defined in Gemfile
+
+  gem.add_dependency "httparty", ">= 0.10.0"
+  gem.add_dependency "crack", ">= 0.3.2"
+end
+Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/cheddargetter_client.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "cheddargetter_client"
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brent Wooden"]
+  s.date = "2013-01-25"
+  s.description = "A more flexible solution for accessing the Cheddargetter API"
+  s.email = "brent.wooden@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "cheddargetter_client.gemspec",
+    "lib/cheddargetter/client.rb",
+    "lib/cheddargetter/response.rb",
+    "lib/cheddargetter_client.rb",
+    "pkg/cheddargetter_client-0.0.0.gem",
+    "spec/cheddar_getter_client_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/BrentW/cheddargetter_client"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "A ruby wrapper for the Cheddargetter API"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<httparty>, [">= 0"])
+      s.add_runtime_dependency(%q<crack>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_runtime_dependency(%q<httparty>, [">= 0.10.0"])
+      s.add_runtime_dependency(%q<crack>, [">= 0.3.2"])
+    else
+      s.add_dependency(%q<httparty>, [">= 0"])
+      s.add_dependency(%q<crack>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<httparty>, [">= 0.10.0"])
+      s.add_dependency(%q<crack>, [">= 0.3.2"])
+    end
+  else
+    s.add_dependency(%q<httparty>, [">= 0"])
+    s.add_dependency(%q<crack>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<httparty>, [">= 0.10.0"])
+    s.add_dependency(%q<crack>, [">= 0.3.2"])
+  end
+end
+

data/lib/cheddargetter/client.rb

@@ -0,0 +1,105 @@
+module Cheddargetter
+  class Client
+    include HTTParty
+    base_uri 'https://cheddargetter.com/xml'
+
+    attr_accessor :username, :password, :product_code, :options_mode
+    
+    OptionModes = [:customer, :data, :customer_and_data, :no_options]
+    
+    def initialize(options = {})
+      self.username      = options[:username] || options["username"]
+      self.password      = options[:password] || options["password"]
+      self.product_code  = options[:product_code] || options["product_code"]
+
+      raise(ArgumentError, "No username specified")     unless username
+      raise(ArgumentError, "No password specified")     unless password
+      raise(ArgumentError, "No product_code specified") unless product_code
+    end
+
+    def method_missing(method, *args, &block)
+      parts = method.to_s.split('_')
+      response = post('/' + [parts.slice!(0, 2).join('/'), parts].flatten.join('-'), args)
+
+      if response.parsed_response["error"] && response.parsed_response["error"]["__content__"] && response.parsed_response["error"]["__content__"] == 'Resource not found'
+        raise NoMethodError.new(method.to_s)
+      else
+        ::Cheddargetter::Response.new(response)
+      end
+    end
+
+    def post(url, options)
+      set_options_mode(options)
+
+      response = self.class.post(
+        full_url(url, options), 
+        :body => filter_customer_code_key(options), 
+        :basic_auth => {:username => username, :password => password}
+      )
+    end  
+
+    def customers_delete_all
+      #whacky url
+      response = self.class.post(
+        "https://cheddargetter.com/xml/customers/delete-all/confirm/#{Time.now.to_i}/productCode/#{product_code}", 
+        :basic_auth => {:username => username, :password => password}
+      )
+      ::Cheddargetter::Response.new(response)
+    end
+    
+    private
+    
+    def full_url(url, options = [])
+      return_url = url_with_product(url)
+
+      (options.first || {}).each do |name, value|
+        return_url += param_from_attribute_name(name, value) || ''
+      end unless options_mode == :data
+      return_url
+    end
+    
+    def set_options_mode(options)    
+      if !options || options.length == 0
+        self.options_mode = :no_options
+      elsif options.is_a?(Array) && options.size == 2
+        self.options_mode = :customer_and_data
+      elsif options.first.size == 1
+        self.options_mode = :customer
+      else
+        self.options_mode = :data
+      end
+    end
+    
+    def filter_customer_code_key(array)
+      return {} if !array || array.length == 0
+      hash = (array && array.is_a?(Array) && array.last) || array 
+      hash[:code] = hash.delete(:customer_code) if hash[:customer_code]
+      hash
+    end
+    
+    def url_with_product(url)
+      url + product_param 
+    end
+    
+    def product_param
+      "/productCode/#{product_code}"
+    end
+    
+    def param_from_attribute_name(name, value)
+      name = 'code' if name.to_sym == :customer_code
+      name_parts = name.to_s.split('_')
+      if name_parts.length > 1   
+        name = name.to_s.split('_').map(&:capitalize).join.tap{|str| str.match(/(^\w)/)}.gsub((/^\w/), $1.downcase)
+      end
+      "/#{name}/#{value}" if value
+    end
+    
+    def customer_param(customer_code)
+      "/code/#{customer_code}" if customer_code 
+    end
+      
+    def item_param(item_code)
+      "/itemCode/#{item_code}" if item_code
+    end
+  end
+end

data/lib/cheddargetter/response.rb

@@ -0,0 +1,416 @@
+module Cheddargetter
+  class Response
+        SPECIAL_ARRAY_KEYS = {
+      :plans => :plan, 
+      :items => :item,
+      :subscriptions => :subscription,
+      :customers => :customer,
+      :invoices => :invoice,
+      :charges => :charge,
+      :transactions => :transaction,
+      :errors => :error
+    }
+    
+    #not charges, because codes aren't unique
+    #not invoices, transactions, subscriptions, or errors because they don't have codes
+    ARRAY_TO_HASH_BY_CODE = 
+      [:plans, :items, :customers]
+    
+    KEY_TO_DATA_TYPE = { 
+      :isActive => :boolean,
+      :isFree => :boolean,
+      :trialDays => :integer,
+      :setupChargeAmount => :float,
+      :recurringChargeAmount => :float,
+      :billingFrequencyQuantity => :integer,
+      :createdDatetime => :datetime,
+      :quantityIncluded => :float,
+      :isPeriodic => :boolean,
+      :overageAmount => :float,
+      :isVatExempt => :boolean,
+      :firstContactDatetime => :datetime,
+      :modifiedDatetime => :datetime,
+      :canceledDatetime => :datetime,
+      :ccExpirationDate => :date,
+      :quantity => :float,
+      :billingDatetime => :datetime,
+      :eachAmount => :float,
+      :number => :integer,
+      :amount => :float,
+      :transactedDatetime => :datetime,
+      :vatRate => :float
+    }
+    
+    attr_accessor :raw_response, :clean_response
+    
+    def initialize(response)    #:nodoc:
+      self.raw_response = response
+      create_clean_response
+    end
+    
+    [:errors, :plans, :customers].each do |key|
+      define_method key.to_s do
+        self[key]
+      end
+    end
+    
+    #true if the response from CheddarGetter was valid
+    def valid?
+      self.errors.size == 0 && self.raw_response.code < 400
+    end
+    
+    #the error messages (if there were any) if the CheddarGetter response was invalid
+    def error_messages
+      self.errors.map do |e|
+        msg = nil
+        if e
+          msg = e[:text]
+          msg += ": #{e[:fieldName]}" unless e[:fieldName].blank?
+        end
+        msg
+      end
+    end
+    
+    #Returns the given plan.
+    #
+    #code must be provided if this response contains more than one plan.
+    def plan(code = nil)
+      retrieve_item(self, :plans, code)
+    end
+    
+    #Returns the items for the given plan.
+    #
+    #code must be provided if this response contains more than one plan.
+    def plan_items(code = nil)
+      (plan(code) || { })[:items]
+    end
+    
+    #Returns the given item for the given plan.
+    #
+    #item_code must be provided if the plan has more than one item.
+    #
+    #code must be provided if this response contains more than one plan.
+    def plan_item(item_code = nil, code = nil)
+      retrieve_item(plan(code), :items, item_code)
+    end
+    
+    #Returns the given customer.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer(code = nil)
+      retrieve_item(self, :customers, code)
+    end
+    
+    #Returns the current subscription for the given customer.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_subscription(code = nil)
+      #current subscription is always the first one
+      (customer_subscriptions(code) || []).first
+    end
+    
+    def customer_paypal_preapproval_url(code = nil)
+      customer_subscription[:redirectUrl] || ""
+    end
+    
+    #Returns all the subscriptions for the given customer.  
+    #Only the first one is active, the rest is historical.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_subscriptions(code = nil)
+      (customer(code) || { })[:subscriptions]
+    end
+    
+    #Returns the current plan for the given customer
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_plan(code = nil)
+      (customer_subscription(code) || { })[:plan]
+    end
+    
+    #Returns the current open invoice for the given customer.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_invoice(code = nil)
+      #current invoice is always the first one
+      ((customer_subscription(code) || { })[:invoices] || []).first
+    end
+    
+    #Returns all of the invoices for the given customer.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_invoices(code = nil)
+      (customer_subscriptions(code) || []).map{ |s| s[:invoices] || [] }.flatten
+    end
+    
+    #Returns the last billed invoice for the given customer.
+    #This is not the same as the currect active invoice.
+    #
+    #nil if there is no last billed invoice.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_last_billed_invoice(code = nil)
+      #last billed invoice is always the second one
+      (customer_invoices(code) || [])[1]
+    end
+    
+    #Returns all of the transactions for the given customer.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_transactions(code = nil)
+      customer_invoices(code).map{ |s| s[:transactions] || [] }.flatten
+    end
+    
+    def customer_one_time_invoices(code = nil)
+      customer_invoices(code).select{ |s| s[:type] == 'one-time' }
+    end
+    #Returns the last transaction for the given customer.
+    #
+    #nil if there are no transactions.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_last_transaction(code = nil)
+      invoice = customer_last_billed_invoice(code) || { }
+      (invoice[:transactions] || []).first
+    end
+    
+    #Returns an array of any currently outstanding invoices for the given customer.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_outstanding_invoices(code = nil)
+      now = Time.now
+      customer_invoices(code).reject do |i| 
+        i[:paidTransactionId] || i[:billingDatetime] > now
+      end
+    end
+    
+    #Info about the given item for the given customer.  
+    #Merges the plan item info with the subscription item info.
+    #
+    #item_code must be provided if the customer is on a plan with more than one item.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_item(item_code = nil, code = nil)
+      sub_item  = retrieve_item(customer_subscription(code), :items, item_code)
+      plan_item = retrieve_item(customer_plan(code),         :items, item_code)
+      return nil unless sub_item && plan_item
+      item = plan_item.dup
+      item[:quantity] = sub_item[:quantity]
+      item
+    end
+    
+    #The amount remaining for a given item for a given customer.
+    #
+    #item_code must be provided if the customer is on a plan with more than one item.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_item_quantity_remaining(item_code = nil, code = nil)
+      item = customer_item(item_code, code)
+      item ? item[:quantityIncluded] - item[:quantity] : 0
+    end
+    
+    #The overage amount for the given item for the given customer.  0 if they are still under their limit.
+    #
+    #item_code must be provided if the customer is on a plan with more than one item.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_item_quantity_overage(item_code = nil, code = nil)
+      over = -customer_item_quantity_remaining(item_code, code)
+      over = 0 if over <= 0
+      over
+    end
+    
+    #The current overage cost for the given item for the given customer.
+    #
+    #item_code must be provided if the customer is on a plan with more than one item.
+    #
+    #code must be provided if this response contains more than one customer.
+    def customer_item_quantity_overage_cost(item_code = nil, code = nil)
+      item = customer_item(item_code, code)
+      return 0 unless item
+      overage = customer_item_quantity_overage(item_code, code)
+      item[:overageAmount] * overage
+    end
+    
+    #true if the customer is canceled
+    #
+    #code must be provided if this reponse contains more than one customer
+    def customer_canceled?(code = nil)
+      sub = customer_subscription(code)
+      sub ? !!sub[:canceledDatetime] : nil
+    end
+    
+    # Get an array representation of a single customer's current subscription
+    # @throws CheddarGetter_Response_Exception if the response type is incompatible or if a $code 
+    # is not provided and the response contains more than one customer
+    # @return array
+    def customer_active?(code = nil)
+      subscription = customer_subscription(code)
+      if subscription[:canceledDatetime] && subscription[:canceledDatetime] <= Time.now
+        false
+      else
+        true
+      end
+    end
+    
+    # Is this customer's account pending paypal preapproval confirmation?
+    def customer_waiting_for_paypal?(code = nil)
+      subscription = customer_subscription(code)
+      if subscription[:canceledDatetime] && subscription[:canceledDatetime] <= Time.now && subscription[:cancelType] == 'paypal-wait'
+        true
+      else
+        false
+      end      
+    end
+    
+    #access the root keys of the response directly, such as 
+    #:customers, :plans, or :errors
+    def [](value)
+      self.clean_response[value]
+    end
+    
+    private
+    def deep_fix_array_keys!(data)
+      if data.is_a?(Array)
+        data.each do |v|
+          deep_fix_array_keys!(v)
+        end
+      elsif data.is_a?(Hash)
+        data.each do |k, v|
+          deep_fix_array_keys!(v)
+          sub_key = SPECIAL_ARRAY_KEYS[k]
+          if sub_key && v.is_a?(Hash) && v.keys.size == 1 && v[sub_key]
+            data[k] = v = [v[sub_key]].flatten
+          end
+        end
+      end
+    end
+    
+    def deep_symbolize_keys!(data)
+      if data.is_a?(Array)
+        data.each do |v|
+          deep_symbolize_keys!(v) 
+        end
+      elsif data.is_a?(Hash)
+        data.keys.each do |key|
+          deep_symbolize_keys!(data[key]) 
+          data[(key.to_sym rescue key) || key] = data.delete(key)
+        end
+      end
+    end
+    
+    def deep_fix_data_types!(data)
+      if data.is_a?(Array)
+        data.each do |v|
+          deep_fix_data_types!(v) 
+        end
+      elsif data.is_a?(Hash)
+        data.each do |k, v|
+          deep_fix_data_types!(v)
+          type = KEY_TO_DATA_TYPE[k]
+          if type && v.is_a?(String)
+            data[k] = case type
+                        when :integer then v.to_i
+                        when :float then v.to_f
+                        when :datetime then Time.parse(v) rescue v
+                        when :date then Date.parse(v) rescue v
+                        when :boolean then v.to_i != 0
+                        else v
+                        end
+          end
+        end
+      end
+    end
+    
+    def make_plan_in_subscription_singular!(data)
+      return unless data[:customers]
+      data[:customers].each do |c|
+        c[:subscriptions].each do |s|
+          if s[:plans].size != 1
+            raise ArgumentError, "Should be exactly one plan in a subscription!"
+          end
+          s[:plan] = s[:plans].first
+          s.delete(:plans)
+        end
+      end
+    end
+    
+    def switch_arrays_to_hashes!(data)
+      if data.is_a?(Array)
+        data.each do |v|
+          switch_arrays_to_hashes!(v) 
+        end
+      elsif data.is_a?(Hash)
+        data.each do |k, v|
+          switch_arrays_to_hashes!(v)
+          if ARRAY_TO_HASH_BY_CODE.include?(k) && v.is_a?(Array)
+            new_hash = { }
+            v.each do |item|
+              new_hash[item[:code]] = item
+            end
+            data[k] = new_hash
+          end
+        end
+      end
+    end
+    
+    def reduce_clean_errors!(data)
+      root_plural    = [(data.delete(:errors) || { })[:error]].flatten
+      root_singular  = [data.delete(:error)]
+      embed_singluar = []
+      embed_plural   = []
+      
+      embed = data[:customers] || data[:plans]
+      if embed
+        embed_singluar = [(embed.delete(:errors) || { })[:error]].flatten
+        embed_plural   = [embed.delete(:error)]
+      end
+      
+      new_errors = (root_plural + root_singular + embed_plural + embed_singluar).compact
+
+      new_errors.each do |e|
+        aux_code = (e[:auxCode] || "")
+        if aux_code[":"]
+          split_aux_code = aux_code.split(':')
+          e[:fieldName] = split_aux_code.first
+          e[:errorType] = split_aux_code.last
+        end          
+      end
+      
+      data[:errors] = new_errors
+    end
+    
+    def create_clean_response
+      data = { }
+      
+      #if it isn't a hash, then we didn't get anything useful back.
+      if self.raw_response.parsed_response.is_a?(Hash)
+        #because Crack can:t get attributes and text at the same time.  
+        #so we fix the error blocks and re-parse
+        data = ::Crack::XML.parse(self.raw_response.body.gsub(/<error(.*)>(.*)<\/error>/, 
+                                                            '<error\1><text>\2</text></error>'))
+      end
+      
+      deep_symbolize_keys!(data)
+      reduce_clean_errors!(data)
+      deep_fix_array_keys!(data)
+      deep_fix_data_types!(data)
+      make_plan_in_subscription_singular!(data)
+      switch_arrays_to_hashes!(data)
+      self.clean_response = data
+    end
+    
+    def retrieve_item(root, type, code = nil)
+      hash = root[type]
+      if !hash
+        raise ArgumentError, "Can:t get #{type} from a response that doesn't contain #{type}"
+      elsif code
+        hash[code.to_s]
+      elsif hash.size <= 1
+        hash.first.last
+      else
+        raise ArgumentError, "This response contains multiple #{type} so you need to provide the code for the one you wish to get"
+      end
+    end
+  end
+end

data/lib/cheddargetter_client.rb

@@ -0,0 +1,7 @@
+require 'httparty'
+require 'cgi' unless Object.const_defined?("CGI")
+
+module Cheddargetter
+  autoload :Client, File.expand_path("lib/cheddargetter/client.rb")
+  autoload :Response, File.expand_path("lib/cheddargetter/response.rb")
+end

data/spec/cheddar_getter_client_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+describe Cheddargetter::Client do
+  before do 
+    class Cheddargetter::Response
+      def self.new(response)
+        response
+      end
+    end 
+  end
+
+  Username    = 'brent.wooden@gmail.com'
+  Password    = 'j3rkface'
+  ProductCode = 'BEETLEBOTS'
+  UserCodes   = ["T_ROC", "BDOG_RUEZ"]
+  PlanCodes    = ["BEETLEBOTS", "SPIDERBOTS"]
+  ValidSubscription = {
+    :planCode     => PlanCodes.first, 
+    :ccFirstName  => 'W Pain', 
+    :ccLastName   => "Almeda", 
+    :ccNumber     => '4111111111111111',
+    :ccExpiration => "04/#{(Date.today.year + 2).to_s}"
+  }
+  
+  CustomerCode  = "W_PAIN"
+  ValidCustomer = {
+    :customer_code => CustomerCode, 
+    :firstName => 'W Pain', 
+    :lastName => 'Alemeda', 
+    :email => 'w_pain@example.com',  
+    :subscription => {:planCode => PlanCodes.last}
+  }
+
+  let(:item_code) { "BATTERY" }
+  ChargeCode  = 'LATE_FEE'
+  
+  def create_customer_with_code(code)
+    valid_customer = {
+      :customer_code => code, 
+      :firstName => code.split('_').first.downcase.capitalize, 
+      :lastName => code.split('_').last.downcase.capitalize, 
+      :email => "#{code.downcase}@example.com",
+      :subscription => {:planCode => PlanCodes.last}
+    }
+    
+    cg_client.customers_new(valid_customer)
+  end
+  
+  
+  describe 'new' do
+    subject { Cheddargetter::Client.new(options) }
+    context 'with no username option' do
+      let(:options) {{ :password => Password, :product_code => ProductCode }}
+      it 'should raise correct arguement error' do
+        begin 
+          subject 
+        rescue Exception => e
+          e.to_s.include?("username").should be_true 
+        end
+      end
+    end
+
+    context 'with no password option' do
+      let(:options) {{ :username => Username, :product_code => ProductCode }}
+      it 'should raise correct arguement error' do
+        begin 
+          subject 
+        rescue Exception => e
+          e.to_s.include?("password").should be_true 
+        end
+      end
+    end
+
+    context 'with no product code option' do
+      let(:options) {{ :password => Password, :username => Username }}
+      it 'should raise correct arguement error' do
+        begin 
+          subject 
+        rescue Exception => e
+          e.to_s.include?("product_code").should be_true 
+        end
+      end
+    end
+
+    context 'client actions' do
+      let!(:cg_client){ 
+        Cheddargetter::Client.new(
+          :username     => 'brent.wooden@gmail.com',
+          :password     => 'j3rkface',
+          :product_code => 'BEETLEBOTS'
+        )
+      }
+
+      context 'errors' do
+        describe 'invalid_method' do
+          context 'when invalid controller' do
+            subject { cg_client.invalid_method }
+            specify { lambda { subject }.should raise_error(NoMethodError) }
+          end
+          
+          context 'when invalid action' do
+            subject { cg_client.customers_invalid_method }
+            specify { lambda { subject }.should raise_error(NoMethodError) }            
+          end
+        end
+      end
+      
+      describe 'customers_delete_all' do
+        subject { cg_client.customers_delete_all.to_s }
+        it { should include('success') }
+      end
+
+      context 'create/delete' do
+        describe 'customers_new' do
+          subject { cg_client.customers_new(ValidCustomer).to_s }
+          it { should include('Alemeda') }
+        end
+
+        describe 'customers_delete' do
+          subject { cg_client.customers_delete(:customer_code => CustomerCode).to_s }
+          it { should include 'success' }
+        end        
+      end
+      
+      context 'needing existing customers' do
+        before { 
+          UserCodes.each do |code|
+            create_customer_with_code(code)
+          end
+        }
+
+        describe "customers_get" do
+          context "with no arguements get all customers" do
+            subject { cg_client.customers_get.to_s }
+
+            UserCodes.each do |user_code|
+              it { should include user_code }
+            end
+          end
+        
+          context 'with specified customer' do          
+            subject { cg_client.customers_get(:customer_code => UserCodes.first).to_s }
+            it { should include UserCodes.first }          
+            it { should_not include UserCodes.last }
+          end
+        end
+      
+        describe 'customers_edit_customer' do
+          def reset_customer
+            cg_client.customers_edit_customer({:customer_code => UserCodes.first},{:company => ''}).to_s
+          end
+        
+          before  { reset_customer }
+          subject { cg_client.customers_edit_customer({:customer_code => UserCodes.first},{:company => 'sbox'}).to_s }
+        
+          it 'should update customer' do
+            should include('sbox')          
+          end
+        
+          it 'should reset customer' do
+            reset_customer.should_not include('sbox')        
+          end
+        end
+      end
+      
+      describe 'customer_edit_subscription' do
+        before  { cg_client.customers_new(ValidCustomer) }
+        subject { cg_client.customers_edit_subscription({:customer_code => CustomerCode},{:subscription => ValidSubscription}).to_s }
+        
+        it 'should update subscription' do
+          should include(PlanCodes.first)          
+        end
+        
+        describe 'customers_delete' do
+          subject { cg_client.customers_delete(:customer_code => CustomerCode).to_s }
+          it { should include 'success' }
+        end
+      end            
+      
+      describe 'customers_edit' do        
+        before  { sleep(8) }
+        before  { cg_client.customers_new(ValidCustomer) }
+        subject { cg_client.customers_edit({:customer_code => CustomerCode},{:company => 'sbox', :subscription => ValidSubscription}).to_s }
+        
+        it 'should update subscription' do
+          should include(PlanCodes.first)          
+        end
+        
+        it 'should update customer' do
+          should include('sbox')
+        end        
+      end
+      
+      describe 'customers_delete' do
+        subject { cg_client.customers_delete(:customer_code => CustomerCode).to_s }
+        it { should include 'success' }
+      end
+
+      context 'items' do
+        before  { cg_client.customers_new(ValidCustomer) }      
+
+        describe 'customers_add_item_quantity' do
+          context 'with a quantity' do
+            subject { cg_client.customers_add_item_quantity({:customer_code => CustomerCode, :itemCode => item_code}, {:quantity => 37}).to_s }
+
+            it { should include '37' }
+            it { should include item_code }
+          end
+        end
+        
+        describe 'set_item_quantity' do
+          subject { cg_client.customers_set_item_quantity({:customer_code => CustomerCode, :itemCode => item_code}, {:quantity => 13}).to_s }
+
+          it { should include item_code }
+          it { should include '13' }          
+        end
+
+        describe 'customers_add_item_quantity()' do
+          context 'with no quantity set' do
+            subject { cg_client.customers_add_item_quantity({:customer_code => CustomerCode, :itemCode => item_code}).to_s }
+
+            it { should include item_code }
+            it { should include '14' }
+          end
+        end
+
+
+        describe 'remove_item_quantity' do
+          subject { cg_client.customers_remove_item_quantity({:customer_code => CustomerCode, :itemCode => item_code}, {:quantity => 5}).to_s }
+
+          it { should include item_code }
+          it { should include '9' }   
+          
+          describe 'with no quantity set' do
+            subject { cg_client.customers_remove_item_quantity({:customer_code => CustomerCode, :itemCode => item_code}).to_s }
+
+            it { should include item_code }
+            it { should include '8' }
+          end       
+        end
+        
+        describe 'customers_delete' do
+          subject { cg_client.customers_delete(:customer_code => CustomerCode).to_s }
+          it { should include 'success' }
+        end        
+      end
+      
+      describe 'customers_add_charge' do
+        before  { cg_client.customers_new(ValidCustomer) }
+        subject { cg_client.customers_add_charge({:customer_code => CustomerCode}, {:chargeCode => ChargeCode, :quantity => 1, :eachAmount => 113}).to_s }
+        it { should include ChargeCode }
+        it { should include '113' }
+                
+        describe 'customers_delete' do
+          subject { cg_client.customers_delete(:customer_code => CustomerCode).to_s }
+          it { should include 'success' }
+        end            
+      end
+        
+      describe 'customers_delete_charge' do
+        before  { 
+          cg_client.customers_new(ValidCustomer) 
+          cg_client.customers_add_charge({:customer_code => CustomerCode}, {:chargeCode => ChargeCode, :quantity => 1, :eachAmount => 113}).to_s
+        }
+
+        subject { cg_client.customers_delete_charge({:customer_code => CustomerCode}, {:chargeId => charge_id}) }
+
+        let(:charge_id) { 
+          cg_client.customers_get({:customer_code => CustomerCode}).
+          parsed_response["customers"]["customer"]["subscriptions"]["subscription"]["invoices"]["invoice"]["charges"]["charge"].last["id"]
+        }
+        it { should_not include charge_id }
+      end
+      
+      describe 'invoices_new' do
+        before  { cg_client.customers_new(ValidCustomer) }
+        subject { cg_client.invoices_new(
+          {:customer_code => CustomerCode}, 
+          {:charges => {"1" => {:chargeCode => ChargeCode, :quantity => 1, :eachAmount => 117}}}
+        ).to_s }
+        it { should include ChargeCode }
+        it { should include '117' }    
+      end  
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require File.expand_path("lib/cheddargetter_client.rb")
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: cheddargetter_client
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Brent Wooden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+description: A more flexible solution for accessing the Cheddargetter API
+email: brent.wooden@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- cheddargetter_client.gemspec
+- lib/cheddargetter/client.rb
+- lib/cheddargetter/response.rb
+- lib/cheddargetter_client.rb
+- pkg/cheddargetter_client-0.0.0.gem
+- spec/cheddar_getter_client_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/BrentW/cheddargetter_client
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 518553288699319148
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A ruby wrapper for the Cheddargetter API
+test_files: []