rainforest 1.0.7 → 2.0.0

data/lib/rainforest/apibits/api_client.rb

@@ -0,0 +1,28 @@
+module Rainforest
+  class ApiClient
+    attr_accessor :headers, :params
+
+    def initialize(headers, params)
+      self.refresh_from(headers, params)
+    end
+
+    def refresh_from(headers, params)
+      @headers = headers
+      @params = params
+      self
+    end
+
+    def execute(api_method)
+      api_method.headers = ParamsBuilder.merge(api_method.headers, @headers)
+      api_method.params = ParamsBuilder.merge(api_method.params, @params)
+      api_method.execute
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}> Headers: " +
+        JSON.pretty_generate(@headers) + ", Params: " +
+        JSON.pretty_generate(@params)
+    end
+
+  end
+end

data/lib/rainforest/apibits/api_endpoint.rb

@@ -0,0 +1,11 @@
+module Rainforest
+  class ApiEndpoint
+    attr_accessor :client
+    attr_accessor :parent
+
+    def initialize(client, parent=nil)
+      @client = client
+      @parent = parent
+    end
+  end
+end

data/lib/rainforest/apibits/api_list.rb

@@ -0,0 +1,88 @@
+module Rainforest
+  class ApiList < ApiResource
+    include Enumerable
+
+    attr_reader :api_method
+    attr_reader :client
+    attr_reader :data
+    attr_reader :klass
+
+    def initialize(klass, json={}, api_method=nil, client=nil)
+      if klass.is_a?(Class)
+        @klass = klass
+      else
+        @klass = Util.constantize(klass)
+      end
+
+      refresh_from(json, api_method, client)
+    end
+
+    def refresh_from(json, api_method=nil, client=nil)
+      unless json.is_a?(Hash)
+        json = {
+          :data => json
+        }
+      end
+      json = Util.symbolize_keys(json)
+
+      clear_api_attributes
+      @api_method = api_method
+      @client = client
+      @data = []
+      @json = Util.sorta_deep_clone(json)
+
+      json.each do |k, v|
+        if k.to_sym == :data
+          if v.respond_to?(:map)
+            instance_variable_set("@#{k}", v.map{ |i| @klass.new(i, @api_method, @client) })
+          else
+            instance_variable_set("@#{k}", v || [])
+          end
+        elsif self.class.api_attribute_names.include?(k)
+          instance_variable_set("@#{k}", determine_api_attribute_value(k, v))
+        end
+      end
+      self
+    end
+
+    def [](k)
+      data[k]
+    end
+
+    def []=(k, v)
+      data[k]=v
+    end
+
+    def last
+      data.last
+    end
+
+    def length
+      data.length
+    end
+
+    def each(&blk)
+      data.each(&blk)
+    end
+
+    def inspect
+      "#<#{self.class}[#{@klass}]:0x#{self.object_id.to_s(16)}> Data: " + JSON.pretty_generate(inspect_data)
+    end
+
+    def inspect_data
+      ret = []
+      data.each do |d|
+        if d.respond_to?(:inspect_nested)
+          ret << d.inspect_nested
+        else
+          ret << d
+        end
+      end
+      ret
+    end
+
+    @api_attributes = {
+      :data => { :readonly => true }
+    }
+  end
+end

data/lib/rainforest/apibits/api_method.rb

@@ -0,0 +1,95 @@
+module Rainforest
+  class ApiMethod
+
+    attr_accessor :path
+    attr_accessor :method
+    attr_accessor :params
+    attr_accessor :headers
+
+    attr_accessor :response_body
+    attr_accessor :response_code
+    attr_accessor :error
+
+    attr_accessor :api_base
+
+    def initialize(method, path, params, headers, object)
+      @api_base = api_base || Rainforest.api_base
+
+      @method = method.to_sym
+      @path = PathBuilder.build(path, object, params)
+      @params = ParamsBuilder.build(params)
+      @headers = HeadersBuilder.build(headers)
+    end
+
+    def execute
+      begin
+        response = Requester.request(method, url, params, headers)
+        @response_body = response.body
+        @response_code = response.code
+      rescue StandardError => e
+        @response_body = e.http_body if e.respond_to?(:http_body)
+        @response_code = e.http_code if e.respond_to?(:http_code)
+        @error = compose_error(e)
+        raise @error
+      end
+
+
+      response_json
+    end
+
+    def url
+      "#{api_base}#{@path}"
+    end
+
+    def response_json
+      return @json if @json
+      begin
+        @json = Util.symbolize_keys(JSON.parse(@response_body))
+      rescue JSON::ParserError
+        @error = ApiError.new("Unable to parse the server response as JSON.", self)
+        raise @error
+      end
+      @json
+    end
+
+    def compose_error(error)
+      msg = "An error occured while making the API call."
+
+      case error
+      when RestClient::ExceptionWithResponse
+        return error_with_response(error)
+
+      when RestClient::RequestTimeout
+        msg = "The request timed out while making the API call."
+
+      when RestClient::ServerBrokeConnection
+        msg = "The connection to the server broke before the request completed."
+
+      when SocketError
+        msg = "An unexpected error occured while trying to connect to " \
+          "the API. You may be seeing this message because your DNS is " \
+          "not working. To check, try running 'host #{Rainforest.api_base}' "\
+          "from the command line."
+
+      else
+        msg = "An unexpected error occured. If this problem persists let us " \
+          "know at #{Rainforest.support_email}."
+      end
+
+      return ApiConnectionError.new(msg, self)
+    end
+
+    # Handle a few common cases.
+    def error_with_response(error)
+      case @response_code
+      when 400, 404
+        return ApiError.new(@response_body || "Invalid request. Please check the URL and parameters.", self)
+      when 401
+        return AuthenticationError.new(@response_body || "Authentication failed.", self)
+      else
+        return ApiError.new(@response_body || "An error occured while making the API call.", self)
+      end
+    end
+
+  end
+end

data/lib/rainforest/apibits/api_object.rb

@@ -0,0 +1,52 @@
+module Rainforest
+  class ApiObject
+    include Enumerable
+    attr_reader :json
+
+    def self.construct(json)
+      if json.is_a?(Array)
+        return json.map{ |a| ApiObject.construct(a) }
+      elsif json.is_a?(Hash)
+        return ApiObject.new(json)
+      else
+        return json
+      end
+    end
+
+    def initialize(json=nil)
+      refresh_from(json)
+    end
+
+    def refresh_from(json={})
+      @json = Util.sorta_deep_clone(json)
+      @json.each do |k, v|
+        @json[k] = ApiObject.construct(v)
+      end
+      self
+    end
+
+    def inspect
+      @json.inspect
+    end
+
+    def to_json(*args)
+      JSON.generate(@json)
+    end
+
+    def method_missing(name, *args, &blk)
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        @json[attr] = args[0]
+      else
+        if @json.respond_to?(name)
+          @json.send(name, *args, &blk)
+        elsif @json.has_key?(name.to_sym)
+          return @json[name.to_sym]
+        else
+          super
+        end
+      end
+    end
+
+  end
+end

data/lib/rainforest/apibits/api_resource.rb

@@ -0,0 +1,153 @@
+module Rainforest
+  class ApiResource
+    attr_reader :api_method
+    attr_reader :json
+    attr_reader :client
+
+    def initialize(json=nil, api_method=nil, client=nil)
+      refresh_from(json, api_method, client)
+    end
+
+    def refresh_from(json={}, api_method=nil, client=nil)
+      unless json.is_a?(Hash)
+        json = { :id => json }
+      end
+      json = Util.symbolize_keys(json)
+
+      # Clear or write over any old data
+      clear_api_attributes
+      @api_method = api_method
+      @json = Util.sorta_deep_clone(json)
+      @client = client || Rainforest.default_client
+
+      # Use json (not the @json, the cloned copy)
+      json.each do |k, v|
+        unless self.class.api_attribute_names.include?(k.to_sym)
+          self.class.add_api_attribute(k.to_sym)
+        end
+        instance_variable_set("@#{k}", determine_api_attribute_value(k, v))
+      end
+      self
+    end
+
+    # Returns the default client
+    def self.client
+      Rainforest.default_client
+    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}> Attributes: " + JSON.pretty_generate(inspect_api_attributes)
+    end
+
+    def inspect_nested
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}>"
+    end
+
+    def to_json(*args)
+      JSON.generate(api_attributes)
+    end
+
+    def self.api_attribute_names
+      @api_attributes.map(&:first)
+    end
+
+    def self.editable_api_attribute_names
+      @api_attributes.select do |k, v|
+        v[:editable]
+      end.map(&:first)
+    end
+
+    def self.add_api_attribute(name)
+      attr_accessor name.to_sym
+      @api_attributes[name.to_sym] = {}
+    end
+
+    def api_attributes
+      ret = {}
+      self.class.api_attribute_names.each do |attribute|
+        ret[attribute] = self.send(attribute)
+      end
+      ret
+    end
+
+    def inspect_api_attributes
+      ret = {}
+      api_attributes.each do |k, v|
+        if v.is_a?(ApiResource)
+          ret[k] = v.inspect_nested
+        else
+          ret[k] = v
+        end
+      end
+      ret
+    end
+
+    # TODO(joncalhoun): Fix this (not currently working as intended)
+    def changed_api_attributes
+      ret = {}
+      self.api_attributes.each do |name, value|
+        if @json[name] != value
+          ret[name] = value
+        end
+      end
+      ret
+    end
+
+    def editable_api_attributes
+      ret = {}
+      self.class.editable_api_attribute_names.each do |name|
+        ret[name] = self.send(name)
+      end
+      ret
+    end
+
+    def clear_api_attributes
+      self.class.api_attribute_names.each do |name|
+        instance_variable_set("@#{name}", nil)
+      end
+    end
+
+    def self.determine_api_attribute_value(name, raw_value)
+      if @api_attributes[name] && @api_attributes[name].has_key?(:constructor)
+        klass = Util.constantize(@api_attributes[name][:constructor])
+        if(klass.respond_to?(:construct))
+          klass.construct(raw_value)
+        else
+          klass.new(raw_value)
+        end
+      else
+        ApiObject.construct(raw_value)
+      end
+    end
+
+    def determine_api_attribute_value(name, raw_value)
+      self.class.determine_api_attribute_value(name, raw_value)
+    end
+
+
+    def self.api_subclasses
+      return @api_subclasses ||= Set.new
+    end
+
+    def self.api_subclass_fetch(name)
+      @api_subclasses_hash ||= {}
+      if @api_subclasses_hash.has_key?(name)
+        @api_subclasses_hash[name]
+      end
+    end
+
+    def self.register_api_subclass(subclass, name=nil)
+      @api_subclasses ||= Set.new
+      @api_subclasses << subclass
+
+      unless name.nil?
+        @api_subclasses_hash ||= {}
+        @api_subclasses_hash[name] = subclass
+      end
+    end
+
+    @api_attributes = {}
+  end
+end

data/lib/rainforest/apibits/headers_builder.rb

@@ -0,0 +1,47 @@
+module Rainforest
+  module HeadersBuilder
+
+    def self.build(headers)
+      headers ||= {}
+      default_headers.merge(headers)
+    end
+
+    def self.default_headers
+      headers = {
+        :user_agent => "Rainforest/#{Rainforest.api_version} RubyBindings/#{Rainforest::VERSION}",
+      }
+
+      begin
+        headers.update({
+          :x_rainforest_client_user_agent => JSON.generate(user_agent)
+        })
+      rescue => e
+        headers.update({
+          :x_rainforest_client_raw_user_agent => user_agent.inspect,
+          :error => "#{e} (#{e.class})"
+        })
+      end
+      headers
+    end
+
+    def self.user_agent
+      lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+      {
+        :bindings_version => Rainforest::VERSION,
+        :lang => 'ruby',
+        :lang_version => lang_version,
+        :platform => RUBY_PLATFORM,
+        :publisher => 'rainforest',
+        :uname => get_uname
+      }
+    end
+
+    def self.get_uname
+      `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+    rescue Errno::ENOMEM => ex # couldn't create subprocess
+      "uname lookup failed"
+    end
+
+  end
+end