paid 0.1.0 → 1.0.0

data/lib/paid/paid_object.rb

@@ -1,187 +0,0 @@
-module Paid
-  class PaidObject
-    include Enumerable
-
-    attr_accessor :api_key
-    @@permanent_attributes = Set.new([:api_key, :id])
-
-    # The default :id method is deprecated and isn't useful to us
-    if method_defined?(:id)
-      undef :id
-    end
-
-    def initialize(id=nil, api_key=nil)
-      # parameter overloading!
-      if id.kind_of?(Hash)
-        @retrieve_options = id.dup
-        @retrieve_options.delete(:id)
-        id = id[:id]
-      else
-        @retrieve_options = {}
-      end
-
-      @api_key = api_key
-      @values = {}
-      # This really belongs in APIResource, but not putting it there allows us
-      # to have a unified inspect method
-      @unsaved_values = Set.new
-      @transient_values = Set.new
-      @values[:id] = id if id
-    end
-
-    def self.construct_from(values, api_key=nil)
-      self.new(values[:id], api_key).refresh_from(values, api_key)
-    end
-
-    def to_s(*args)
-      JSON.pretty_generate(@values)
-    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(@values)
-    end
-
-    def refresh_from(values, api_key, partial=false)
-      @api_key = api_key
-
-      @previous_properties = values[:properties]
-      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
-      added = Set.new(values.keys - @values.keys)
-
-      instance_eval do
-        remove_accessors(removed)
-        add_accessors(added)
-      end
-      removed.each do |k|
-        @values.delete(k)
-        @transient_values.add(k)
-        @unsaved_values.delete(k)
-      end
-      values.each do |k, v|
-        @values[k] = Util.convert_to_paid_object(v, api_key)
-        @transient_values.delete(k)
-        @unsaved_values.delete(k)
-      end
-
-      return self
-    end
-
-    def [](k)
-      @values[k.to_sym]
-    end
-
-    def []=(k, v)
-      send(:"#{k}=", v)
-    end
-
-    def keys
-      @values.keys
-    end
-
-    def values
-      @values.values
-    end
-
-    def to_json(*a)
-      JSON.generate(@values)
-    end
-
-    def as_json(*a)
-      @values.as_json(*a)
-    end
-
-    def to_hash
-      @values.inject({}) do |acc, (key, value)|
-        acc[key] = value.respond_to?(:to_hash) ? value.to_hash : value
-        acc
-      end
-    end
-
-    def each(&blk)
-      @values.each(&blk)
-    end
-
-    def _dump(level)
-      Marshal.dump([@values, @api_key])
-    end
-
-    def self._load(args)
-      values, api_key = Marshal.load(args)
-      construct_from(values, api_key)
-    end
-
-    if RUBY_VERSION < '1.9.2'
-      def respond_to?(symbol)
-        @values.has_key?(symbol) || super
-      end
-    end
-
-    protected
-
-    def metaclass
-      class << self; self; end
-    end
-
-    def remove_accessors(keys)
-      metaclass.instance_eval do
-        keys.each do |k|
-          next if @@permanent_attributes.include?(k)
-          k_eq = :"#{k}="
-          remove_method(k) if method_defined?(k)
-          remove_method(k_eq) if method_defined?(k_eq)
-        end
-      end
-    end
-
-    def add_accessors(keys)
-      metaclass.instance_eval do
-        keys.each do |k|
-          next if @@permanent_attributes.include?(k)
-          k_eq = :"#{k}="
-          define_method(k) { @values[k] }
-          define_method(k_eq) do |v|
-            if v == ""
-              raise ArgumentError.new(
-                "You cannot set #{k} to an empty string." +
-                "We interpret empty strings as nil in requests." +
-                "You may set #{self}.#{k} = nil to delete the property.")
-            end
-            @values[k] = v
-            @unsaved_values.add(k)
-          end
-        end
-      end
-    end
-
-    def method_missing(name, *args)
-      # TODO: only allow setting in updateable classes.
-      if name.to_s.end_with?('=')
-        attr = name.to_s[0...-1].to_sym
-        add_accessors([attr])
-        begin
-          mth = method(name)
-        rescue NameError
-          raise NoMethodError.new("Cannot set #{attr} on this object. HINT: you can't set: #{@@permanent_attributes.to_a.join(', ')}")
-        end
-        return mth.call(args[0])
-      else
-        return @values[name] if @values.has_key?(name)
-      end
-
-      begin
-        super
-      rescue NoMethodError => e
-        if @transient_values.include?(name)
-          raise NoMethodError.new(e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Paid's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}")
-        else
-          raise
-        end
-      end
-    end
-
-    def respond_to_missing?(symbol, include_private = false)
-      @values && @values.has_key?(symbol) || super
-    end
-  end
-end

data/lib/paid/singleton_api_resource.rb

@@ -1,20 +0,0 @@
-module Paid
-  class SingletonAPIResource < APIResource
-    def self.api_url
-      if self == SingletonAPIResource
-        raise NotImplementedError.new('SingletonAPIResource is an abstract class.  You should perform actions on its subclasses (Account, etc.)')
-      end
-      "/v0/#{CGI.escape(class_name.downcase)}"
-    end
-
-    def api_url
-      self.class.api_url
-    end
-
-    def self.retrieve(api_key=nil)
-      instance = self.new(nil, api_key)
-      instance.refresh
-      instance
-    end
-  end
-end

data/lib/tasks/paid_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :paid do
-#   # Task goes here
-# end

data/test/paid/alias_test.rb

@@ -1,22 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Paid
-  # AliasTest
-  class AliasTest < Test::Unit::TestCase
-    should 'aliases should not be deletable' do
-      assert_raises NoMethodError do
-        # Expect twice because Paid::Alias.retrieve returns a customer object
-        @mock.expects(:get).twice.returns(test_response(test_customer))
-        c = Paid::Alias.retrieve('test_alias')
-        c.delete
-      end
-    end
-
-    should 'retrieve should retrieve alias' do
-      # Expect twice because Paid::Alias.retrieve returns a customer object
-      @mock.expects(:get).twice.returns(test_response(test_alias))
-      i = Paid::Alias.retrieve('in_test_alias')
-      assert_equal 'al_test_alias', i.id
-    end
-  end
-end

data/test/paid/certificate_blacklist_test.rb

@@ -1,18 +0,0 @@
-# require File.expand_path('../../test_helper', __FILE__)
-
-# module Paid
-
-#   class CertificateBlacklistTest < Test::Unit::TestCase
-#     should "not trust revoked certificates" do
-#       assert_raises(Paid::APIConnectionError) {
-#         Paid::CertificateBlacklist.check_ssl_cert("https://revoked.paidapi.com:444",
-#                                                     Paid::DEFAULT_CA_BUNDLE_PATH)
-#       }
-#     end
-
-#     should "trust api.paidapi.com" do
-#       assert_true Paid::CertificateBlacklist.check_ssl_cert("https://api.paidapi.com",
-#                                                               Paid::DEFAULT_CA_BUNDLE_PATH)
-#     end
-#   end
-# end

data/test/paid/list_object_test.rb

@@ -1,16 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Paid
-  class ListObjectTest < Test::Unit::TestCase
-    should "be able to retrieve full lists given a listobject" do
-      @mock.expects(:get).twice.returns(test_response(test_transaction_array))
-      c = Paid::Transaction.all
-      assert c.kind_of?(Paid::ListObject)
-      assert_equal('/v0/transactions', c.url)
-      all = c.all
-      assert all.kind_of?(Paid::ListObject)
-      assert_equal('/v0/transactions', all.url)
-      assert all.data.kind_of?(Array)
-    end
-  end
-end

data/test/paid/paid_object_test.rb

@@ -1,27 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Paid
-  class PaidObjectTest < Test::Unit::TestCase
-    should "implement #respond_to correctly" do
-      obj = Paid::PaidObject.construct_from({ :id => 1, :foo => 'bar' })
-      assert obj.respond_to?(:id)
-      assert obj.respond_to?(:foo)
-      assert !obj.respond_to?(:baz)
-    end
-
-    should "marshal a paid object correctly" do
-      obj = Paid::PaidObject.construct_from({ :id => 1, :name => 'Paid' }, 'apikey')
-      m = Marshal.load(Marshal.dump(obj))
-      assert_equal 1, m.id
-      assert_equal 'Paid', m.name
-      assert_equal 'apikey', m.api_key
-    end
-
-    should "recursively call to_hash on its values" do
-      nested = Paid::PaidObject.construct_from({ :id => 7, :foo => 'bar' })
-      obj = Paid::PaidObject.construct_from({ :id => 1, :nested => nested })
-      expected_hash = { :id => 1, :nested => { :id => 7, :foo => 'bar' } }
-      assert_equal expected_hash, obj.to_hash
-    end
-  end
-end

data/test/paid/properties_test.rb

@@ -1,103 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Paid
-  class PropertiesTest < Test::Unit::TestCase
-    setup do
-      @properties_supported = {
-        transaction: {
-          new: Paid::Transaction.method(:new),
-          test: method(:test_transaction),
-          url: "/v0/transactions/#{test_transaction[:id]}"
-        },
-        customer: {
-          new: Paid::Customer.method(:new),
-          test: method(:test_customer),
-          url: "/v0/customers/#{test_customer[:id]}"
-        }
-      }
-
-      @base_url = 'https://api.paidapi.com'
-    end
-
-    should 'not touch properties' do
-      update_actions = ->(obj) { obj.description = 'test' }
-      check_properties({ properties: { 'initial' => 'true' } },
-                     'description=test',
-                     update_actions)
-    end
-
-    should 'update properties as a whole' do
-      update_actions = ->(obj) { obj.properties = { 'uuid' => '6735' } }
-      check_properties({ properties: {} },
-                     'properties[uuid]=6735',
-                     update_actions)
-
-      if is_greater_than_ruby_1_9?
-        check_properties({ properties: { initial: 'true' } },
-                       'properties[uuid]=6735&properties[initial]=',
-                       update_actions)
-      end
-    end
-
-    should 'update properties keys individually' do
-      update_actions = ->(obj) { obj.properties['txn_id'] = '134a13' }
-      check_properties({ properties: { 'initial' => 'true' } },
-                     'properties[txn_id]=134a13',
-                     update_actions)
-    end
-
-    should 'clear properties as a whole' do
-      update_actions = ->(obj) { obj.properties = nil }
-      check_properties({ properties: { 'initial' => 'true' } },
-                     'properties=',
-                     update_actions)
-    end
-
-    should 'clear properties keys individually' do
-      update_actions = ->(obj) { obj.properties['initial'] = nil }
-      check_properties({ properties: { 'initial' => 'true' } },
-                     'properties[initial]=',
-                     update_actions)
-    end
-
-    should 'handle combinations of whole and partial properties updates' do
-      if is_greater_than_ruby_1_9?
-        update_actions = lambda do |obj|
-          obj.properties = { 'type' => 'summer' }
-          obj.properties['uuid'] = '6735'
-        end
-        params = { properties: { 'type' => 'summer', 'uuid' => '6735' } }
-        curl_args = Paid.uri_encode(params)
-        check_properties({ properties: { 'type' => 'christmas' } },
-                       curl_args,
-                       update_actions)
-      end
-    end
-
-    def check_properties(initial_params, curl_args, properties_update)
-      @properties_supported.each do |_name, methods|
-        neu = methods[:new]
-        test = methods[:test]
-        url = @base_url + methods[:url]
-
-        initial_test_obj = test.call(initial_params)
-        @mock.expects(:get).once.returns(test_response(initial_test_obj))
-
-        final_test_obj = test.call
-        @mock.expects(:post).once
-          .returns(test_response(final_test_obj))
-          .with(url, nil, curl_args)
-
-        obj = neu.call('test')
-        obj.refresh
-        properties_update.call(obj)
-        obj.save
-      end
-    end
-
-    def is_greater_than_ruby_1_9?
-      version = RUBY_VERSION.dup  # clone preserves frozen state
-      Gem::Version.new(version) >= Gem::Version.new('1.9')
-    end
-  end
-end