rpc-mapper 0.2.1 → 0.3.0

data/lib/rpc_mapper/association.rb

@@ -2,6 +2,23 @@ module RPCMapper::Association; end
 
 module RPCMapper::Association
 
+  ##
+  # Association::Base
+  #
+  # This is the base class for all associations.  It defines the basic structure
+  # of an association.  The basic nomenclature is as follows:
+  #
+  # TODO: Clean up this nomenclature.  Source and Target should be switched.  From
+  # the configuration side this is already done but the internal naming is backwards.
+  #
+  # Source:  The start point of the association.  The source class is the class
+  # on which the association is defined.
+  #
+  # Proxy:  On a through association the proxy is the class on which the target
+  # association lives
+  #
+  # Target:  The class that will ultimately be returned by the association
+  #
   class Base
     attr_accessor :source_klass, :id, :options
 
@@ -16,7 +33,10 @@ module RPCMapper::Association
     end
 
     def polymorphic?
-      raise NotImplementedError, "You must define how your association is polymorphic in subclasses."
+      raise(
+        NotImplementedError,
+        "You must define how your association is polymorphic in subclasses."
+      )
     end
 
     def collection?
@@ -32,11 +52,33 @@ module RPCMapper::Association
     end
 
     def target_klass(object=nil)
-      klass = if options[:polymorphic]
-        eval [options[:polymorphic_namespace], object.send("#{id}_type")].compact.join('::') if object
+      if options[:polymorphic] && object
+        poly_type = object.is_a?(RPCMapper::Base) ? object.send("#{id}_type") : object
+      end
+
+      klass = if poly_type
+        type_string = [
+          options[:polymorphic_namespace],
+          sanitize_type_attribute(poly_type)
+        ].compact.join('::')
+        begin
+          eval(type_string)
+        rescue NameError => err
+          raise(
+            RPCMapper::PolymorphicAssociationTypeError,
+            "No constant defined called #{type_string}"
+          )
+        end
       else
-        raise(ArgumentError, ":class_name option required for association declaration.") unless options[:class_name]
-        options[:class_name] = "::#{options[:class_name]}" unless options[:class_name] =~ /^::/
+        unless options[:class_name]
+          raise(ArgumentError,
+                ":class_name option required for association declaration.")
+        end
+
+        unless options[:class_name] =~ /^::/
+          options[:class_name] = "::#{options[:class_name]}"
+        end
+
         eval(options[:class_name])
       end
 
@@ -47,9 +89,12 @@ module RPCMapper::Association
       raise NotImplementedError, "You must define scope in subclasses"
     end
 
-    # TRP: Only eager loadable if association query does not depend on instance data
+    # 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) }
+      RPCMapper::Relation::FINDER_OPTIONS.inject(true) do |condition, key|
+        condition && !options[key].respond_to?(:call)
+      end
     end
 
     protected
@@ -66,6 +111,11 @@ module RPCMapper::Association
       end
     end
 
+    # TRP: Make sure the value looks like a variable syntaxtually
+    def sanitize_type_attribute(string)
+      string.gsub(/[^a-zA-Z]\w*/, '')
+    end
+
   end
 
 
@@ -87,16 +137,26 @@ module RPCMapper::Association
       !!options[:polymorphic]
     end
 
+    def polymorphic_type
+      "#{id}_type".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
+    # 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:
+    # 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]
+      if object[self.foreign_key]
+        base_scope(object).where(self.primary_key => object[self.foreign_key])
+      end
     end
 
   end
@@ -105,27 +165,46 @@ module RPCMapper::Association
   class Has < Base
 
     def foreign_key
-      super || (self.polymorphic? ? "#{options[:as]}_id" : "#{RPCMapper::Base.base_class_name(source_klass).downcase}_id").to_sym
+      super || if self.polymorphic?
+        "#{options[:as]}_id"
+      else
+         "#{RPCMapper::Base.base_class_name(source_klass).downcase}_id"
+      end.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
+    # 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:
     #
-    # has_many :widgets, :class_name => "Widget", :foreign_key => :widget_id
-    # has_many :comments, :as => :parent
+    #   where(widget_id => source[:id])
     #
-    # 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)
+    #
+    #   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?
+      return nil unless object[self.primary_key]
+      s = base_scope(object).where(self.foreign_key => object[self.primary_key])
+      if polymorphic?
+        s = s.where(
+          polymorphic_type => RPCMapper::Base.base_class_name(object.class) )
+      end
       s
     end
 
+    def polymorphic_type
+      :"#{options[:as]}_type"
+    end
+
     def polymorphic?
       !!options[:as]
     end
@@ -159,4 +238,93 @@ module RPCMapper::Association
   end
 
 
+  class HasManyThrough < HasMany
+    attr_accessor :proxy_association
+    attr_accessor :target_association
+
+    def proxy_association
+      @proxy_association ||= source_klass.defined_associations[options[:through]] ||
+        raise(
+          RPCMapper::AssociationNotFound,
+          ":has_many_through: '#{options[:through]}' is not an association " +
+          "on #{source_klass}"
+        )
+    end
+
+    def target_association
+      return @target_association if @target_association
+
+      klass = proxy_association.target_klass
+      @target_association = klass.defined_associations[self.id] ||
+        klass.defined_associations[self.options[:source]] ||
+        raise(RPCMapper::AssociationNotFound,
+          ":has_many_through: '#{options[:source] || self.id}' is not an " +
+          "association on #{klass}"
+        )
+    end
+
+    def scope(object)
+      # Which attribute's values should be used on the proxy
+      key = if target_is_has?
+        target_association.primary_key.to_sym
+      else
+        target_association.foreign_key.to_sym
+      end
+
+      # Fetch the ids of all records on the proxy using the correct key
+      proxy_ids = proc do
+        proxy_association.scope(object).select(key).collect(&key)
+      end
+
+      # Use these ids to build a scope on the target object
+      relation = target_klass.scoped
+
+      if target_is_has?
+        relation = relation.where(
+          proc do
+            { target_association.foreign_key => proxy_ids.call }
+          end
+        )
+      else
+        relation = relation.where(
+          proc do
+            { target_association.primary_key => proxy_ids.call }
+          end
+        )
+      end
+
+      # Add polymorphic type condition if target is polymorphic and has
+      if target_association.polymorphic? && target_is_has?
+        relation = relation.where(
+          target_association.polymorphic_type =>
+            RPCMapper::Base.base_class_name(proxy_association.target_klass(object))
+        )
+      end
+
+      relation
+    end
+
+    def target_klass
+      target_association.target_klass(options[:source_type])
+    end
+
+    def target_type
+      target_association.type
+    end
+
+    def target_is_has?
+      target_association.is_a?(Has)
+    end
+
+    def type
+      :has_many_through
+    end
+
+    def polymorphic?
+      false
+    end
+
+  end
+
+
 end

data/lib/rpc_mapper/association_preload.rb

@@ -4,30 +4,49 @@ module RPCMapper::AssociationPreload
     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
+        force_fresh = relation.fresh_value
+
+        unless association
+          raise(
+            RPCMapper::AssociationNotFound,
+            "no such association (#{association_id})"
+          )
+        end
 
         unless association.eager_loadable?
-          raise RPCMapper::AssociationPreloadNotSupported,
-                "delayed execution options (block options) cannot be used for eager loaded associations"
+          raise(
+            RPCMapper::AssociationPreloadNotSupported,
+            "delayed execution options (block options) cannot be used for eager loaded associations"
+          )
         end
 
+        options = association.options
+
         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
+          pre_records = association.target_klass.where(association.foreign_key => fks).all(:fresh => force_fresh)
 
           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
+
+            relevant_records = if association.collection?
+              scope = association.scope(record).where(association.foreign_key => pk)
+              scope.records = relevant_records
+              scope
+            else
+              relevant_records.first
+            end
+
             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
+          pre_records = association.target_klass.where(association.primary_key => fks).all(:fresh => force_fresh)
 
           original_results.each do |record|
             fk = record.send(association.foreign_key)
@@ -47,4 +66,4 @@ module RPCMapper::AssociationPreload
     receiver.extend         ClassMethods
     receiver.send :include, InstanceMethods
   end
-end
+end

data/lib/rpc_mapper/associations/external.rb

@@ -15,7 +15,12 @@ module RPCMapper::Associations
       end
 
       def has_many(id, options={})
-        create_external_association RPCMapper::Association::HasMany.new(self, id, options)
+        klass = if options.include?(:through)
+          RPCMapper::Association::HasManyThrough
+        else
+          RPCMapper::Association::HasMany
+        end
+        create_external_association klass.new(self, id, options)
       end
 
       protected
@@ -27,11 +32,13 @@ module RPCMapper::Associations
         define_method(association.id) do
           cached_value = instance_variable_get(cache_ivar)
 
-          # TRP: Logic for actually pulling setting the value
+          # TRP: Logic for actually pulling & setting the value
           unless cached_value
             scoped = association.scope(self)
 
-            cached_value = association.collection? ? scoped : scoped.first if scoped && !scoped.where_values.empty?
+            if scoped && !scoped.where_values.empty?
+              cached_value = association.collection? ? scoped : scoped.first
+            end
 
             instance_variable_set(cache_ivar, cached_value)
           end
@@ -57,4 +64,4 @@ module RPCMapper::Associations
     end
   end
 
-end
+end

data/lib/rpc_mapper/errors.rb

@@ -1,24 +1,49 @@
 module RPCMapper
 
   # Generic RPCMapper error
+  #
   class RPCMapperError < StandardError
   end
 
   # Raised when RPCMapper cannot find records from a given id or set of ids
+  #
   class RecordNotFound < RPCMapperError
   end
 
-  # Raised when RPCMapper cannot save a record through the write_adapter and save! or update_attributes! was used
+  # Raised when RPCMapper cannot save a record through the write_adapter
+  # and save! or update_attributes! was used
+  #
   class RecordNotSaved < RPCMapperError
   end
 
-  # Raised when trying to eager load an association that relies on instance level data.
+  # Used for all association related errors
+  #
+  class AssociationError < 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
+  #
+  class AssociationPreloadNotSupported < AssociationError
+  end
+
+  # Raised when trying to eager load an association that does not exist or
+  # trying to create a :has_many_through association with a nonexistant
+  # association as the source
+  #
+  class AssociationNotFound < AssociationError
+  end
+
+  # Raised when a polymorphic association type is not present in the specified
+  # scope.  Always be sure that any values set for the type attribute on any
+  # polymorphic association are real constants defined in :polymorphic_namespace
+  #
+  class PolymorphicAssociationTypeError < AssociationError
   end
 
 end

data/lib/rpc_mapper/relation.rb

@@ -6,6 +6,8 @@ require 'rpc_mapper/relation/finder_methods'
 # 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
+  attr_accessor :records
+
   SINGLE_VALUE_METHODS = [:limit, :offset, :from, :fresh]
   MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :includes, :where, :having]
 
@@ -44,23 +46,31 @@ class RPCMapper::Relation
     else
       hash = SINGLE_VALUE_METHODS.inject({}) do |h, option|
         value = self.send("#{option}_value")
+        value = call_procs(value)
         value ? h.merge(option => value) : h
       end
 
       hash.merge!((MULTI_VALUE_METHODS - [:select]).inject({}) do |h, option|
         value = self.send("#{option}_values")
+        value = call_procs(value)
         value && !value.empty? ? h.merge(option => value.uniq) : h
       end)
 
       # TRP: If one of the select options contains a * than select options are ignored
       if select_values && !select_values.empty? && !select_values.any? { |val| val.to_s.match(/\*$/) }
-        hash.merge!(:select => select_values.uniq)
+        value = call_procs(select_values)
+        hash.merge!(:select => value.uniq)
       end
 
       hash
     end
   end
 
+  def reset_queries
+    @hash = nil
+    @records = nil
+  end
+
   def to_a
     @records ||= fetch_records
   end
@@ -127,4 +137,17 @@ class RPCMapper::Relation
     @klass.send(:fetch_records, self)
   end
 
+  private
+
+  def call_procs(values)
+    case values
+    when Array:
+      values.collect { |v| v.is_a?(Proc) ? v.call : v }
+    when Proc:
+      values.call
+    else
+      values
+    end
+  end
+
 end

data/lib/rpc_mapper/relation/query_methods.rb

@@ -8,33 +8,33 @@ module RPCMapper::QueryMethods
     if block_given?
       to_a.select {|*block_args| yield(*block_args) }
     else
-      clone.tap { |r| r.select_values += args if args && !args.empty? }
+      clone.tap { |r| r.select_values += args if args_valid? args }
     end
   end
 
   def group(*args)
-    clone.tap { |r| r.group_values += args if args && !args.empty? }
+    clone.tap { |r| r.group_values += args if args_valid? args }
   end
 
   def order(*args)
-    clone.tap { |r| r.order_values += args if args && !args.empty? }
+    clone.tap { |r| r.order_values += args if args_valid? args }
   end
 
   def joins(*args)
-    clone.tap { |r| r.joins_values += args if args && !args.empty? }
+    clone.tap { |r| r.joins_values += args if args_valid?(args) }
   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? }
+    clone.tap { |r| r.includes_values += (r.includes_values + args).flatten.uniq if args_valid? args }
   end
 
   def where(*args)
-    clone.tap { |r| r.where_values += args.compact.reject(&:empty?) if args && !args.empty? }
+    clone.tap { |r| r.where_values += args.compact.select { |i| args_valid? i } if args_valid? args }
   end
 
   def having(*args)
-    clone.tap { |r| r.having_values += args if args && !args.empty? }
+    clone.tap { |r| r.having_values += args if args_valid? args }
   end
 
   def limit(value = true)
@@ -52,7 +52,7 @@ module RPCMapper::QueryMethods
   def fresh(val=true)
     clone.tap do |r|
       r.fresh_value = val
-      r.instance_variable_set(:@records, nil) if r.fresh_value
+      r.reset_queries if r.fresh_value
     end
   end
 
@@ -60,4 +60,10 @@ module RPCMapper::QueryMethods
     clone.tap { |r| r.raw_sql_value = raw_sql }
   end
 
+  protected
+
+  def args_valid?(args)
+    args.respond_to?(:empty?) ? !args.empty? : !!args
+  end
+
 end

data/lib/rpc_mapper/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rpc-mapper
 version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
+  hash: 19
+  prerelease: 
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Travis Petticrew
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-03 00:00:00 -06:00
+date: 2011-02-28 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -179,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: Ruby library for querying and mapping data over RPC