mochigome 0.2.2 → 0.2.3

data/lib/mochigome_ver.rb

@@ -1,3 +1,3 @@
 module Mochigome
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/lib/model_extensions.rb

@@ -189,6 +189,7 @@ module Mochigome
       @options[:custom_subgroup_exprs] = ActiveSupport::OrderedHash.new
       @options[:custom_assocs] = ActiveSupport::OrderedHash.new
       @options[:ignore_assocs] = Set.new
+      @options[:preferred_paths] = {}
     end
 
     def type_name(n)
@@ -247,6 +248,10 @@ module Mochigome
     def ignore_assoc(name)
       @options[:ignore_assocs].add name.to_sym
     end
+
+    def preferred_path_to(target_model, assoc_name)
+      @options[:preferred_paths][target_model.name] = assoc_name
+    end
   end
 
   class AggregationSettings

data/lib/model_graph.rb

@@ -120,7 +120,8 @@ module Mochigome
 
         ignore_assocs = []
         if model.acts_as_mochigome_focus?
-          ignore_assocs = model.mochigome_focus_settings.options[:ignore_assocs]
+          opts = model.mochigome_focus_settings.options
+          ignore_assocs = opts[:ignore_assocs]
         end
 
         model.reflections.
@@ -157,12 +158,6 @@ module Mochigome
       end
 
       added_models.each do |model|
-        # FIXME: Un-DRY, this is a C&P from above
-        ignore_assocs = []
-        if model.acts_as_mochigome_focus?
-          ignore_assocs = model.mochigome_focus_settings.options[:ignore_assocs]
-        end
-
         next unless @assoc_graph.has_vertex?(model)
         path_tree = @assoc_graph.bfs_search_tree_from(model).reverse
         path_tree.depth_first_search do |tgt_model|
@@ -173,10 +168,22 @@ module Mochigome
           end
           @shortest_paths[[model,tgt_model]] = path
         end
+      end
+
+      added_models.each do |model|
+        ignore_assocs, model_preferred_paths = [], {}
+        if model.acts_as_mochigome_focus?
+          opts = model.mochigome_focus_settings.options
+          ignore_assocs = opts[:ignore_assocs]
+          model_preferred_paths = opts[:preferred_paths]
+        end
+
+        preferred_paths = {}
 
         # Use through reflections as a hint for preferred indirect paths
-        model.reflections.
-        select{|name, assoc| assoc.through_reflection}.
+        # TODO Support for nested through reflections
+        # (Though Rails 2 doesn't support them either...)
+        model.reflections.select{|name, assoc| assoc.through_reflection}.
         reject{|name, assoc| ignore_assocs.include? name.to_sym}.
         reject{|name, assoc| ignore_assocs.include? assoc.through_reflection.name.to_sym}.
         to_a.sort{|a,b| a.first.to_s <=> b.first.to_s}.
@@ -187,9 +194,60 @@ module Mochigome
           rescue NameError
             # FIXME Can't handle polymorphic through reflection
           end
-          edge = [model,foreign_model]
-          next if @shortest_paths[edge].try(:size).try(:<, 3)
-          @shortest_paths[edge] = [model, join_model, foreign_model]
+          edge = [model, foreign_model]
+          path = [model, join_model, foreign_model]
+          next if @shortest_paths[edge].try(:size).try(:<, path.size)
+          preferred_paths[edge] = path
+        end
+
+        # Model focus can specify paths with prefered_path_to
+        model_preferred_paths.each do |tgt_model_name, assoc_name|
+          tgt_model = tgt_model_name.constantize
+          edge = [model, tgt_model]
+          assoc = model.reflections[assoc_name]
+          sub_path = @shortest_paths[[assoc.klass, tgt_model]]
+          unless sub_path
+            raise ModelSetupError.new(
+              "Can't find subpath to #{tgt_model} via #{model.name}.#{assoc_name}"
+            )
+          end
+          if sub_path.include?(model)
+            raise ModelSetupError.new(
+              "Subpath to #{tgt_model} via #{model.name}.#{assoc_name} loops back"
+            )
+          end
+          sub_link = @shortest_paths[[model, assoc.klass]]
+          preferred_paths[edge] = sub_link + sub_path.drop(1)
+        end
+
+        # Replace all instances of the default path in the path directory
+        # with the preferred path, including when the default path is
+        # a subset of a larger path, and/or when the direction of travel
+        # is reversed.
+        # FIXME What if preferred paths conflict?
+        # FIXME What if one preferred path causes a shortest_path to become
+        # applicable under another one? Then arbitrary model scanning
+        # order matters, and it shouldn't. Is there even a consistent
+        # way to deal with this?
+        preferred_paths.each do |edge, path|
+          [lambda{|a| a}, lambda{|a| a.reverse}].each do |prc|
+            e, p = prc.call(edge), prc.call(path)
+            old_path = @shortest_paths[e]
+            next if old_path == p
+            edges_to_replace = {}
+            @shortest_paths.each do |se, sp|
+              p_begin = sp.find_index(old_path.first)
+              if p_begin && sp[p_begin, old_path.size] == old_path
+                edges_to_replace[se] =
+                  sp.take(p_begin) +
+                  p +
+                  sp.drop(p_begin + old_path.size)
+              end
+            end
+            edges_to_replace.each do |re, rp|
+              @shortest_paths[re] = rp
+            end
+          end
         end
       end
     end

data/lib/relation.rb

@@ -51,8 +51,8 @@ module Mochigome
         end
       end
 
-      raise QueryError.new("No path to #{model}") unless best_path
-      join_on_path(best_path)
+      raise QueryError.new("No path to #{model} from #{@models.map(&:name).inspect}") unless best_path
+      join_on_path best_path, "Best path to model #{model}"
 
       # Also use the conditions of any other unique path
       # TODO: Write a test that requires the below code to work
@@ -60,22 +60,22 @@ module Mochigome
         extra_path = @model_graph.path_thru([n, model])
         if extra_path
           unless best_path.all?{|m| extra_path.include?(m)}
-            join_on_path extra_path
+            join_on_path extra_path, "Additional path to model #{model}"
           end
         end
       end
     end
 
-    def join_on_path_thru(path)
+    def join_on_path_thru(path, descrip = nil)
       full_path = @model_graph.path_thru(path)
       if full_path
-        join_on_path(full_path)
+        join_on_path(full_path, descrip || "Generic path thru #{path.map(&:name).inspect}")
       else
         raise QueryError.new("Cannot route thru #{path.map(&:name).inspect}")
       end
     end
 
-    def join_on_path(path, options = {})
+    def join_on_path(path, descrip = "Generic")
       begin
         path = path.map(&:to_real_model).uniq
         join_to_model path.first
@@ -89,7 +89,7 @@ module Mochigome
             join_descrips << tgt.name
           end
         end
-        @join_path_descriptions << join_descrips.join("->")
+        @join_path_descriptions << "#{join_descrips.join("->")} (#{descrip})"
       rescue QueryError => e
         raise QueryError.new("Error pathing #{path.map(&:name).inspect}: #{e}")
       end
@@ -130,7 +130,7 @@ module Mochigome
             # FIXME: Eventually we need to support joins that
             # double back, if only for CanCan stuff, so get rid of this
             # uniq junk.
-            join_on_path_thru path.uniq
+            join_on_path_thru path.uniq, "Access filter for #{m.name}"
           end
           if h[:condition]
             apply_condition h.delete(:condition)

data/test/app_root/app/models/favorite.rb

@@ -0,0 +1,6 @@
+class Favorite < ActiveRecord::Base
+  acts_as_mochigome_focus
+
+  belongs_to :owner
+  belongs_to :product
+end

data/test/app_root/app/models/owner.rb

@@ -1,9 +1,11 @@
 class Owner < ActiveRecord::Base
   acts_as_mochigome_focus do |f|
     f.fieldset :age, ["birth_date", "age"]
+    f.preferred_path_to Product, :stores
   end
 
   has_many :stores
+  has_many :favorites
 
   def name(reverse = false)
     if reverse

data/test/app_root/app/models/product.rb

@@ -33,6 +33,7 @@ class Product < ActiveRecord::Base
   has_many :store_products
   has_many :stores, :through => :store_products
   has_many :sales, :through => :store_products
+  has_many :favorites
 
   validates_presence_of :name
   validates_presence_of :price

data/test/app_root/db/migrate/20110817163830_create_tables.rb

@@ -38,6 +38,12 @@ class CreateTables < ActiveRecord::Migration
       t.timestamps
     end
 
+    # Used to create an alternate path to try and confuse ModelGraph
+    create_table :favorites do |t|
+      t.integer :owner_id
+      t.integer :product_id
+    end
+
     # Used by ModelExtensionTest to create temporary models
     create_table :fake do |t|
       t.timestamps

data/test/factories.rb

@@ -33,6 +33,11 @@ FactoryGirl.define do
     store_product
   end
 
+  factory :favorite do
+    owner
+    product
+  end
+
   factory :boring_datum do
     foo 'Bar'
   end

data/test/unit/query_test.rb

@@ -41,6 +41,11 @@ describe Mochigome::Query do
       n.times{create(:sale, :store_product => sp)}
     end
 
+    create(:favorite, :owner => @john, :product => @product_c)
+    create(:favorite, :owner => @john, :product => @product_d)
+    create(:favorite, :owner => @jane, :product => @product_c)
+    create(:favorite, :owner => @jane, :product => @product_a)
+
     (1..5).each do |div_num|
       WidgetDivisor.create(:divisor => div_num)
     end
@@ -318,6 +323,20 @@ describe Mochigome::Query do
     assert_empty data_node.children
   end
 
+  it "can collect aggregate data in non-association-order layer designs" do
+    q = Mochigome::Query.new([Product, Owner, Store], :aggregate_sources => [Sale])
+    data_node = q.run
+    assert_equal_children [
+      @product_a, @product_b, @product_c, @product_d, @product_e
+    ], data_node
+    assert_equal_children [@john, @jane], data_node/0
+    assert_equal_children [@jane], data_node/1
+    assert_equal_children [@store_x], data_node/0/0
+    assert_equal_children [@store_y], data_node/1/0
+    assert_equal 9, (data_node/0)["Sales count"]
+    assert_equal 5, (data_node/0/0)["Sales count"]
+  end
+
   it "can use a named aggregate data setting" do
     q = Mochigome::Query.new(
       [Owner],
@@ -531,7 +550,7 @@ describe Mochigome::Query do
 
   # TODO: Test use of non-trivial function for aggregation value
 
-  it "puts a comment on the root node describing the query" do
+  it "sets a comment on the root node describing the query" do
     q = Mochigome::Query.new([Owner, Store, Product])
     data_node = q.run([@store_x, @store_y, @store_z])
     c = data_node.comment

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-03 00:00:00 Z
+date: 2012-10-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -121,6 +121,7 @@ files:
 - test/app_root/app/helpers/application_helper.rb
 - test/app_root/app/models/boring_datum.rb
 - test/app_root/app/models/category.rb
+- test/app_root/app/models/favorite.rb
 - test/app_root/app/models/owner.rb
 - test/app_root/app/models/product.rb
 - test/app_root/app/models/sale.rb