api_resource 0.2.1

data/lib/api_resource.rb

@@ -0,0 +1,129 @@
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'api_resource/core_extensions'
+
+require 'active_model'
+
+require 'log4r'
+require 'log4r/outputter/consoleoutputters'
+
+require 'api_resource/exceptions'
+
+require 'differ'
+require 'colorize'
+
+module ApiResource
+  
+  extend ActiveSupport::Autoload
+  
+  autoload :Associations
+  autoload :AssociationActivation
+  autoload :Attributes
+  autoload :Base
+  autoload :Callbacks
+  autoload :Connection
+  autoload :CustomMethods
+  autoload :Formats
+  autoload :Local
+  autoload :LogSubscriber
+  autoload :Mocks
+  autoload :ModelErrors
+  autoload :Observing
+  autoload :Scopes
+  autoload :Validations
+  
+  
+  mattr_writer :logger
+  mattr_accessor :raise_missing_definition_error; self.raise_missing_definition_error = false
+
+  DEFAULT_TIMEOUT = 10 # seconds
+  
+  # Load a fix for inflections for words ending in ess
+  ActiveSupport::Inflector.inflections do |inflect|
+    inflect.singular(/ess$/i, 'ess')
+  end
+  
+  def self.load_mocks_and_factories
+    require 'hash_dealer'
+    Mocks.clear_endpoints
+    Mocks.init
+    
+    Dir["#{File.dirname(__FILE__)}/../spec/support/requests/*.rb"].each {|f| require f}
+    Dir["#{File.dirname(__FILE__)}/../spec/support/**/*.rb"].each {|f| require f}
+  end
+  
+  def self.site=(new_site)
+    ApiResource::Base.site = new_site
+  end
+  
+  def self.format=(new_format)
+    ApiResource::Base.format = new_format
+  end
+  # set token
+  def self.token=(new_token)
+    ApiResource::Base.token = new_token
+  end
+  # get token
+  def self.token
+    ApiResource::Base.token
+  end
+  # Run a block with a given token - useful for AroundFilters
+  def self.with_token(new_token, &block)
+    old_token = self.token
+    begin
+      self.token = new_token
+      yield
+    ensure
+      self.token = old_token
+    end
+  end
+  
+  # delegated to Base
+  def self.reset_connection
+    ApiResource::Base.reset_connection
+  end
+
+  # set the timeout val and reset the connection
+  def self.timeout=(val)
+    @timeout = val
+    self.reset_connection
+    val
+  end
+  
+  # Getter for timeout
+  def self.timeout
+    @timeout ||= DEFAULT_TIMEOUT
+  end
+
+  # set the timeout val and reset the connection
+  def self.open_timeout=(val)
+    @open_timeout = val
+    self.reset_connection
+    val
+  end
+  
+  # Getter for timeout
+  def self.open_timeout
+    @open_timeout ||= DEFAULT_TIMEOUT
+  end
+  
+  # logger
+  def self.logger
+    return @logger if @logger
+    @logger = Log4r::Logger.new("api_resource")
+    @logger.outputters = [Log4r::StdoutOutputter.new('console')]
+    @logger.level = Log4r::INFO
+    @logger
+  end
+  
+  # Use this method to enable logging in the future
+  # def self.logging(val = nil)
+  #   return (@@logging || false) unless val
+  #   return @@logging = val
+  # end
+  
+end

data/lib/api_resource/association_activation.rb

@@ -0,0 +1,19 @@
+module ApiResource
+  module AssociationActivation
+    extend ActiveSupport::Concern
+    
+    included do
+      cattr_accessor :association_types
+      # our default association types
+      self.association_types = {:belongs_to => :single, :has_one => :single, :has_many => :multi}
+    end
+    
+    module ClassMethods
+      def activate_associations(assoc_types = nil)
+        self.association_types = assoc_types unless assoc_types.nil?
+        self.send(:include, ApiResource::Associations)
+      end
+    end
+    
+  end
+end

data/lib/api_resource/associations.rb

@@ -0,0 +1,169 @@
+require 'active_support'
+require 'active_support/string_inquirer'
+require 'api_resource/association_activation'
+require 'api_resource/associations/relation_scope'
+require 'api_resource/associations/resource_scope'
+require 'api_resource/associations/dynamic_resource_scope'
+require 'api_resource/associations/multi_argument_resource_scope'
+require 'api_resource/associations/multi_object_proxy'
+require 'api_resource/associations/single_object_proxy'
+require 'api_resource/associations/belongs_to_remote_object_proxy'
+require 'api_resource/associations/has_one_remote_object_proxy'
+require 'api_resource/associations/has_many_remote_object_proxy'
+require 'api_resource/associations/related_object_hash'
+
+module ApiResource
+  
+  module Associations
+    extend ActiveSupport::Concern
+
+    included do
+      
+      raise "Cannot include Associations without first including AssociationActivation" unless self.ancestors.include?(ApiResource::AssociationActivation)
+      class_inheritable_accessor :related_objects
+      
+      # Hash to hold onto the definitions of the related objects
+      self.related_objects = RelatedObjectHash.new
+      self.association_types.keys.each do |type|
+        self.related_objects[type] = RelatedObjectHash.new({})
+      end
+      self.related_objects[:scope] = RelatedObjectHash.new({})
+      
+      self.define_association_methods
+      
+    end
+
+    # module methods to include the proper associations in various libraries - this is usually loaded in Railties
+    def self.activate_active_record
+      ActiveRecord::Base.class_eval do
+        include ApiResource::AssociationActivation
+        self.activate_associations(:has_many_remote => :has_many_remote, :belongs_to_remote => :belongs_to_remote, :has_one_remote => :has_one_remote)
+      end
+    end
+
+    module ClassMethods
+      
+      # Define the methods for creating and testing for associations, unfortunately
+      # scopes are different enough to require different methods :(
+      def define_association_methods
+        self.association_types.each_key do |assoc|
+          self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
+            def #{assoc}(*args)
+              options = args.extract_options!
+              options = options.with_indifferent_access
+              # Raise an error if we have multiple args and options
+              raise "Invalid arguments to #{assoc}" unless options.blank? || args.length == 1
+              args.each do |arg|
+                klass_name = (options[:class_name] ? options[:class_name].to_s.classify : arg.to_s.classify)
+                # add this to any descendants - the other methods etc are handled by inheritance
+                ([self] + self.descendants).each do |klass|
+                  klass.related_objects[:#{assoc}][arg.to_sym] = klass_name
+                end
+                # We need to define reader and writer methods here
+                define_association_as_attribute(:#{assoc}, arg)
+              end
+            end
+          
+            def #{assoc}?(name)
+              return self.related_objects[:#{assoc}][name.to_s.pluralize.to_sym].present? || self.related_objects[:#{assoc}][name.to_s.singularize.to_sym].present?
+            end
+          
+            def #{assoc}_class_name(name)
+              raise "No such" + :#{assoc}.to_s + " association on #{name}" unless self.#{assoc}?(name)
+              return self.find_namespaced_class_name(self.related_objects[:#{assoc}][name.to_sym])
+            end            
+
+          EOE
+          # For convenience we will define the methods for testing for the existence of an association
+          # and getting the class for an association as instance methods too to avoid tons of self.class calls
+          self.class_eval <<-EOE, __FILE__, __LINE__ + 1
+            def #{assoc}?(name)
+              return self.class.#{assoc}?(name)
+            end
+
+            def #{assoc}_class_name(name)
+              return self.class.#{assoc}_class_name(name)
+            end
+          EOE
+        end
+      end
+      
+      def association?(assoc)
+        self.related_objects.any? do |key, value|
+          next if key.to_s == "scope"
+          value.detect { |k,v| k.to_sym == assoc.to_sym }
+        end
+      end
+      
+      def association_names
+        # structure is {:has_many => {"myname" => "ClassName"}}
+        self.related_objects.clone.delete_if{|k,v| k.to_s == "scope"}.collect{|k,v| v.keys.first.to_sym}
+      end
+      
+      def association_class_name(assoc)
+        raise ArgumentError, "#{assoc} is not a valid association of #{self}" unless self.association?(assoc)
+        result = self.related_objects.detect do |key,value|
+          ret = value.detect{|k,v| k.to_sym == assoc.to_sym }
+          return self.find_namespaced_class_name(ret[1]) if ret
+        end
+      end
+      
+      def clear_associations
+        self.related_objects.each do |_, val|
+          val.clear
+        end
+      end
+      
+      protected
+        def define_association_as_attribute(assoc_type, assoc_name)
+          self.class_eval <<-EOE, __FILE__, __LINE__ + 1
+            def #{assoc_name}
+              self.attributes[:#{assoc_name}] ||= #{self.association_types[assoc_type.to_sym].to_s.classify}ObjectProxy.new(self.association_class_name('#{assoc_name}'), nil, self)
+            end
+            def #{assoc_name}=(val)
+              #{assoc_name}_will_change! unless self.#{assoc_name}.internal_object == val
+              self.#{assoc_name}.internal_object = val
+            end
+            def #{assoc_name}?
+              self.#{assoc_name}.internal_object.present?
+            end
+          EOE
+        end
+        
+        def find_namespaced_class_name(klass)
+          # return the name if it is itself namespaced
+          return klass if klass =~ /::/
+          ancestors = self.name.split("::")
+          if ancestors.size > 1
+            receiver = Object
+            namespaces = ancestors[0..-2].collect do |mod|
+              receiver = receiver.const_get(mod)
+            end
+            if namespace = namespaces.reverse.detect{|ns| ns.const_defined?(klass, false)}
+              return namespace.const_get(klass).name
+            end
+          end
+
+          return klass
+        end
+      
+    end
+    
+    module InstanceMethods
+      def association?(assoc)
+        self.class.association?(assoc)
+      end
+      
+      def association_class_name(assoc)
+        self.class.association_class_name(assoc)
+      end
+      
+      # list of all association names
+      def association_names
+        self.class.association_names
+      end
+    end
+
+  end
+  
+end

data/lib/api_resource/associations/association_proxy.rb

@@ -0,0 +1,115 @@
+module ApiResource
+  
+  module Associations
+   
+    class AssociationProxy
+
+      cattr_accessor :remote_path_element; self.remote_path_element = :service_uri
+      cattr_accessor :include_class_scopes; self.include_class_scopes = true
+
+      attr_accessor :owner, :loaded, :klass, :internal_object, :remote_path, :scopes, :times_loaded
+
+      # TODO: added owner - moved it to the end because the tests don't use it - it's useful here though
+      def initialize(klass_name, contents, owner = nil)
+        raise "Cannot create an association proxy to the unknown object #{klass_name}" unless defined?(klass_name.to_s.classify)
+        # A simple attr_accessor for testing purposes
+        self.times_loaded = 0
+        self.owner = owner
+        self.klass = klass_name.to_s.classify.constantize
+        self.load(contents)
+        self.loaded = {}.with_indifferent_access
+        if self.class.include_class_scopes
+          self.scopes = self.scopes.reverse_merge(self.klass.scopes)
+        end
+        # Now that we have set up all the scopes with the load method we need to create methods
+        self.scopes.each do |key, _|
+          self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
+            def #{key}(opts = {})
+              ApiResource::Associations::RelationScope.new(self, :#{key}, opts)
+            end
+          EOE
+        end
+      end
+      
+      def serializable_hash(options = {})
+        raise "Not Implemented: This method must be implemented in a subclass"
+      end
+
+      def scopes
+        @scopes ||= {}.with_indifferent_access
+      end
+
+      def scope?(scp)
+        self.scopes.keys.include?(scp.to_s)
+      end
+
+      def internal_object
+        @internal_object ||= self.load_scope_with_options(:all, {})
+      end
+      
+      def blank?
+        self.internal_object.blank?
+      end
+      alias_method :empty?, :blank?
+
+      def method_missing(method, *args, &block)
+        self.internal_object.send(method, *args, &block)
+      end
+
+      def reload(scope =  nil, opts = {})
+        if scope.nil?
+          self.loaded.clear
+          self.times_loaded = 0
+          # Remove the loaded object to force it to reload
+          remove_instance_variable(:@internal_object) if instance_variable_defined?(:@internal_object)
+        else
+          # Delete this key from the loaded hash which will cause it to be reloaded
+          self.loaded.delete(self.loaded_hash_key(scope, opts))
+        end
+        self
+      end
+      
+      def to_s
+        self.internal_object.to_s
+      end
+      
+      def inspect
+        self.internal_object.inspect
+      end
+
+      protected
+      # This method loads a particular scope with a set of options from the remote server
+      def load_scope_with_options(scope, options)
+        raise "Not Implemented: This method must be implemented in a subclass"
+      end
+      # This method is a helper to initialize for loading the data passed in to create this object
+      def load(contents)
+        raise "Not Implemented: This method must be implemented in a subclass"
+      end
+      
+      # get the remote URI based on our config and options
+      def build_load_path(options)
+        path = self.remote_path
+        # add a format if it doesn't exist and there is no query string yet
+        path += ".#{self.klass.format.extension}" unless path =~ /\./ || path =~/\?/
+        # add the query string, allowing for other user-provided options in the remote_path if we have options
+        unless options.blank?
+          path += (path =~ /\?/ ? "&" : "?") + options.to_query 
+        end
+        path
+      end
+
+      # get data from the remote server
+      def load_from_remote(options)
+        self.klass.connection.get(self.build_load_path(options))
+      end
+      # This method create the key for the loaded hash, it ensures that a unique set of scopes
+      # with a unique set of options is only loaded once
+      def loaded_hash_key(scope, options)
+        options.to_a.sort.inject(scope) {|accum,(k,v)| accum << "_#{k}_#{v}"}
+      end
+    end
+    
+  end
+  
+end

data/lib/api_resource/associations/belongs_to_remote_object_proxy.rb

@@ -0,0 +1,16 @@
+require 'api_resource/associations/single_object_proxy'
+module ApiResource
+  module Associations
+    class BelongsToRemoteObjectProxy < SingleObjectProxy
+      def initialize(klass_name, contents, owner)
+        super
+        return if self.internal_object
+        # now if we have an owner and a foreign key, we set the data up to load
+        if owner && key = owner.send(self.klass.to_s.foreign_key)
+          self.load({"service_uri" => self.klass.element_path(key), "scopes_only" => true}.merge(self.klass.scopes))
+        end
+        true
+      end
+    end
+  end
+end