api_resource 0.4.0 → 0.4.1

data/lib/api_resource.rb

@@ -1,130 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,218 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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