rpc-mapper 0.1.6 → 0.2.0

data/lib/rpc_mapper/association.rb

@@ -0,0 +1,162 @@
+module RPCMapper::Association; end
+
+module RPCMapper::Association
+
+  class Base
+    attr_accessor :source_klass, :id, :options
+
+    def initialize(klass, id, options={})
+      self.source_klass = klass
+      self.id = id.to_sym
+      self.options = options
+    end
+
+    def type
+      raise NotImplementedError, "You must define the type in subclasses."
+    end
+
+    def polymorphic?
+      raise NotImplementedError, "You must define how your association is polymorphic in subclasses."
+    end
+
+    def collection?
+      raise NotImplementedError, "You must define collection? in subclasses."
+    end
+
+    def primary_key
+      options[:primary_key] || :id
+    end
+
+    def foreign_key
+      options[:foreign_key]
+    end
+
+    def target_klass(object=nil)
+      klass = if options[:polymorphic]
+        eval [options[:polymorphic_namespace], object.send("#{id}_type")].compact.join('::') if object
+      else
+        raise(ArgumentError, ":class_name option required for association declaration.") unless options[:class_name]
+        options[:class_name] = "::#{options[:class_name]}" unless options[:class_name] =~ /^::/
+        eval(options[:class_name])
+      end
+
+      RPCMapper::Base.resolve_leaf_klass klass
+    end
+
+    def scope(object)
+      raise NotImplementedError, "You must define scope in subclasses"
+    end
+
+    # TRP: Only eager loadable if association query does not depend on instance data
+    def eager_loadable?
+      RPCMapper::Relation::FINDER_OPTIONS.inject(true) { |condition, key| condition && !options[key].respond_to?(:call) }
+    end
+
+    protected
+
+    def base_scope(object)
+      target_klass(object).scoped.apply_finder_options base_finder_options(object)
+    end
+
+    def base_finder_options(object)
+      RPCMapper::Relation::FINDER_OPTIONS.inject({}) do |sum, key|
+        value = self.options[key]
+        sum.merge!(key => value.respond_to?(:call) ? value.call(object) : value) if value
+        sum
+      end
+    end
+
+  end
+
+
+  class BelongsTo < Base
+
+    def type
+      :belongs_to
+    end
+
+    def collection?
+      false
+    end
+
+    def foreign_key
+      super || "#{id}_id".to_sym
+    end
+
+    def polymorphic?
+      !!options[:polymorphic]
+    end
+
+    # Returns a scope on the target containing this association
+    #
+    # Builds conditions on top of the base_scope generated from any finder options set with the association
+    #
+    # belongs_to :foo, :foreign_key => :foo_id
+    #
+    # In addition to any finder options included with the association options the following scope will be added:
+    #  where(:id => source[:foo_id])
+    def scope(object)
+      base_scope(object).where(self.primary_key => object[self.foreign_key]) if object[self.foreign_key]
+    end
+
+  end
+
+
+  class Has < Base
+
+    def foreign_key
+      super || (self.polymorphic? ? "#{options[:as]}_id" : "#{RPCMapper::Base.base_class_name(source_klass).downcase}_id").to_sym
+    end
+
+
+    # Returns a scope on the target containing this association
+    #
+    # Builds conditions on top of the base_scope generated from any finder options set with the association
+    #
+    # has_many :widgets, :class_name => "Widget", :foreign_key => :widget_id
+    # has_many :comments, :as => :parent
+    #
+    # In addition to any finder options included with the association options the following will be added:
+    #  where(widget_id => source[:id])
+    # Or for the polymorphic :comments association:
+    #  where(:parent_id => source[:id], :parent_type => source.class)
+    def scope(object)
+      s = base_scope(object).where(self.foreign_key => object[self.primary_key]) if object[self.primary_key]
+      s = s.where(:"#{options[:as]}_type" => RPCMapper::Base.base_class_name(object.class)) if s && polymorphic?
+      s
+    end
+
+    def polymorphic?
+      !!options[:as]
+    end
+
+  end
+
+
+  class HasMany < Has
+
+    def collection?
+      true
+    end
+
+    def type
+      :has_many
+    end
+
+  end
+
+
+  class HasOne < Has
+
+    def collection?
+      false
+    end
+
+    def type
+      :has_one
+    end
+
+  end
+
+
+end

data/lib/rpc_mapper/association_preload.rb

@@ -0,0 +1,50 @@
+module RPCMapper::AssociationPreload
+  module ClassMethods
+
+    def eager_load_associations(original_results, relation)
+      relation.includes_values.each do |association_id|
+        association = self.defined_associations[association_id.to_sym]
+        options = association.options
+
+        unless association.eager_loadable?
+          raise RPCMapper::AssociationPreloadNotSupported,
+                "delayed execution options (block options) cannot be used for eager loaded associations"
+        end
+
+        case association.type
+        when :has_many, :has_one
+          fks = original_results.collect { |record| record.send(association.primary_key) }.compact
+
+          pre_records = association.target_klass.where(association.foreign_key => fks).all
+
+          original_results.each do |record|
+            pk = record.send(association.primary_key)
+            relevant_records = pre_records.select { |r| r.send(association.foreign_key) == pk }
+            relevant_records = association.collection? ? relevant_records : relevant_records.first
+            record.send("#{association.id}=", relevant_records)
+          end
+
+        when :belongs_to
+          fks = original_results.collect { |record| record.send(association.foreign_key) }.compact
+
+          pre_records = association.target_klass.where(association.primary_key => fks).all
+
+          original_results.each do |record|
+            fk = record.send(association.foreign_key)
+            relevant_records = pre_records.select { |r| r.send(association.primary_key) == fk }.first
+            record.send("#{association.id}=", relevant_records)
+          end
+        end
+      end
+    end
+
+  end
+
+  module InstanceMethods
+  end
+
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+end

data/lib/rpc_mapper/associations/common.rb

@@ -3,6 +3,15 @@ module RPCMapper::Associations
   module Common
     module ClassMethods
 
+      def base_class_name(klass)
+        klass.to_s.split("::").last
+      end
+
+      # TRP: This will return the most recent extension of klass or klass if it is a leaf node in the hierarchy
+      def resolve_leaf_klass(klass)
+        extension_map[klass].empty? ? klass : resolve_leaf_klass(extension_map[klass].last)
+      end
+
       protected
 
       def extension_map
@@ -13,15 +22,6 @@ module RPCMapper::Associations
         self.extension_map[old_klass] += [new_klass] if base_class_name(old_klass) == base_class_name(new_klass)
       end
 
-      # TRP: This will return the most recent extension of klass or klass if it is a leaf node in the hierarchy
-      def resolve_leaf_klass(klass)
-        extension_map[klass].empty? ? klass : resolve_leaf_klass(extension_map[klass].last)
-      end
-
-      def base_class_name(klass)
-        klass.to_s.split("::").last
-      end
-
     end
 
     module InstanceMethods
@@ -32,9 +32,9 @@ module RPCMapper::Associations
         klass = if options[:polymorphic]
           eval [options[:polymorphic_namespace], self.send("#{association}_type")].compact.join('::')
         else
-          raise(ArgumentError, ":class_name or :klass option required for association declaration.") unless options[:class_name] || options[:klass]
+          raise(ArgumentError, ":class_name option required for association declaration.") unless options[:class_name]
           options[:class_name] = "::#{options[:class_name]}" unless options[:class_name] =~ /^::/
-          options[:klass] || eval(options[:class_name])
+          eval(options[:class_name])
         end
 
         self.class.send :resolve_leaf_klass, klass

data/lib/rpc_mapper/associations/external.rb

@@ -1,47 +1,38 @@
 require 'rpc_mapper/associations/common'
+require 'rpc_mapper/association'
 
 module RPCMapper::Associations
 
   module External
     module ClassMethods
 
-      def belongs_to(association, options={})
-        create_external_association(:belongs, association, options)
+      def belongs_to(id, options={})
+        create_external_association RPCMapper::Association::BelongsTo.new(self, id, options)
       end
 
-      def has_one(association, options={})
-        create_external_association(:one, association, options)
+      def has_one(id, options={})
+        create_external_association RPCMapper::Association::HasOne.new(self, id, options)
       end
 
-      def has_many(association, options={})
-        create_external_association(:many, association, options)
+      def has_many(id, options={})
+        create_external_association RPCMapper::Association::HasMany.new(self, id, options)
       end
 
       protected
 
-      def create_external_association(association_type, association, association_options={})
-        cache_ivar = "@association_#{association}"
-        self.declared_associations[association] = [association_type, association_options]
+      def create_external_association(association)
+        cache_ivar = "@association_#{association.id}"
+        self.defined_associations[association.id] = association
 
-        define_method(association) do
-          type = self.class.declared_associations[association].first
-          options = self.class.declared_associations[association].last.dup
-          options = options.is_a?(Proc) ? options.call(self) : options
-          klass = klass_from_association_options(association, options)
+        define_method(association.id) do
           cached_value = instance_variable_get(cache_ivar)
 
-          options[:primary_key] = (options[:primary_key] || "id").to_sym
-          options[:foreign_key] = (options[:foreign_key] || ((type == :belongs) ? "#{association}_id" : "#{self.class.name.split('::').last.downcase}_id")).to_sym
-
           # TRP: Logic for actually pulling setting the value
           unless cached_value
-            query_options = build_query_options_for_external_association(type, options)
-            cached_value = case type
-            when :belongs, :one
-              klass.first(query_options) if query_options[:conditions] # TRP: Only run query if conditions is not nil
-            when :many
-              klass.apply_finder_options(query_options)   if query_options[:conditions] # TRP: Only apply scopes if conditions is not nil
-            end
+            scoped = association.scope(self)
+
+            cached_value = association.collection? ? scoped : scoped.first if scoped && !scoped.where_values.empty?
+
             instance_variable_set(cache_ivar, cached_value)
           end
 
@@ -49,7 +40,7 @@ module RPCMapper::Associations
         end
 
         # TRP: Allow eager loading of the association without having to load it through the normal accessor
-        define_method("#{association}=") do |value|
+        define_method("#{association.id}=") do |value|
           instance_variable_set(cache_ivar, value)
         end
       end
@@ -57,39 +48,6 @@ module RPCMapper::Associations
     end
 
     module InstanceMethods
-
-      protected
-
-      def build_query_options_for_external_association(type, options)
-        as = options[:as]
-        as_type = self.class.send(:base_class_name, self.class) if as
-
-        pk = options[:primary_key].to_sym
-        fk = (as ? "#{as}_id" : options[:foreign_key]).to_sym
-
-        default_query_options = case type
-        when :belongs
-          { :conditions => (self[fk] ? { pk => self[fk] } : nil) } # TRP: Only add conditions if the fk is not nil
-        when :one, :many
-          # TRP: Only add conditions if the pk is not nil
-          if self[pk]
-            conditions = { fk => self[pk] }
-            conditions.merge!(:"#{as}_type" => as_type) if as
-            { :conditions => conditions }
-          else
-            {}
-          end
-        end
-
-        configured_query_options = {}
-        RPCMapper::Relation::FINDER_OPTIONS.each do |key|
-          value = options[key]
-          configured_query_options.merge!({ key => value.respond_to?(:call) ? value.call(self) : value }) if value
-        end
-
-        default_query_options.deep_merge(configured_query_options)
-      end
-
     end
 
     def self.included(receiver)

data/lib/rpc_mapper/base.rb

@@ -2,6 +2,7 @@
 require 'rpc_mapper/errors'
 require 'rpc_mapper/associations/contains'
 require 'rpc_mapper/associations/external'
+require 'rpc_mapper/association_preload'
 require 'rpc_mapper/cacheable'
 require 'rpc_mapper/serialization'
 require 'rpc_mapper/relation'
@@ -12,16 +13,17 @@ require 'rpc_mapper/adapters'
 class RPCMapper::Base
   include RPCMapper::Associations::Contains
   include RPCMapper::Associations::External
+  include RPCMapper::AssociationPreload
   include RPCMapper::Serialization
   include RPCMapper::Scopes
 
   attr_accessor :attributes, :new_record, :read_options, :write_options
   alias :new_record? :new_record
 
-  class_inheritable_accessor :read_adapter, :write_adapter, :cacheable, :defined_attributes, :scoped_methods, :declared_associations
+  class_inheritable_accessor :read_adapter, :write_adapter, :cacheable, :defined_attributes, :scoped_methods, :defined_associations
 
   self.cacheable = false
-  self.declared_associations = {}
+  self.defined_associations = {}
   self.defined_attributes = []
 
   def initialize(attributes={})
@@ -88,8 +90,9 @@ class RPCMapper::Base
 
     protected
 
-    def fetch_records(options={})
-      self.read_adapter.read(options).collect { |hash| self.new_from_data_store(hash) }.compact
+    def fetch_records(relation)
+      options = relation.to_hash
+      self.read_adapter.read(options).collect { |hash| self.new_from_data_store(hash) }.compact.tap { |result| eager_load_associations(result, relation) }
     end
 
     def read_with(adapter_type)

data/lib/rpc_mapper/cacheable.rb

@@ -20,7 +20,8 @@ module RPCMapper::Cacheable
 
     protected
 
-    def fetch_records_with_caching(options={})
+    def fetch_records_with_caching(relation)
+      options = relation.to_hash
       key = Digest::MD5.hexdigest(self.to_s + options.to_a.sort { |a,b| a.to_s.first <=> b.to_s.first }.inspect)
       cache_hit = self.cache_store.read(key)
       get_fresh = options.delete(:fresh)
@@ -30,7 +31,7 @@ module RPCMapper::Cacheable
         cache_hit.each { |fv| fv.fresh = false.freeze }
         cache_hit
       else
-        fresh_value = fetch_records_without_caching(options)
+        fresh_value = fetch_records_without_caching(relation)
 
         # TRP: Only store in cache if record count is below the cache_record_count_threshold (if it is set)
         if !self.cache_record_count_threshold || fresh_value.size <= self.cache_record_count_threshold

data/lib/rpc_mapper/errors.rb

@@ -12,4 +12,13 @@ module RPCMapper
   class RecordNotSaved < RPCMapperError
   end
 
+  # Raised when trying to eager load an association that relies on instance level data.
+  # class Article < RPCMapper::Base
+  #   has_many :comments, :conditions => lambda { |article| ... }
+  # end
+  #
+  # Article.recent.includes(:comments) # Raises AssociationPreloadNotSupported
+  class AssociationPreloadNotSupported < RPCMapperError
+  end
+
 end

data/lib/rpc_mapper/relation/finder_methods.rb

@@ -18,11 +18,11 @@ module RPCMapper::FinderMethods
   end
 
   def all(options={})
-    self.apply_finder_options(options).fetch_records
+    self.apply_finder_options(options).to_a
   end
 
   def first(options={})
-    self.apply_finder_options(options).limit(1).fetch_records.first
+    self.apply_finder_options(options).limit(1).to_a.first
   end
 
   def search(options={})

data/lib/rpc_mapper/relation/query_methods.rb

@@ -1,8 +1,8 @@
 module RPCMapper::QueryMethods
   # TRP: Define each of the variables the query options will be stored in.
-  attr_accessor :select_values, :group_values, :order_values, :joins_values, :where_values,
-                :having_values, :limit_value, :offset_value, :from_value, :raw_sql_value,
-                :fresh_value
+  attr_accessor :select_values, :group_values, :order_values, :joins_values, :includes_values, :where_values, :having_values,
+                :limit_value, :offset_value, :from_value,
+                :raw_sql_value, :fresh_value
 
   def select(*args)
     if block_given?
@@ -24,8 +24,13 @@ module RPCMapper::QueryMethods
     clone.tap { |r| r.joins_values += args if args && !args.empty? }
   end
 
+  def includes(*args)
+    args.reject! { |a| a.nil? }
+    clone.tap { |r| r.includes_values += (r.includes_values + args).flatten.uniq if args && !args.empty? }
+  end
+
   def where(*args)
-    clone.tap { |r| r.where_values += args if args && !args.empty? }
+    clone.tap { |r| r.where_values += args.compact.reject(&:empty?) if args && !args.empty? }
   end
 
   def having(*args)
@@ -45,7 +50,10 @@ module RPCMapper::QueryMethods
   end
 
   def fresh(val=true)
-    clone.tap { |r| r.fresh_value = val }
+    clone.tap do |r|
+      r.fresh_value = val
+      r.instance_variable_set(:@records, nil) if r.fresh_value
+    end
   end
 
   def sql(raw_sql)

data/lib/rpc_mapper/relation.rb

@@ -5,8 +5,9 @@ require 'rpc_mapper/relation/finder_methods'
 # => http://github.com/rails/rails
 # Used to achieve the chainability of scopes -- methods are delegated back and forth from BM::Base and BM::Relation
 class RPCMapper::Relation
+  attr_reader :klass
   SINGLE_VALUE_METHODS = [:limit, :offset, :from, :fresh]
-  MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having]
+  MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :includes, :where, :having]
 
   FINDER_OPTIONS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS + [:conditions, :search, :sql]
 
@@ -38,7 +39,7 @@ class RPCMapper::Relation
 
   def to_hash
     # TRP: If present pass :sql option alone as it trumps all other options
-    if self.raw_sql_value
+    @hash ||= if self.raw_sql_value
       { :sql => raw_sql_value }
     else
       hash = SINGLE_VALUE_METHODS.inject({}) do |h, option|
@@ -64,6 +65,10 @@ class RPCMapper::Relation
     @records ||= fetch_records
   end
 
+  def eager_load?
+    @includes_values && !@includes_values.empty?
+  end
+
   def inspect
    to_a.inspect
   end
@@ -119,7 +124,7 @@ class RPCMapper::Relation
   end
 
   def fetch_records
-    @klass.send(:fetch_records, to_hash)
+    @klass.send(:fetch_records, self)
   end
 
 end

data/lib/rpc_mapper/version.rb

@@ -2,8 +2,8 @@ module RPCMapper
   module Version
 
     MAJOR = 0
-    MINOR = 1
-    TINY  = 6
+    MINOR = 2
+    TINY  = 0
 
     def self.to_s # :nodoc:
       [MAJOR, MINOR, TINY].join('.')

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 6
-  version: 0.1.6
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Travis Petticrew
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-18 00:00:00 -06:00
+date: 2010-11-22 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -127,6 +127,8 @@ files:
 - lib/rpc_mapper/adapters/bertrpc_adapter.rb
 - lib/rpc_mapper/adapters/restful_http_adapter.rb
 - lib/rpc_mapper/adapters.rb
+- lib/rpc_mapper/association.rb
+- lib/rpc_mapper/association_preload.rb
 - lib/rpc_mapper/associations/common.rb
 - lib/rpc_mapper/associations/contains.rb
 - lib/rpc_mapper/associations/external.rb