api_resource 0.6.21 → 0.6.22

data/lib/api_resource/response.rb

@@ -0,0 +1,108 @@
+module ApiResource
+  class Response
+
+    attr_accessor :body
+    attr_reader :headers
+
+    # explicit delegate for things we define
+    delegate(
+      :as_json,
+      :blank?,
+      :inspect,
+      :to_s,
+      to: :body
+    )
+
+    #
+    # Constructor
+    #
+    # @param  response [HttpClient::Response]
+    # @param  format [ApiResource::Format] Decoder
+    #
+    def initialize(response)
+      @body = self.parse_body(response)
+      @headers = response.try(:headers) || {}
+    end
+
+    #
+    # We typically treat the response as just a wrapper for an
+    # Array or a Hash and use is_a? to determine what kind of response
+    # we have.  So to keep that consistent, #is_a? returns true if the
+    # body is a descendant of the class as well
+    #
+    # @param  klass [Class]
+    #
+    # @return [Boolean]
+    def is_a?(klass)
+      super || @body.is_a?(klass)
+    end
+
+    #
+    # Implementation of marshal_dump
+    #
+    # @return [Array<Hash>] The data to dump
+    def marshal_dump
+      [@body, @headers]
+    end
+
+    #
+    # Implementation of marshal load
+    # @param  args [Array] Array of dumped data
+    #
+    # @return [Response] New instance
+    def marshal_load(args)
+      @body, @headers = args
+      self
+    end
+
+
+    #
+    # Return ourself cloned with the body wrapped as an array
+    #
+    # @example
+    #   resp = ApiResource::Response.new(response, format)
+    #   resp.body # => {'a' => 'b'}
+    #
+    #   array = Array.wrap(resp)
+    #   array.body # => [{'a' => 'b'}]
+    #
+    #   array.response == resp.response # true!
+    #
+    # @return [ApiResource::Response]
+    def to_ary
+      klone = self.dup
+      klone.body = Array.wrap(self.body)
+      klone
+    end
+
+    protected
+
+    #
+    # Proxy method missing to the body
+    #
+    # @param  meth [Symbol] Method called
+    # @param  *args [Array<Mixed>] Args passed
+    # @param  &block [Proc] Block passed
+    #
+    # @return [Mixed]
+    def method_missing(meth, *args, &block)
+      @body.__send__(meth, *args, &block)
+    end
+
+    #
+    # Handle parsing of the body.  Returns a blank Hash if
+    # no body is present
+    #
+    # @param  response [HttpClient::Response]
+    #
+    # @return [Hash, Array<Hash>] Parsed response
+    def parse_body(response)
+      if response.try(:body).present?
+        return ApiResource.format.decode(response.body)
+      else
+        return {}
+      end
+    end
+
+  end
+end

data/lib/api_resource/scopes.rb

@@ -6,6 +6,7 @@ module ApiResource
     module ClassMethods
       # TODO: calling these methods should force loading of the resource definition
       def scopes
+        self.reload_resource_definition
         return self.related_objects[:scopes]
       end
 
@@ -68,7 +69,7 @@ module ApiResource
         end
       end
 
-      # 
+      #
       # Apply scopes from params based on our resource
       # definition
       #
@@ -90,20 +91,53 @@ module ApiResource
         return base
       end
 
+      #
+      # Add our dynamic scopes based on a set of params
+      #
+      # @param  params [Hash] User-supplied params
+      # @param  base [ApiResource::Conditions::AbstractCondition, Class] Base
+      # Scope
+      #
+      # @return [ApiResource::Conditions::AbstractCondition] [description]
       def add_dynamic_scopes(params, base)
         self.dynamic_scopes.each_pair do |name, args|
-          next if params[name].blank?
+          # make sure we have all required arguments
+          next unless self.check_required_scope_args(args, params[name])
+
+          # the args we will apply
           caller_args = []
-          args.each_pair do |subkey, type|
-            if type == :req || params[name][subkey].present?
-              caller_args << params[name][subkey]
+
+          # iterate through our args and add them to an array to send to our
+          # scope
+          args.keys.each do |subkey|
+            # we only apply things that are present or explicitly false
+            if val = self.get_scope_arg_value(subkey, params[name][subkey])
+              caller_args << val
             end
           end
+          # call our scope with the supplied args
           base = base.send(name, *caller_args)
         end
         return base
       end
 
+      #
+      # Check if we have supplied all of the necessary
+      # @param  scope [Hash] [Scope Definition
+      # @param  params [Hash] [Supplied params]
+      #
+      # @return [Boolean] Validity
+      def check_required_scope_args(scope, params)
+        # make sure we have a hash and it has values
+        return false unless params.is_a?(Hash) && params.present?
+        # find required values
+        required = scope.select{ |k,v| v.to_sym == :req }.keys
+        # make sure we have all of the required values, we allow false
+        required.all? { |key|
+          params[key].present? || params[key] == false
+        }
+      end
+
       #
       # Wrapper method to define all scopes from the resource definition
       #
@@ -117,10 +151,33 @@ module ApiResource
         true
       end
 
+      #
+      # Scopes that require arguments
+      #
+      # @return [Hash]
       def dynamic_scopes
         self.scopes.select { |name, args| args.present? }
       end
 
+      #
+      # Get the parsed/formatted arguments to send to the server
+      #
+      # @param  key [String, Symbol] Key name for the scope value
+      # @param  value [String, Integer, Symbol] Value for the scope
+      #
+      # @return [String, Integer, Symbol, Date] Parsed/formatted value
+      def get_scope_arg_value(key, value)
+        # cast to string to avoid incorred blank? behavior for us
+        return "false" if value == false
+        # if we havea date field, try to parse, falling back to the original
+        # value
+        if key.to_s =~ /date/
+          value = Date.parse(value) rescue value
+        end
+        # return the final value
+        value
+      end
+
       def static_scopes
         self.scopes.select { |name, args| args.blank? }.keys
       end

data/lib/api_resource/serializer.rb

@@ -151,7 +151,7 @@ module ApiResource
       # or if the attribute has changed to nil
       return true if self.record.changes[key].present?
       # make sure our value isn't blank
-      return val.present?
+      return !val.nil?
     end
 
     #

data/lib/api_resource/typecasters/boolean_typecaster.rb

@@ -8,6 +8,7 @@ module ApiResource
     module BooleanTypecaster
 
       def self.from_api(value)
+        return nil if value.nil?
         TRUE_VALUES.include?(value)
       end
 

data/lib/api_resource/typecasters/integer_typecaster.rb

@@ -7,6 +7,7 @@ module ApiResource
       def self.from_api(value)
         return 0 if value == false
         return 1 if value == true
+        return nil if value.nil?
         return nil if value.is_a?(String) && value.blank?
         return value.to_i if value.respond_to?(:to_i)
         return value.to_s.to_i

data/lib/api_resource/typecasters/time_typecaster.rb

@@ -15,13 +15,17 @@ module ApiResource
 
         if value =~ ApiResource::Typecast::ISO_DATETIME
           micro = ($7.to_f * 1_000_000).to_i
-          return self.new_time($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, micro)
+          return self.new_time(false, $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, micro)
         end
 
         time_info = Date._parse(value)
         time_info[:micro] = ((time_info[:sec_fraction].to_f % 1) * 1_000_000).to_i
 
-        new_time(*time_info.values_at(:year, :mon, :mday, :hour, :min, :sec, :micro))
+        if time_info[:zone].present?
+          new_time(true, *time_info.values_at(:year, :mon, :mday, :hour, :min, :sec, :zone))
+        else
+          new_time(false, *time_info.values_at(:year, :mon, :mday, :hour, :min, :sec, :micro))
+        end
 
       end
 
@@ -31,10 +35,14 @@ module ApiResource
 
       protected
 
-      def self.new_time(*args)
+      def self.new_time(use_zone, *args)
         year = args.first
         return nil if year.nil? || year == 0
-        Time.utc(*args) rescue nil
+        if use_zone
+          Time.new(*args).utc rescue nil
+        else
+          Time.utc(*args) rescue nil
+        end
       end
 
     end

data/lib/api_resource/version.rb

@@ -1,3 +1,3 @@
 module ApiResource
-  VERSION = "0.6.21"
+  VERSION = "0.6.22"
 end

data/lib/api_resource.rb

@@ -33,6 +33,7 @@ module ApiResource
   autoload :Mocks
   autoload :ModelErrors
   autoload :Observing
+  autoload :Response
   autoload :Scopes
   autoload :Serializer
   autoload :Typecast

data/spec/lib/associations/has_one_remote_object_proxy_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module ApiResource
   module Associations
-    
+
     describe HasOneRemoteObjectProxy do
 
       before(:all) do
@@ -10,12 +10,12 @@ module ApiResource
       end
 
       context "#load" do
-        
+
         it "correctly loads data from an endpoint that returns
           a single record" do
-          
+
           tr = TestResource.new(
-            :has_one_object => {:service_uri => "/has_one_objects/1.json"} 
+            :has_one_object => {:service_uri => "/has_one_objects/1.json"}
           )
           tr.has_one_object.internal_object.should be_instance_of(
             HasOneObject

data/spec/lib/associations_spec.rb

@@ -604,10 +604,10 @@ describe "Associations" do
       end
 
       it "should be able to chain scopes" do
-        scp = TestResource.active.paginate(20, 1)
+        scp = TestResource.active.boolean(20, 1)
         scp.should be_a Conditions::ScopeCondition
         scp.to_query.should eql(
-          "active=true&paginate[current_page]=1&paginate[per_page]=20"
+          "active=true&boolean[a]=20&boolean[b]=1"
         )
       end
 
@@ -789,7 +789,7 @@ describe "Associations" do
           end
         end
         context "Belongs To" do
-          before(:all) do 
+          before(:all) do
             TestAR.class_eval do
               belongs_to_remote :test_resource
             end

data/spec/lib/attributes_spec.rb

@@ -70,7 +70,7 @@ describe "Attributes" do
 
       it "should be able to determine scopes when the class loads" do
         tst = TestResource.new
-        tst.scope?(:paginate).should be_true
+        tst.scope?(:boolean).should be_true
         tst.scope?(:active).should be_true
       end
 
@@ -104,6 +104,21 @@ describe "Attributes" do
 
         tst.attr5.should eql("attr5")
       end
+
+      context '#password' do
+
+        it 'is able to define password even though it is a
+          class attribute' do
+
+          TestResource.define_attributes :password
+
+          resource = TestResource.new(password: '123456')
+          expect(resource.password).to eql('123456')
+
+        end
+
+      end
+
     end
 
     it "should define methods for testing for reading and writing known attributes" do

data/spec/lib/base_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 require 'json'
 
 include ApiResource
@@ -93,6 +93,8 @@ describe "Base" do
         self.prefix = "/path/to/nested/:id/"
       end
 
+      ChildResource = Class.new(PrefixResource)
+
     end
 
 
@@ -108,6 +110,43 @@ describe "Base" do
       )
     end
 
+    it "appends its type in the query string if it is not a direct
+      descendant of ApiResource::Base" do
+
+      expect(ChildResource.new_element_path).to eql(
+        "/path/to/project/prefix_resources/new.json?type=ChildResource"
+      )
+
+    end
+
+  end
+
+  context "#id" do
+
+    it 'should have a blank id on initialize' do
+      expect(TestResource.new.id).to be_nil
+    end
+
+  end
+
+  context '#new_record?' do
+
+    it 'is a new record on initialize' do
+      expect(TestResource.new).to be_new_record
+    end
+
+  end
+
+  context '#to_key' do
+
+    it 'is the primary key of the record' do
+      expect(TestResource.find(3).to_key).to eq([3])
+    end
+
+    it 'is nil if the record is not persisted' do
+      expect(TestResource.new.to_key).to be_nil
+    end
+
   end
 
   context "Prefixes" do
@@ -127,11 +166,9 @@ describe "Base" do
 
         TestResource.connection.expects(:post).with(
           "/belongs_to_objects/22/test_resources.json",
-          {
-            test_resource: {
-              'name' => 'Dan'
-            }
-          },
+          has_entries({
+            test_resource: is_a(Hash)
+          }),
           TestResource.headers
         )
 
@@ -172,6 +209,53 @@ describe "Base" do
 
   end
 
+  context "Saving with file upload" do
+
+    before(:all) do
+      TestResource.reload_resource_definition
+    end
+
+    after(:all) do
+      TestResource.reload_resource_definition
+    end
+
+    let(:uploaded_file){
+      ActionDispatch::Http::UploadedFile.new(
+        tempfile: File.new(
+          File.expand_path("../../support/files/bg-awesome.jpg", __FILE__)
+        )
+      )
+    }
+
+    context "#save" do
+
+      it 'sends the file to HTTPClient' do
+
+        TestResource.define_attributes :image_file
+
+        TestResource.connection.expects(:request)
+          .with(
+            :post,
+            instance_of(String),
+            has_entries(
+              test_resource: has_entries(
+                'image_file' => instance_of(File)
+              )
+            ),
+            instance_of(Hash)
+          )
+
+        test_resource = TestResource.new(
+          image_file: uploaded_file
+        )
+        test_resource.save
+
+      end
+
+    end
+
+  end
+
 
   describe "Loading data from a hash" do
 
@@ -445,19 +529,23 @@ describe "Base" do
       context("Override create to return the json") do
 
 
-        it "should be able to include associations when saving if they are specified" do
+        it "should be able to include associations when saving if
+          they are specified" do
           ApiResource::Connection.any_instance.expects(:post).with(
             "/test_resources.json",
-            {
-              test_resource: {
-                'name' => 'Ethan',
-                'age' => 20
-              }
-            },
+            has_entries({
+              test_resource: has_entries({
+                'has_many_objects' => [{}]
+              })
+            }),
             TestResource.headers
           )
 
-          tr = TestResource.build(name: "Ethan", age: 20)
+          tr = TestResource.build(
+            name: "Ethan",
+            age: 20,
+            has_many_objects: [HasManyObject.new]
+          )
           tr.save
         end
 
@@ -467,7 +555,8 @@ describe "Base" do
             "/test_resources.json",
             {
               test_resource: {
-                'name' => 'Ethan'
+                'name' => 'Ethan',
+                'roles' => []
               }
             },
             TestResource.headers
@@ -477,13 +566,15 @@ describe "Base" do
           tr.save
         end
 
-        it "should include false attributes when creating by default" do
+        it "should include false and empty attributes when creating
+          by default" do
           ApiResource::Connection.any_instance.expects(:post).with(
             "/test_resources.json",
             {
               test_resource: {
                 'name' => 'Ethan',
-                'is_active' => false
+                'is_active' => false,
+                'roles' => []
               }
             },
             TestResource.headers
@@ -500,6 +591,7 @@ describe "Base" do
             {
               test_resource: {
                 'name' => 'Ethan',
+                'roles' => [],
                 'has_one_object' => {
                   'size' => 'large'
                 }
@@ -514,15 +606,15 @@ describe "Base" do
         end
 
 
-        it "should include nil attributes if they are passed in through the include_extras" do
+        it "should include nil attributes if they are passed in through
+          the include_extras" do
           ApiResource::Connection.any_instance.expects(:post).with(
             "/test_resources.json",
-            {
-              test_resource: {
-                'name' => 'Ethan',
+            has_entries({
+              test_resource: has_entries({
                 'age' => nil
-              }
-            },
+              })
+            }),
             TestResource.headers
           )
 
@@ -904,7 +996,7 @@ describe "Base" do
 
         begin
           initial = ApiResource::Base.ttl
-          ApiResource::Base.ttl = 1
+          ApiResource::Base.ttl = 50
           if defined?(Rails)
             Object.send(:remove_const, :Rails)
           end
@@ -914,23 +1006,13 @@ describe "Base" do
         end
 
       end
-
-      it "should implement caching using the ttl setting" do
-        cache = mock(fetch: {id: 123, name: "Dan"})
-        ApiResource.stubs(cache: cache)
-        TestResource.find(123)
+      # @todo This doesn't exactly test the cache, but stubbing is really
+      # difficult when everything uses the cache
+      it 'should work with the real cache' do
+        tr = TestResource.find(1, expires_in: 200)
+        expect(tr).to eql(TestResource.find(1, expires_in: 200))
       end
 
-      it "should find with expires_in and cache" do
-        ApiResource.cache.expects(:fetch)
-          .with(anything, expires_in: 10.0)
-          .returns({id: 2, name: "d"})
-
-        res = TestResource.find("adfa", expires_in: 10)
-
-        ApiResource::Base.ttl.should eql(1)
-        res.id.to_i.should eql(2)
-      end
     end
 
   end

data/spec/lib/conditions/{abstract_conditions_spec.rb → abstract_condition_spec.rb}

@@ -17,7 +17,7 @@ describe "Conditions" do
 
 		obj3 = obj.paginate
 
-		obj3.to_query.should eql("active=true&paginate=true")
+		obj3.to_query.should eql("active=true&page=1&per_page=10")
 		obj3.should_not be_eager_load
 		obj3.should_not be_blank_conditions
 		# Make sure that it clones
@@ -61,25 +61,37 @@ describe "Conditions" do
 	it "should create a resource finder when forced to load, and cache the result" do
 		obj = TestResource.includes(:has_many_objects)
 
-		ApiResource::Finders::ResourceFinder.expects(:new).with(TestResource, obj).returns(mock(:load => [1]))
-		obj.internal_object.should eql([1])
-		obj.all.should eql([1])
+		resource_finder_mock = mock(load: [1], first: 1)
+
+		ApiResource::Finders::ResourceFinder.expects(:new)
+			.with(TestResource, obj)
+			.returns(resource_finder_mock)
+
+		obj.internal_object.should eql(resource_finder_mock)
+		obj.all.should eql(resource_finder_mock)
 		obj.first.should eql(1)
 	end
 
-	it "should proxy calls to enumerable and array methods to the loaded object" do
+	it "should proxy calls to enumerable and array methods to the loaded
+		object" do
+
 		obj = TestResource.includes(:has_many_objects)
 
-		ApiResource::Finders::ResourceFinder.expects(:new).with(TestResource, obj).returns(mock(:load => [1,2]))
+		# this just needs to call each
+		resource_finder_mock = mock(load: true, each: true)
+
+		ApiResource::Finders::ResourceFinder.expects(:new)
+			.with(TestResource, obj)
+			.returns(resource_finder_mock)
 
-		obj.collect{|o| o * 2}.should eql([2,4])
+		obj.collect{|o| o * 2}.should eql([])
 	end
 
 	it "should not typecast nil and false to true when creating condition hashes" do
-		obj = TestResource.paginate(false, nil)
-		hsh = obj.to_hash["paginate"]
-		hsh["per_page"].should eql(false)
-		hsh.should be_key(:current_page)
+		obj = TestResource.boolean(false, nil)
+		hsh = obj.to_hash["boolean"]
+		hsh["a"].should eql(false)
+		hsh.should be_key(:b)
 	end
 
 end