old_api_resource 0.3.0

data/lib/old_api_resource/associations/multi_object_proxy.rb

@@ -0,0 +1,74 @@
+require 'old_api_resource/associations/association_proxy'
+
+module OldApiResource
+  
+  module Associations
+   
+      class MultiObjectProxy < AssociationProxy
+
+        include Enumerable
+
+        def all
+          self.internal_object
+        end
+
+        def each(*args, &block)
+          self.internal_object.each(*args, &block)
+        end
+
+        def serializable_hash(options)
+          self.internal_object.collect{|obj| obj.serializable_hash(options) }
+        end
+
+        # force a load when calling this method
+        def internal_object
+          @internal_object ||= self.load_scope_with_options(:all, {})
+        end
+        
+        def internal_object=(contents)
+          return @internal_object = contents if contents.all?{|o| o.is_a?(self.klass)}
+          return load(contents)
+        end
+
+        protected
+        def load_scope_with_options(scope, options)
+          scope = self.loaded_hash_key(scope.to_s, options)
+          return [] if self.remote_path.blank?
+          unless self.loaded[scope]
+            self.times_loaded += 1
+            self.loaded[scope] = self.klass.connection.get("#{self.remote_path}.#{self.klass.format.extension}?#{options.to_query}")
+          end
+          self.loaded[scope].collect{|item| self.klass.new(item)}
+        end
+
+        def load(contents)
+          # If we have a blank array or it's just nil then we should just return after setting internal_object to a blank array
+          @internal_object = [] and return nil if (contents.is_a?(Array) && contents.blank?) || contents.nil?
+          if contents.is_a?(Array) && contents.first.is_a?(Hash) && contents.first[self.class.remote_path_element]
+            settings = contents.slice!(0).with_indifferent_access
+          end
+
+          settings = contents if contents.is_a?(Hash)
+          settings ||= {}.with_indifferent_access
+
+          raise "Invalid response for multi object relationship: #{contents}" unless settings[self.class.remote_path_element] || contents.is_a?(Array)
+          self.remote_path = settings.delete(self.class.remote_path_element)
+
+          settings.each do |key, value|
+            raise "Expected the scope #{key} to point to a hash, to #{value}" unless value.is_a?(Hash)
+            self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
+              def #{key}(opts = {})
+                OldApiResource::Associations::RelationScope.new(self, :#{key}, opts)
+              end
+            EOE
+            self.scopes[key.to_s] = value
+          end
+
+          # Create the internal object
+          @internal_object = contents.is_a?(Array) ? contents.collect{|item| self.klass.new(item)} : nil
+        end
+      end
+    
+  end
+  
+end

data/lib/old_api_resource/associations/related_object_hash.rb

@@ -0,0 +1,12 @@
+module OldApiResource
+  module Associations 
+    # RelatedObjectHash, re-defines dup to be recursive
+    class RelatedObjectHash < HashWithIndifferentAccess
+      def dup
+        Marshal.load(Marshal.dump(self))
+      end
+      # use this behavior for clone too
+      alias_method :clone, :dup
+    end
+  end
+end

data/lib/old_api_resource/associations/relation_scope.rb

@@ -0,0 +1,24 @@
+require 'old_api_resource/associations/scope'
+
+module OldApiResource
+  
+  module Associations
+    
+    class RelationScope < Scope
+
+      def reload
+        remove_instance_variable(:@internal_object) if instance_variable_defined?(:@internal_object)
+        self.klass.reload(self.current_scope, self.scopes[self.current_scope])
+        self
+      end
+
+      # Use this method to access the internal data, this guarantees that loading only occurs once per object
+      def internal_object
+        @internal_object ||= self.klass.send(:load_scope_with_options, self.current_scope, self.scopes[self.current_scope])
+      end
+
+    end
+    
+  end
+  
+end

data/lib/old_api_resource/associations/resource_scope.rb

@@ -0,0 +1,25 @@
+require 'old_api_resource/associations/scope'
+
+module OldApiResource
+  
+  module Associations
+    
+    class ResourceScope < Scope
+      
+      include Enumerable
+
+      def internal_object
+        @internal_object ||= self.klass.send(:find, :all, :params => self.scopes[self.current_scope])
+      end
+      
+      alias_method :all, :internal_object
+      
+      def each(*args, &block)
+        self.internal_object.each(*args, &block)
+      end
+
+    end
+    
+  end
+  
+end

data/lib/old_api_resource/associations/scope.rb

@@ -0,0 +1,88 @@
+module OldApiResource
+  
+  module Associations
+    
+    class Scope
+
+      attr_accessor :klass, :current_scope, :internal_object
+
+      attr_reader :scopes
+
+      def initialize(klass, current_scope, opts)
+        # Holds onto the association proxy this RelationScope is bound to
+        @klass = klass
+        @current_scope = Array.wrap(current_scope.to_s)
+        # define methods for the scopes of the object
+
+        klass.scopes.each do |key, val|
+          self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
+            # This class always has at least one scope, adding a new one should clone this object
+            def #{key}(opts = {})
+              obj = self.clone
+              # Call reload to make it go back to the webserver the next time it loads
+              obj.reload
+              obj.enhance_current_scope(:#{key}, opts)
+              return obj
+            end
+          EOE
+          self.scopes[key.to_s] = val
+        end
+        # Use the method current scope because it gives a string
+        # This expression substitutes the options from opts into the default attributes of the scope, it will only copy keys that exist in the original
+        self.scopes[self.current_scope] = opts.inject(self.scopes[current_scope]){|accum,(k,v)| accum.key?(k.to_s) ? accum.merge(k.to_s => v) : accum}
+      end
+
+      # Use this method to access the internal data, this guarantees that loading only occurs once per object
+      def internal_object
+        raise "Not Implemented: This method must be implemented in a subclass"
+      end
+
+      def scopes
+        @scopes ||= {}.with_indifferent_access
+      end
+
+      def scope?(scp)
+        self.scopes.key?(scp.to_s)
+      end
+
+      def current_scope
+        ActiveSupport::StringInquirer.new(@current_scope.join("_and_").concat("_scope"))
+      end
+
+      def to_query
+        self.scopes[self.current_scope].to_query
+      end
+
+      def method_missing(method, *args, &block)
+        self.internal_object.send(method, *args, &block)
+      end
+
+      def reload
+        remove_instance_variable(:@internal_object) if instance_variable_defined?(:@internal_object)
+        self
+      end
+
+      def to_s
+        self.internal_object.to_s
+      end
+      
+      def inspect
+        self.internal_object.inspect
+      end
+
+      protected
+        def enhance_current_scope(scp, opts)
+          scp = scp.to_s
+          raise ArgumentError, "Unknown scope #{scp}" unless self.scope?(scp)
+          # Hold onto the attributes related to the old scope that we're going to chain to
+          current_scope_hash = self.scopes[self.current_scope]
+          # This sets the new current scope making them unique and sorted to make it order independent
+          @current_scope = @current_scope.concat([scp.to_s]).uniq.sort
+          # This sets up the new options for the current scope, it merges the defaults for the new scope then substitutes from opts
+          self.scopes[self.current_scope] = opts.inject(current_scope_hash.merge(self.scopes[scp.to_s])){|accum,(k,v)| accum.key?(k.to_s) ? accum.merge(k.to_s => v) : accum }
+        end
+    end
+    
+  end
+  
+end

data/lib/old_api_resource/associations/single_object_proxy.rb

@@ -0,0 +1,64 @@
+require 'old_api_resource/associations/association_proxy'
+
+module OldApiResource
+  
+  module Associations
+    
+    class SingleObjectProxy < AssociationProxy
+
+      def serializable_hash(options = {})
+        self.internal_object.serializable_hash(options)
+      end
+      
+      def internal_object=(contents)
+        return @internal_object = contents if contents.is_a?(self.klass)
+        return load(contents)
+      end
+
+      protected
+      def load_scope_with_options(scope, options)
+        scope = self.loaded_hash_key(scope.to_s, options)
+        # If the service uri is blank you can't load
+        return nil if self.remote_path.blank?
+        unless self.loaded[scope]
+          self.times_loaded += 1
+          self.loaded[scope] = self.klass.connection.get("#{self.remote_path}.#{self.klass.format.extension}?#{options.to_query}")
+        end
+        self.klass.new(self.loaded[scope])
+      end
+
+      def load(contents)
+        # If we get something nil this should just behave like nil
+        return if contents.nil?
+        raise "Expected an attributes hash got #{contents}" unless contents.is_a?(Hash)
+        # If we don't have a 'service_uri' just assume that these are all attributes and make an object
+        return @internal_object = self.klass.new(contents) unless contents[self.class.remote_path_element]
+        # allow for symbols vs strings with these elements
+        self.remote_path = contents.delete(self.class.remote_path_element) || contents.delete(self.class.remote_path_element.to_s)
+        # There's only one hash here so it's hard to distinguish attributes from scopes, the key scopes_only says everything
+        # in this hash is a scope
+        no_attrs = (contents.delete("scopes_only") || contents.delete(:scopes_only) || false)
+        attrs = {}
+        contents.each do |key, val|
+          # if this key is an attribute add it to attrs, warn if we've set scopes_only
+          if self.klass.attribute_names.include?(key) && !no_attrs
+            attrs[key] = val
+          else
+            warn("#{key} is an attribute of #{self.klass}, beware of name collisions") if no_attrs && self.klass.attribute_names.include?(key)
+            raise "Expected the scope #{key} to have a hash for a value, got #{val}" unless val.is_a?(Hash)
+            self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
+              def #{key}(opts = {})
+                OldApiResource::Associations::RelationScope.new(self, :#{key}, opts)
+              end
+            EOE
+            self.scopes[key.to_s] = val
+          end
+        end
+        @internal_object = attrs.present? ? self.klass.new(attrs) : nil
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/old_api_resource/attributes.rb

@@ -0,0 +1,162 @@
+module OldApiResource
+
+  module Attributes
+  
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Dirty
+    
+    included do
+      
+      alias_method_chain :save, :dirty_tracking
+      
+      class_inheritable_accessor :attribute_names, :public_attribute_names, :protected_attribute_names
+      
+      attr_reader :attributes
+      
+      self.attribute_names = []
+      self.public_attribute_names = []
+      self.protected_attribute_names = []
+      
+      define_method(:attributes) do
+        return @attributes if @attributes
+        # Otherwise make the attributes hash of all the attributes
+        @attributes = HashWithIndifferentAccess.new
+        self.class.attribute_names.each do |attr|
+          @attributes[attr] = self.send("#{attr}")
+        end
+        @attributes
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      def define_attributes(*args)
+        # This is provided by ActiveModel::AttributeMethods, it should define the basic methods
+        # but we need to override all the setters so we do dirty tracking
+        define_attribute_methods args
+        args.each do |arg|
+          self.attribute_names << arg.to_sym
+          self.public_attribute_names << arg.to_sym
+          
+          # Override the setter for dirty tracking
+          self.class_eval <<-EOE, __FILE__, __LINE__ + 1
+            def #{arg}
+              self.attributes[:#{arg}]
+            end
+          
+            def #{arg}=(val)
+              #{arg}_will_change! unless self.#{arg} == val
+              self.attributes[:#{arg}] = val
+            end
+            
+            def #{arg}?
+              self.attributes[:#{arg}].present?
+            end
+          EOE
+        end
+        self.attribute_names.uniq!
+        self.public_attribute_names.uniq!
+      end
+      
+      def define_protected_attributes(*args)
+        define_attribute_methods args
+        args.each do |arg|
+          self.attribute_names << arg.to_sym
+          self.protected_attribute_names << arg.to_sym
+          
+          # These attributes cannot be set, throw an error if you try
+          self.class_eval <<-EOE, __FILE__, __LINE__ + 1
+
+            def #{arg}
+              self.attributes[:#{arg}]
+            end
+          
+            def #{arg}=(val)
+              raise "#{arg} is a protected attribute and cannot be set"
+            end
+            
+            def #{arg}?
+              self.attributes[:#{arg}].present?
+            end
+          EOE
+        end
+        self.attribute_names.uniq!
+        self.protected_attribute_names.uniq!
+      end
+      
+      def attribute?(name)
+        self.attribute_names.include?(name.to_sym)
+      end
+      
+      def protected_attribute?(name)
+        self.protected_attribute_names.include?(name.to_sym)
+      end
+      
+      def clear_attributes
+        self.attribute_names.clear
+        self.public_attribute_names.clear
+        self.protected_attribute_names.clear
+      end
+    end
+    
+    module InstanceMethods
+      
+      # set new attributes
+      def attributes=(new_attrs)
+        new_attrs.each_pair do |k,v|
+          self.send("#{k}=",v)
+        end
+        new_attrs
+      end
+      
+      def save_with_dirty_tracking(*args)
+        if save_without_dirty_tracking(*args)
+          @previously_changed = self.changes
+          @changed_attributes.clear
+          return true
+        else
+          return false
+        end
+      end
+      
+      def set_attributes_as_current(*attrs)
+        @changed_attributes.clear and return if attrs.blank?
+        attrs.each do |attr|
+          @changed_attributes.delete(attr.to_s)
+        end
+      end
+      
+      def reset_attribute_changes(*attrs)
+        attrs = self.class.public_attribute_names if attrs.blank?
+        attrs.each do |attr|
+          self.send("reset_#{attr}!")
+        end
+        
+        set_attributes_as_current(*attrs)
+      end
+      
+      def attribute?(name)
+        self.class.attribute?(name)
+      end
+      
+      def protected_attribute?(name)
+        self.class.protected_attribute?(name)
+      end
+      
+      def respond_to?(sym)
+        if sym =~ /\?$/
+          return true if self.attribute?($`)
+        elsif sym =~ /=$/
+          return true if self.class.public_attribute_names.include?($`)
+        else
+          return true if self.attribute?(sym.to_sym)
+        end
+        super
+      end
+    end
+    
+  end
+  
+end