rainforest 1.0.7 → 2.0.0

data/lib/rainforest/api_operations/create.rb

@@ -1,16 +0,0 @@
-module Rainforest
-  module APIOperations
-    module Create
-      module ClassMethods
-        def create(params={}, api_key=nil)
-          response, api_key = Rainforest.request(:post, self.url, api_key, params)
-          Util.convert_to_rainforest_object(response, api_key)
-        end
-      end
-
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-    end
-  end
-end

data/lib/rainforest/api_operations/delete.rb

@@ -1,11 +0,0 @@
-module Rainforest
-  module APIOperations
-    module Delete
-      def delete
-        response, api_key = Rainforest.request(:delete, url, @api_key)
-        refresh_from(response, api_key)
-        self
-      end
-    end
-  end
-end

data/lib/rainforest/api_operations/list.rb

@@ -1,16 +0,0 @@
-module Rainforest
-  module APIOperations
-    module List
-      module ClassMethods
-        def all(filters={}, api_key=nil)
-          response, api_key = Rainforest.request(:get, url, api_key, filters)
-          Util.convert_to_rainforest_object(response, api_key)
-        end
-      end
-
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-    end
-  end
-end

data/lib/rainforest/api_operations/update.rb

@@ -1,61 +0,0 @@
-module Rainforest
-  module APIOperations
-    module Update
-      def save
-        values = serialize_params(self)
-
-        if @values[:metadata]
-          values[:metadata] = serialize_metadata
-        end
-
-        if values.length > 0
-          values.delete(:id)
-
-          if self.id
-            response, api_key = Rainforest.request(:put, url + "/#{self.id}", @api_key, values)
-          else
-            response, api_key = Rainforest.request(:post, url, @api_key, values)
-          end
-          refresh_from(response, api_key)
-        end
-        self
-      end
-
-      def serialize_metadata
-        if @unsaved_values.include?(:metadata)
-          # the metadata object has been reassigned
-          # i.e. as object.metadata = {key => val}
-          metadata_update = @values[:metadata]  # new hash
-          new_keys = metadata_update.keys.map(&:to_sym)
-          # remove keys at the server, but not known locally
-          keys_to_unset = @previous_metadata.keys - new_keys
-          keys_to_unset.each {|key| metadata_update[key] = ''}
-
-          metadata_update
-        else
-          # metadata is a RainforestObject, and can be serialized normally
-          serialize_params(@values[:metadata])
-        end
-      end
-
-      def serialize_params(obj)
-        case obj
-        when nil
-          ''
-        when RainforestObject
-          unsaved_keys = obj.instance_variable_get(:@unsaved_values)
-          obj_values = obj.instance_variable_get(:@values)
-          update_hash = {}
-
-          unsaved_keys.each do |k|
-            update_hash[k] = serialize_params(obj_values[k])
-          end
-
-          update_hash
-        else
-          obj
-        end
-      end
-    end
-  end
-end

data/lib/rainforest/api_resource.rb

@@ -1,33 +0,0 @@
-module Rainforest
-  class APIResource < RainforestObject
-    def self.class_name
-      self.name.split('::')[-1]
-    end
-
-    def self.url()
-      if self == APIResource
-        raise NotImplementedError.new('APIResource is an abstract class.  You should perform actions on its subclasses (Charge, Customer, etc.)')
-      end
-      "/#{CGI.escape(class_name.downcase)}s"
-    end
-
-    def url
-      unless id = self['id']
-        raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
-      end
-      "#{self.class.url}/#{CGI.escape(id.to_s)}"
-    end
-
-    def refresh
-      response, api_key = Rainforest.request(:get, url, @api_key, @retrieve_options)
-      refresh_from(response, api_key)
-      self
-    end
-
-    def self.retrieve(id, api_key=nil)
-      instance = self.new(id, api_key)
-      instance.refresh
-      instance
-    end
-  end
-end

data/lib/rainforest/errors/invalid_request_error.rb

@@ -1,10 +0,0 @@
-module Rainforest
-  class InvalidRequestError < RainforestError
-    attr_accessor :param
-
-    def initialize(message, param, http_status=nil, http_body=nil, json_body=nil)
-      super(message, http_status, http_body, json_body)
-      @param = param
-    end
-  end
-end

data/lib/rainforest/json.rb

@@ -1,21 +0,0 @@
-module Rainforest
-  module JSON
-    if MultiJson.respond_to?(:dump)
-      def self.dump(*args)
-        MultiJson.dump(*args)
-      end
-
-      def self.load(*args)
-        MultiJson.load(*args)
-      end
-    else
-      def self.dump(*args)
-        MultiJson.encode(*args)
-      end
-
-      def self.load(*args)
-        MultiJson.decode(*args)
-      end
-    end
-  end
-end

data/lib/rainforest/list_object.rb

@@ -1,35 +0,0 @@
-module Rainforest
-  class ListObject < RainforestObject
-
-    def [](k)
-      case k
-      when String, Symbol
-        super
-      else
-        raise ArgumentError.new("You tried to access the #{k.inspect} index, but ListObject types only support String keys. (HINT: List calls return an object with a 'data' (which is the data array). You likely want to call #data[#{k.inspect}])")
-      end
-    end
-
-    def each(&blk)
-      self.data.each(&blk)
-    end
-
-    def retrieve(id, api_key=nil)
-      api_key ||= @api_key
-      response, api_key = Rainforest.request(:get,"#{url}/#{CGI.escape(id)}", api_key)
-      Util.convert_to_rainforest_object(response, api_key)
-    end
-
-    def create(params={}, api_key=nil)
-      api_key ||= @api_key
-      response, api_key = Rainforest.request(:post, url, api_key, params)
-      Util.convert_to_rainforest_object(response, api_key)
-    end
-
-    def all(params={}, api_key=nil)
-      api_key ||= @api_key
-      response, api_key = Rainforest.request(:get, url, api_key, params)
-      Util.convert_to_rainforest_object(response, api_key)
-    end
-  end
-end

data/lib/rainforest/rainforest_object.rb

@@ -1,165 +0,0 @@
-module Rainforest
-  class RainforestObject
-    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)
-      obj = self.new(values[:id], api_key)
-      obj.refresh_from(values, api_key)
-      obj
-    end
-
-    def to_s(*args)
-      Rainforest::JSON.dump(@values, :pretty => true)
-    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: " + Rainforest::JSON.dump(@values, :pretty => true)
-    end
-
-    def refresh_from(values, api_key, partial=false)
-      @api_key = api_key
-
-      @previous_metadata = values[:metadata]
-      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_rainforest_object(v, api_key)
-        @transient_values.delete(k)
-        @unsaved_values.delete(k)
-      end
-    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)
-      Rainforest::JSON.dump(@values)
-    end
-
-    def as_json(*a)
-      @values.as_json(*a)
-    end
-
-    def to_hash
-      @values
-    end
-
-    def each(&blk)
-      @values.each(&blk)
-    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 Rainforest'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
-  end
-end

data/lib/rainforest/run.rb

@@ -1,8 +0,0 @@
-module Rainforest
-  class Run < APIResource
-    include Rainforest::APIOperations::Create
-    include Rainforest::APIOperations::Delete
-    include Rainforest::APIOperations::Update
-    include Rainforest::APIOperations::List
-  end
-end

data/lib/rainforest/singleton_api_resource.rb

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

data/lib/rainforest/util.rb

@@ -1,100 +0,0 @@
-module Rainforest
-  module Util
-    def self.objects_to_ids(h)
-      case h
-      when APIResource
-        h.id
-      when Hash
-        res = {}
-        h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
-        res
-      when Array
-        h.map { |v| objects_to_ids(v) }
-      else
-        h
-      end
-    end
-
-    def self.object_classes
-      @object_classes ||= {
-        'Run' => Run,
-        'list' => ListObject
-      }
-    end
-
-    # TODO(jon): Suggest an object attribute be returned instead of this.
-    def self.convert_to_rainforest_object(resp, api_key)
-      case resp
-      when Array
-        resp.map { |i| convert_to_rainforest_object(i, api_key) }
-      when Hash
-        # Try converting to a known object class.  If none available, fall back to generic RainforestObject
-        object_classes.fetch(resp[:object], RainforestObject).construct_from(resp, api_key)
-      else
-        resp
-      end
-    end
-
-    def self.file_readable(file)
-      # This is nominally equivalent to File.readable?, but that can
-      # report incorrect results on some more oddball filesystems
-      # (such as AFS)
-      begin
-        File.open(file) { |f| }
-      rescue
-        false
-      else
-        true
-      end
-    end
-
-    def self.symbolize_names(object)
-      case object
-      when Hash
-        new = {}
-        object.each do |key, value|
-          key = (key.to_sym rescue key) || key
-          new[key] = symbolize_names(value)
-        end
-        new
-      when Array
-        object.map { |value| symbolize_names(value) }
-      else
-        object
-      end
-    end
-
-    def self.url_encode(key)
-      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-    end
-
-    def self.flatten_params(params, parent_key=nil)
-      result = []
-      params.each do |key, value|
-        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
-        if value.is_a?(Hash)
-          result += flatten_params(value, calculated_key)
-        elsif value.is_a?(Array)
-          result += flatten_params_array(value, calculated_key)
-        else
-          result << [calculated_key, value]
-        end
-      end
-      result
-    end
-
-    def self.flatten_params_array(value, calculated_key)
-      result = []
-      value.each do |elem|
-        if elem.is_a?(Hash)
-          result += flatten_params(elem, calculated_key)
-        elsif elem.is_a?(Array)
-          result += flatten_params_array(elem, calculated_key)
-        else
-          result << ["#{calculated_key}[]", elem]
-        end
-      end
-      result
-    end
-  end
-end