api_resource 0.4.1 → 0.4.2

data/lib/api_resource.rb

@@ -0,0 +1,130 @@
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext'
+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 :Decorators
+  autoload :Formats
+  autoload :Local
+  autoload :LogSubscriber
+  autoload :Mocks
+  autoload :ModelErrors
+  autoload :Observing
+  autoload :Scopes
+  autoload :Validations
+  
+  require 'api_resource/railtie'
+  
+  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
+
+  class << self
+    
+    delegate :site, :site=, :format, :format=, 
+      :token, :token=, :timeout, 
+      :open_timeout, 
+      :reset_connection, :ttl, :ttl=,
+      :to => ApiResource::Base
+    
+  end
+
+  def self.cache(reset = false)
+    @cache = nil if reset
+    @cache ||= begin
+      defined?(Rails) ? Rails.cache : ActiveSupport::Cache::MemoryStore.new
+    end
+  end
+  
+  # set the timeout val and reset the connection
+  def self.timeout=(val)
+    ApiResource::Base.timeout = val
+    self.reset_connection
+    val
+  end
+
+  # set the timeout val and reset the connection
+  def self.open_timeout=(val)
+    ApiResource::Base.open_timeout = val
+    self.reset_connection
+    val
+  end
+  self.timeout = self.open_timeout = DEFAULT_TIMEOUT
+
+  # 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
+
+  def self.with_ttl(new_ttl, &block)
+    old_ttl = self.ttl
+    begin
+      self.ttl = new_ttl
+      yield
+    ensure
+      self.ttl = old_ttl
+    end
+  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
+      class_attribute :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,218 @@
+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/generic_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/has_many_through_remote_object_proxy'
+require 'api_resource/associations/related_object_hash'
+
+module ApiResource
+  
+  module Associations
+    extend ActiveSupport::Concern
+
+    included do
+      
+      unless self.ancestors.include?(ApiResource::AssociationActivation)
+        raise Exception.new(
+          "Can't include Associations without AssociationActivation" 
+        )
+      end
+
+      class_attribute :related_objects
+      attr_accessor :assoc_attributes
+
+      define_method(:assoc_attributes) do
+        @assoc_attributes ||= Hash.new
+      end
+
+      self.clear_related_objects
+
+      # we need to add an inherited method here, but it can't happen
+      # until after this module in included/extended, so it's in its own
+      # little mini module
+      extend InheritedMethod
+
+      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 InheritedMethod
+      # define a method to reset our related objects
+      def inherited(descendant)
+        # we only want to do this in direct descendants of ApiResoruce::Base
+        if self == ApiResource::Base
+          descendant.clear_related_objects
+        else
+          descendant.clone_related_objects
+        end
+        super(descendant)
+      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|
+                  #We need to merge upon itself to generate a new object since the children all share their related objects with each other
+                  klass.related_objects = klass.related_objects.merge(:#{assoc} => klass.related_objects[:#{assoc}].merge(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 == "scopes"
+          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 == "scopes"}.collect{|k,v| v.keys.collect(&:to_sym)}.flatten
+      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
+      
+      protected
+
+        def clear_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
+
+          # TODO :Remove scopes from related_objects.
+          self.related_objects[:scopes] = RelatedObjectHash.new({})
+        end
+
+        def clone_related_objects
+          # Hash to hold onto the definitions of the related objects
+          self.related_objects = self.related_objects.clone
+          self.association_types.keys.each do |type|
+            self.related_objects[type] = self.related_objects[type].clone
+          end
+          # TODO :Remove scopes from related_objects.
+          self.related_objects[:scopes] = self.related_objects[:scopes].clone
+        end
+
+        def define_association_as_attribute(assoc_type, assoc_name)
+          # set up dirty tracking for associations
+          
+          self.class_eval <<-EOE, __FILE__, __LINE__ + 1
+            def #{assoc_name}
+              self.assoc_attributes[:#{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)
+              # get old internal object
+              old_internal_object = self.#{assoc_name}.internal_object
+              self.#{assoc_name}.internal_object = val
+              #{assoc_name}_will_change! unless self.#{assoc_name} == old_internal_object
+              self.#{assoc_name}.internal_object
+            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
+    
+    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

data/lib/api_resource/associations/association_proxy.rb

@@ -0,0 +1,116 @@
+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, _|
+          next if self.respond_to?(key)
+          self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
+            def #{key}(opts = {})
+              @#{key} ||= 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
+        if self
+          remove_instance_variable(:@internal_object) if instance_variable_defined?(:@internal_object)
+          self.load(self.load_from_remote({}))
+          self
+        end
+      end
+      
+      def to_s
+        self.internal_object.to_s
+      end
+      
+      def inspect
+        self.internal_object.inspect
+      end
+      
+      def ==(other)
+         raise "Not Implemented: This method must be implemented in a subclass"
+      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