api_resource 0.5.1 → 0.6.0

data/lib/api_resource/typecasters/array_typecaster.rb

@@ -0,0 +1,19 @@
+module ApiResource
+
+  module Typecast
+
+    module ArrayTypecaster
+
+      def self.from_api(value)
+        return Array.wrap(value)
+      end
+
+      def self.to_api(value)
+        return Array.wrap(value)
+      end
+
+    end
+
+  end
+
+end

data/lib/api_resource/typecasters/boolean_typecaster.rb

@@ -0,0 +1,22 @@
+module ApiResource
+
+  module Typecast
+
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
+    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+
+    module BooleanTypecaster
+
+      def self.from_api(value)
+        TRUE_VALUES.include?(value)
+      end
+
+      def self.to_api(value)
+        value
+      end
+
+    end
+
+  end
+
+end

data/lib/api_resource/typecasters/date_typecaster.rb

@@ -0,0 +1,35 @@
+module ApiResource
+
+  module Typecast
+
+    ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+
+    module DateTypecaster
+
+      def self.from_api(value)
+        return value if value.is_a?(Date)
+
+        value = value.to_s
+        if value =~ ApiResource::Typecast::ISO_DATE
+          return self.new_date($1.to_i, $2.to_i, $3.to_i)
+        end
+
+        self.new_date(*::Date._parse(value, false).values_at(:year, :mon, :mday))
+      end
+
+      def self.to_api(value)
+        return value.to_s
+      end
+
+      protected
+
+      def self.new_date(year, month, day)
+        return nil unless year && year != 0
+        return Date.new(year, month, day) rescue nil
+      end
+
+    end
+
+  end
+
+end

data/lib/api_resource/typecasters/float_typecaster.rb

@@ -0,0 +1,22 @@
+module ApiResource
+
+  module Typecast
+
+    module FloatTypecaster
+
+      def self.from_api(value)
+        return value.to_f if value.respond_to?(:to_f)
+        # Special case for true to return 1.0
+        return 1.0 if value.class == TrueClass
+        return value.to_s.to_f
+      end
+
+      def self.to_api(value)
+        value
+      end
+
+    end
+
+  end
+
+end

data/lib/api_resource/typecasters/integer_typecaster.rb

@@ -0,0 +1,22 @@
+module ApiResource
+
+  module Typecast
+
+    module IntegerTypecaster
+
+      def self.from_api(value)
+        return value.to_i if value.respond_to?(:to_i)
+        # Special case so that true typecasts to 1
+        return 1 if value.class == TrueClass
+        return value.to_s.to_i
+      end
+
+      def self.to_api(value)
+        value
+      end
+
+    end
+
+  end
+
+end

data/lib/api_resource/typecasters/string_typecaster.rb

@@ -0,0 +1,19 @@
+module ApiResource
+
+  module Typecast
+
+    module StringTypecaster
+
+      def self.from_api(value)
+        return value.to_s
+      end
+
+      def self.to_api(value)
+        return value
+      end
+
+    end
+
+  end
+
+end

data/lib/api_resource/typecasters/time_typecaster.rb

@@ -0,0 +1,44 @@
+require 'active_support/time'
+
+module ApiResource
+
+  module Typecast
+
+    ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+
+    module TimeTypecaster
+
+      def self.from_api(value)
+        return value if value.is_a?(Time)
+        value = value.to_s
+        return nil if value.empty?
+
+        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)
+        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))
+
+      end
+
+      def self.to_api(value)
+        return value.to_s
+      end
+
+      protected
+
+      def self.new_time(*args)
+        year = args.first
+        return nil if year.nil? || year == 0
+        Time.utc(*args) rescue nil
+      end
+
+    end
+
+  end
+
+end

data/lib/api_resource/version.rb

@@ -0,0 +1,3 @@
+module ApiResource
+  VERSION = "0.6.0"
+end

data/spec/lib/api_resource_spec.rb

@@ -4,6 +4,12 @@ describe ApiResource do
 
   context ".cache" do
 
+    before(:each) do
+      if defined?(Rails)
+        Object.send(:remove_const, :Rails)
+      end
+    end
+
     after(:each) do
       if defined?(Rails)
         Object.send(:remove_const, :Rails)

data/spec/lib/associations/association_scope_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ApiResource::Associations::AssociationScope do
+describe ApiResource::Associations::AssociationProxy do
 
   before(:all) do
     TestResource.reload_resource_definition

data/spec/lib/associations_spec.rb

@@ -81,6 +81,13 @@ describe "Associations" do
       TestResource.association_class_name(:strange_name).should eql("BelongsToObject")
     end
 
+    it "should be able to return the name of the foreign key field field for the association" do
+      TestResource.belongs_to :belongs_to_object
+      TestResource.has_many :has_many_objects
+      TestResource.association_foreign_key_field(:belongs_to_object).should eql(:belongs_to_object_id)
+      TestResource.association_foreign_key_field(:has_many_objects).should eql(:has_many_object_ids)
+    end
+
     it "should only define relationships for the given class - they should not cascade" do
       TestResource.belongs_to :belongs_to_object
       AnotherTestResource.association?(:belongs_to_object).should_not be_true
@@ -338,38 +345,6 @@ describe "Associations" do
         end
       end
 
-      context "Defining scopes" do
-
-        it "should identify known scopes based on the scopes defined on 
-          the object it is a proxy to" do
-          
-          TestResource.scope :class_scope, "class_scope" => "true"
-          
-          ap = Associations::MultiObjectProxy.new(
-            "TestResource",
-            BelongsToObject.new,
-            [{:service_uri => "/route"}]
-          )
-          ap.scope?(:class_scope).should be_true
-        end
-
-        it "scopes in the response should shadow class defined scopes" do
-          TestResource.scope(:scope1, "scope1" => "true")
-          ap = Associations::MultiObjectProxy.new(
-            "TestResource",
-            BelongsToObject.new,
-            [
-              {
-                :service_uri => "/route", 
-                :scope1 => {"scope1" => true}, 
-                :scope2 => {"scope2" => true}
-              }
-            ]
-          )
-          ap.scopes[:scope1].should eql({"scope1" => true})
-        end
-      end
-
     end
 
     describe "Selecting scopes" do
@@ -421,6 +396,12 @@ describe "Associations" do
 
   describe "Loading and Caching loaded data" do
 
+
+    before(:each) do
+      # Clear the cache to prevent any funny business
+      ApiResource.cache(true)
+    end
+
     context "Single Object" do
 
       before(:all) do
@@ -460,9 +441,8 @@ describe "Associations" do
         ap.active.expires_in(30).internal_object
 
         # should only be called once
-        TestResource.connection.expects(:get).never
+        TestResource.connection.expects(:request).never
         ap.active.expires_in(30).internal_object
-        ap.should be_loaded
       end
 
       it "should check that ttl matches the expiration parameter" do
@@ -545,19 +525,6 @@ describe "Associations" do
       ap.first.name.should eql old_name
     end
 
-    it "should propagate the scopes from the associated class" do
-
-      ap = Associations::MultiObjectProxy.new(
-        "TestResource", 
-        BelongsToObject.new, {
-          :service_uri => '/multi_object_association'
-        }
-      )
-      ap.scopes.should eql(TestResource.scopes)
-      true
-    end
-
-
     context "Multi Object" do
 
       it "should be able to load 'all'" do
@@ -642,13 +609,13 @@ describe "Associations" do
         end
       end
 
-      it "should return a ResourceScope when calling any scope on a class" do
-        TestResource.send(TestResource.scopes.first.first.to_sym).should be_a Associations::ResourceScope
+      it "should return a ScopeCondition when calling any scope on a class" do
+        TestResource.send(TestResource.scopes.first.first.to_sym).should be_a Conditions::ScopeCondition
       end
 
       it "should be able to chain scopes" do
         scp = TestResource.active.paginate(20, 1)
-        scp.should be_a Associations::Scope
+        scp.should be_a Conditions::ScopeCondition
         scp.to_query.should eql(
           "active=true&paginate[current_page]=1&paginate[per_page]=20"
         )

data/spec/lib/base_spec.rb

@@ -38,6 +38,27 @@ describe "Base" do
 
   end
 
+  context ".load_resource_definition" do
+
+    it "should not inherit from unrelated objects" do
+
+      ErrorResource.new
+      orig_public_attr_names = ErrorResource.public_attribute_names
+      orig_protected_attr_names = ErrorResource.protected_attribute_names
+      
+      TestResource.new
+
+      ErrorResource.public_attribute_names.should eql(
+        orig_public_attr_names
+      )
+      ErrorResource.protected_attribute_names.should eql(
+        orig_protected_attr_names
+      )
+      true
+    end
+
+  end
+
   context "Comparison" do
 
     context "&group_by" do
@@ -516,6 +537,7 @@ describe "Base" do
     context "Updating old records" do
       before(:all) do
         TestResource.reload_resource_definition
+        HasOneObject.reload_resource_definition
         TestResource.has_many :has_many_objects
         RestClient::Payload.stubs(:has_file? => false)
       end

data/spec/lib/conditions/abstract_conditions_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe "Conditions" do
+
+	before(:each) do
+		TestResource.reload_resource_definition
+	end
+
+	it "should chain scopes onto the base class" do
+
+		obj = TestResource.active
+		obj.should be_a ApiResource::Conditions::ScopeCondition
+
+		obj2 = TestResource.paginate
+
+		TestResource.expects(:paginate).returns(obj2)
+
+		obj3 = obj.paginate
+
+		obj3.to_query.should eql("active=true&paginate=true")
+		obj3.should_not be_eager_load
+		obj3.should_not be_blank_conditions
+		# Make sure that it clones
+
+		obj3.object_id.should_not eql(obj.object_id)
+		obj3.object_id.should_not eql(obj2.object_id)
+	end
+
+	it "should properly deal with calling includes" do
+		obj = TestResource.includes(:has_many_objects).active
+
+		obj.should be_eager_load
+		obj.should_not be_blank_conditions
+		obj.association.should be_nil
+		obj.to_query.should eql("active=true")
+		obj.included_objects.should eql([:has_many_objects])
+	end
+
+	it "should be able to chain includes and scopes" do
+		obj = TestResource.includes(:has_many_objects).active.includes(:belongs_to_object)
+
+		obj.should be_eager_load
+		obj.should_not be_blank_conditions
+		obj.included_objects.should eql([:has_many_objects, :belongs_to_object])
+	end
+
+	it "should be able to include multiple includes in the same call" do
+		obj = TestResource.includes(:has_many_objects, :belongs_to_object)
+
+		obj.should be_eager_load
+		obj.should be_blank_conditions
+		obj.included_objects.should eql([:has_many_objects, :belongs_to_object])
+	end
+
+	it "should raise an error if given an include that isn't a valid association" do
+		lambda {
+			TestResource.includes(:fake_assoc)
+		}.should raise_error
+	end
+
+	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(:find => [1]))
+		obj.internal_object.should eql([1])
+		obj.all.should eql([1])
+		obj.first.should eql(1)
+	end
+
+	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(:find => [1,2]))
+
+		obj.collect{|o| o * 2}.should eql([2,4])
+	end
+
+end