paid 1.0.1 → 1.0.2

data/test/test_helper.rb

@@ -4,29 +4,29 @@ require 'mocha/setup'
 require 'stringio'
 require 'shoulda'
 require File.expand_path('../test_data', __FILE__)
-require File.expand_path('../mock_resource', __FILE__)
+# require File.expand_path('../mock_resource', __FILE__)
 
 # monkeypatch request methods
 module Paid
-  @mock_rest_client = nil
-
-  def self.mock_rest_client=(mock_client)
-    @mock_rest_client = mock_client
+  class << self
+    attr_accessor :mock_rest_client
   end
 
-  def self.execute_request(opts)
-    headers = opts[:headers]
-    post_params = opts[:payload]
-    case opts[:method]
-    when :get then @mock_rest_client.get opts[:url], headers, post_params
-    when :put then @mock_rest_client.put opts[:url], headers, post_params
-    when :post then @mock_rest_client.post opts[:url], headers, post_params
-    when :delete then @mock_rest_client.delete opts[:url], headers, post_params
+  module Requester
+    def self.request(method, url, params, headers)
+      case method
+      when :get then Paid::mock_rest_client.get(url, headers, params)
+      when :put then Paid::mock_rest_client.put(url, headers, params)
+      when :post then Paid::mock_rest_client.post(url, headers, params)
+      when :delete then Paid::mock_rest_client.delete(url, headers, params)
+      else
+        raise "Invalid method"
+      end
     end
   end
 end
 
-class Test::Unit::TestCase
+class ::Test::Unit::TestCase
   include Paid::TestData
   include Mocha
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paid
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Jon Calhoun
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-15 00:00:00.000000000 Z
+date: 2015-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -118,7 +118,7 @@ dependencies:
 description: Paid is the programmatic way to manage payments.  See https://paidapi.com
   for details.
 email:
-- joncalhoun@gmail.com
+- jon@apibits.com
 - ryan@paidapi.com
 executables:
 - paid-console
@@ -139,37 +139,41 @@ files:
 - gemfiles/yajl.gemfile
 - lib/paid.rb
 - lib/paid/account.rb
-- lib/paid/api_class.rb
 - lib/paid/api_list.rb
+- lib/paid/api_method.rb
 - lib/paid/api_resource.rb
-- lib/paid/api_singleton.rb
 - lib/paid/customer.rb
 - lib/paid/errors/api_connection_error.rb
 - lib/paid/errors/api_error.rb
 - lib/paid/errors/authentication_error.rb
-- lib/paid/errors/invalid_request_error.rb
 - lib/paid/errors/paid_error.rb
 - lib/paid/event.rb
+- lib/paid/event_data.rb
+- lib/paid/headers_builder.rb
 - lib/paid/invoice.rb
+- lib/paid/params_builder.rb
+- lib/paid/path_builder.rb
 - lib/paid/plan.rb
+- lib/paid/refund_list.rb
+- lib/paid/requester.rb
 - lib/paid/subscription.rb
 - lib/paid/transaction.rb
 - lib/paid/util.rb
 - lib/paid/version.rb
 - paid.gemspec
 - tasks/api_test.rb
-- test/mock_resource.rb
+- test/paid/_api_resource_test.rb
 - test/paid/account_test.rb
-- test/paid/api_class_test.rb
 - test/paid/api_list_test.rb
-- test/paid/api_resource_test.rb
-- test/paid/api_singleton_test.rb
-- test/paid/authentication_test.rb
+- test/paid/api_method_test.rb
 - test/paid/customer_test.rb
 - test/paid/event_test.rb
+- test/paid/headers_builder_test.rb
 - test/paid/invoice_test.rb
+- test/paid/params_builder_test.rb
+- test/paid/path_builder_test.rb
 - test/paid/plan_test.rb
-- test/paid/status_codes_test.rb
+- test/paid/requester_test.rb
 - test/paid/subscription_test.rb
 - test/paid/transaction_test.rb
 - test/paid/util_test.rb
@@ -195,23 +199,23 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for Paid API
 test_files:
-- test/mock_resource.rb
+- test/paid/_api_resource_test.rb
 - test/paid/account_test.rb
-- test/paid/api_class_test.rb
 - test/paid/api_list_test.rb
-- test/paid/api_resource_test.rb
-- test/paid/api_singleton_test.rb
-- test/paid/authentication_test.rb
+- test/paid/api_method_test.rb
 - test/paid/customer_test.rb
 - test/paid/event_test.rb
+- test/paid/headers_builder_test.rb
 - test/paid/invoice_test.rb
+- test/paid/params_builder_test.rb
+- test/paid/path_builder_test.rb
 - test/paid/plan_test.rb
-- test/paid/status_codes_test.rb
+- test/paid/requester_test.rb
 - test/paid/subscription_test.rb
 - test/paid/transaction_test.rb
 - test/paid/util_test.rb

data/lib/paid/api_class.rb

@@ -1,338 +0,0 @@
-module Paid
-  class APIClass
-    attr_accessor :json
-
-    def self.path
-      raise NotImplementedError.new("APIClass is an abstract class. Please refer to its subclasses: #{subclasses}")
-    end
-
-    def path
-      raise NotImplementedError.new("APIClass is an abstract class. Please refer to its subclasses: #{APIClass.subclasses}")
-    end
-
-    def self.api_class_method(name, method, path=nil, opts={})
-      singleton = class << self; self end
-      singleton.send(:define_method, name, api_lambda(name, method, path, opts))
-    end
-
-    def self.api_instance_method(name, method, path=nil, opts={})
-      self.send(:define_method, name, api_lambda(name, method, path, opts))
-    end
-
-    def self.attribute(name, klass=nil)
-      @attribute_names ||= Set.new
-      @attribute_names << name.to_sym
-
-      self.send(:define_method, "#{name}", attribute_get_lambda(name))
-      self.send(:define_method, "#{name}=", attribute_set_lambda(name, klass))
-    end
-
-    def attributes
-      attributes = {}
-      self.class.attribute_names.each do |attr|
-        attributes[attr.to_sym] = self.send(attr)
-      end
-      attributes
-    end
-
-    def non_nil_attributes
-      attributes.select{|k, v| !v.nil? }
-    end
-
-    def self.attribute_names
-      @attribute_names ||= Set.new
-      unless self == APIClass
-        @attribute_names + self.superclass.attribute_names
-      else
-        @attribute_names
-      end
-    end
-
-    def mark_attribute_changed(attr_name)
-      @changed_attribute_names ||= Set.new
-      @changed_attribute_names << attr_name.to_sym
-    end
-
-    def changed_attribute_names
-      @changed_attribute_names ||= Set.new
-      attributes.each do |key, val|
-        next if @changed_attribute_names.include?(key)
-        if val.is_a?(Array) || val.is_a?(Hash)
-          @changed_attribute_names << key if json[key] != val
-        end
-      end
-      @changed_attribute_names
-    end
-
-    def changed_attributes
-      ret = {}
-      changed_attribute_names.each do |attr|
-        ret[attr] = send(attr)
-      end
-      ret
-    end
-
-    def clear_changed_attributes
-      @changed_attribute_names = Set.new
-    end
-
-
-    def self.changed_lambda
-      # This runs in the context of an instance since it is used in
-      # an api_instance_method
-      lambda do |instance|
-        instance.changed_attributes
-      end
-    end
-
-    def initialize(id=nil)
-      refresh_from(id)
-    end
-
-    def self.construct(json={})
-      self.new.refresh_from(json)
-    end
-
-    def refresh_from(json={})
-      unless json.is_a?(Hash)
-        json = { :id => json }
-      end
-      self.json = Util.sorta_deep_clone(json)
-
-      json.each do |k, v|
-        if self.class.attribute_names.include?(k.to_sym)
-          self.send("#{k}=", v)
-        end
-      end
-      clear_changed_attributes
-      self
-    end
-
-    # Alias, but dont declare it as one because we need to use overloaded methods.
-    def construct(json={})
-      refresh_from(json)
-    end
-
-    def self.subclasses
-      return @subclasses ||= Set.new
-    end
-
-    def self.subclass_fetch(name)
-      @subclasses_hash ||= {}
-      if @subclasses_hash.has_key?(name)
-        @subclasses_hash[name]
-      end
-    end
-
-    def self.register_subclass(subclass, name=nil)
-      @subclasses ||= Set.new
-      @subclasses << subclass
-
-      unless name.nil?
-        @subclasses_hash ||= {}
-        @subclasses_hash[name] = subclass
-      end
-    end
-
-    def inspect
-      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
-      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(attributes)
-    end
-
-    def to_json(*a)
-      JSON.generate(attributes)
-    end
-
-
-    private
-
-    def instance_variables_include?(name)
-      if RUBY_VERSION <= '1.9'
-        instance_variables.include?("@#{name}")
-      else
-        instance_variables.include?("@#{name}".to_sym)
-      end
-    end
-
-    def self.attribute_get_lambda(name)
-      lambda do
-        unless instance_variables_include?(name)
-          nil
-        else
-          instance_variable_get("@#{name}")
-        end
-      end
-    end
-
-    def self.attribute_set_lambda(name, klass=nil)
-      lambda do |val|
-        if klass
-          val = klass.construct(val)
-        end
-        instance_variable_set("@#{name}", val)
-        mark_attribute_changed(name)
-      end
-    end
-
-    def self.api_lambda(out_name, out_method, out_path=nil, out_opts={})
-      # Path, Opts, and Klass are all optional, so we have to determine
-      # which were provided using the criteria:
-      temp = [out_path, out_opts]
-      out_path = temp.select{ |t| t.is_a?(String) }.first || nil
-      out_opts = temp.select{ |t| t.is_a?(Hash) }.first || {}
-
-      out_arg_names = out_opts[:arguments] || []
-      out_constructor = out_opts[:constructor] || :self
-      out_default_params = out_opts[:default_params] || {}
-
-      lambda do |*args|
-        # Make sure we have clean data
-        constructor = out_constructor
-        method = out_method
-        path = nil
-        path = out_path.dup if out_path
-        arg_names = nil
-        arg_names = out_arg_names.dup if out_arg_names
-        default_params = out_default_params # dont need to dup this since it isn't modified directly
-
-        validate_args(arg_names, *args)
-        arguments = compose_arguments(method, arg_names, *args)
-        composed_path = compose_api_path(path, arguments)
-        unused_args = determine_unused_args(path, arg_names, arguments)
-        arguments[:params] = compose_params(arguments[:params], unused_args, default_params)
-
-        resp = Paid.request(method, composed_path, arguments[:params], arguments[:opts])
-
-
-        puts "Making a call to #{composed_path}"
-
-        if constructor.is_a?(Class)
-          constructor.construct(resp)
-        elsif constructor.is_a?(Proc)
-          constructor.call(resp)
-        elsif constructor.is_a?(Symbol)
-          if constructor == :self
-            self.construct(resp)
-          else
-            raise ArgumentError.new("Invalid constructor. See method definition.")
-          end
-        end
-      end
-    end
-
-    def self.validate_args(arg_names, *args)
-      # Make sure we have valid arguments
-      if args.length > arg_names.length
-        if args.length > arg_names.length + 2 # more than params and opts were included
-          raise ArgumentError.new("Too many arguments")
-        else
-          # Params and opts are allowed, but they must be hashes
-          args[arg_names.length..-1].each do |arg|
-            unless arg.is_a?(Hash) || arg.nil?
-              raise ArgumentError.new("Invalid Param or Opts argument")
-            end
-          end
-        end
-      end
-
-      if args.length < arg_names.length
-        missing = arg_names[args.length..-1]
-        raise ArgumentError.new("Missing arguments #{missing}")
-      end
-    end
-    def validate_args(arg_names, *args)
-      self.class.validate_args(arg_names, *args)
-    end
-
-    # Priority: params > unused_args > default_params
-    def self.compose_params(params={}, unused_args={}, default_params={}, this=self)
-      ret = {}
-
-      # Handle the default params
-      if default_params.is_a?(Proc)
-        default_params = default_params.call(this)
-      elsif default_params.is_a?(Symbol)
-        default_params = this.send(default_params)
-      end
-
-      ret.update(default_params || {})
-      ret.update(unused_args || {})
-      ret.update(params || {})
-      ret
-    end
-    def compose_params(params={}, unused_args={}, default_params={})
-      self.class.compose_params(params, unused_args, default_params, self)
-    end
-
-    def self.compose_arguments(method, arg_names, *args)
-      arguments = {}
-      names = arg_names.dup + [:params, :opts]
-
-      names.each_with_index do |k, i|
-        arguments[k] = args[i] if args.length > i
-      end
-      arguments[:params] ||= {}
-      arguments[:opts] ||= {}
-
-      arguments
-    end
-    def compose_arguments(method, arg_names, *args)
-      self.class.compose_arguments(method, arg_names, *args)
-    end
-
-    def self.compose_api_path(path, arguments, this=self)
-      # Setup the path using the following attribute order:
-      #   1. Args passed in
-      #   2. Args on this
-      #   3. Args on this.class
-      ret = (path || this.path).dup
-      if ret.include?(":")
-        missing = Set.new
-        matches = ret.scan(/:([^\/]*)/).flatten.map(&:to_sym)
-        matches.each do |match|
-          value = arguments[match]
-          begin
-            value ||= this.send(match)
-          rescue NoMethodError
-          end
-          begin
-            value ||= this.class.send(match) unless this.class == Class
-          rescue NoMethodError
-          end
-
-          if value.nil?
-            missing << match
-          end
-
-          ret.sub!(match.inspect, "#{value}")
-        end
-
-        unless missing.empty?
-          raise InvalidRequestError.new("Could not determine the full URL to request. Missing the following values: #{missing.to_a.join(', ')}.")
-        end
-      end
-      ret
-    end
-    def compose_api_path(path, arguments)
-      self.class.compose_api_path(path, arguments, self)
-    end
-
-    def self.determine_unused_args(path, arg_names, arguments, this=self)
-      unused = Set.new(arg_names)
-      path ||= this.path
-      if path.include?(":")
-        matches = path.scan(/:([^\/]*)/).flatten.map(&:to_sym)
-        matches.each{ |m| unused.delete(m) }
-      end
-      ret = {}
-      unused.each do |arg_name|
-        ret[arg_name] = arguments[arg_name]
-      end
-      ret
-    end
-    def determine_unused_args(path, arg_names, arguments)
-      self.class.determine_unused_args(path, arg_names, arguments, self)
-    end
-
-  end
-end