rainforest 1.0.1

data/lib/rainforest/errors/rainforest_error.rb

@@ -0,0 +1,20 @@
+module Rainforest
+  class RainforestError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :json_body
+
+    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = json_body
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+end

data/lib/rainforest/json.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,168 @@
+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)
+      # Wipe old state before setting new.  This is useful for e.g. updating a
+      # customer, where there is no persistent card parameter.  Mark those values
+      # which don't persist as transient
+
+      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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,20 @@
+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/test.rb

@@ -0,0 +1,14 @@
+module Rainforest
+  class Test < APIResource
+    include Rainforest::APIOperations::Create
+    include Rainforest::APIOperations::Delete
+    include Rainforest::APIOperations::Update
+    include Rainforest::APIOperations::List
+
+    def self.tags(filters={}, api_key=nil)
+      response, api_key = Rainforest.request(:get, url + "/tags", api_key, filters)
+      response
+    end
+
+  end
+end

data/lib/rainforest/util.rb

@@ -0,0 +1,101 @@
+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 ||= {
+        'test' => Test,
+        '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, klass = nil)
+      case resp
+      when Array
+        resp.map { |i| convert_to_rainforest_object(i, api_key, klass) }
+      when Hash
+        # Try converting to a known object class.  If none available, fall back to generic RainforestObject
+        object_classes.fetch(klass || 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

data/lib/rainforest/version.rb

@@ -0,0 +1,3 @@
+module Rainforest
+  VERSION = File.open(File.expand_path("../../../VERSION", __FILE__)).read()
+end

data/rainforest.gemspec

@@ -0,0 +1,26 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rainforest/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'rainforest'
+  s.version = Rainforest::VERSION
+  s.summary = 'Ruby bindings for the Rainforest API'
+  s.description = 'Rainforest allows you to create tests for your website in plain English, then run them across all major browsers with a single click.  See https://www.rainforestqa.com/ for details.'
+  s.authors = ['Jon Calhon']
+  s.email = ['joncalhoun@gmail.com']
+  s.homepage = 'https://app.rainforestqa.com/docs/ruby'
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('multi_json', '>= 1.0.4', '< 2')
+
+  s.add_development_dependency('mocha', '~> 0.13.2')
+  s.add_development_dependency('shoulda', '~> 3.4.0')
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rake')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/test/stripe/account_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Rainforest
+  class AccountTest < Test::Unit::TestCase
+    should "account should be retrievable" do
+      resp = {:email => "test+bindings@rainforest.com", :charge_enabled => false, :details_submitted => false}
+      @mock.expects(:get).once.returns(test_response(resp))
+      a = Rainforest::Account.retrieve
+      assert_equal "test+bindings@rainforest.com", a.email
+      assert !a.charge_enabled
+      assert !a.details_submitted
+    end
+  end
+end