mochigome 0.1.6 → 0.1.7

data/TODO

@@ -4,5 +4,5 @@
   - Alternately, always ignore conditional associations unless they're specifically provided to Mochigome by the model
 - Named subsets of different fields and agg fields on a single model
 - Some kind of single-page preview on the edit screen would be cool. Maybe use FOP with fake data and the PNG output option?
-- Allow inwards-branching join patterns on layer list (i.e. Category->Store->Product)
 - Automatically set default to 0 on sum and count aggregation
+- Treat through-associations as hints for preferred paths

data/lib/mochigome_ver.rb

@@ -1,3 +1,3 @@
 module Mochigome
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/model_extensions.rb

@@ -54,37 +54,35 @@ module Mochigome
         write_inheritable_attribute :mochigome_aggregation_settings, settings
       end
 
-      def arelified_assoc(name)
+      def assoc_condition(name)
         # TODO: Deal with polymorphic assocs.
         model = self
         assoc = reflect_on_association(name)
         raise AssociationError.new("No such assoc #{name}") unless assoc
         table = Arel::Table.new(table_name)
         ftable = Arel::Table.new(assoc.klass.table_name)
-        lambda do |r|
-          # FIXME: This acts as though arel methods are non-destructive,
-          # but they are, right? Except, I can't remove the rel
-          # assignment from relation_over_path...
-          cond = nil
-          if assoc.belongs_to?
-            cond = table[assoc.association_foreign_key].eq(
-              ftable[assoc.klass.primary_key]
-            )
-          else
-            cond = table[primary_key].eq(ftable[assoc.primary_key_name])
-          end
-
-          if assoc.options[:as]
-            # FIXME Can we assume that this is the polymorphic type field?
-            cond = cond.and(ftable["#{assoc.options[:as]}_type"].eq(model.name))
-          end
 
-          # TODO: Apply association conditions.
+        # FIXME: This acts as though arel methods are non-destructive,
+        # but they are, right? Except, I can't remove the rel
+        # assignment from relation_over_path...
+        cond = nil
+        if assoc.belongs_to?
+          cond = table[assoc.association_foreign_key].eq(
+            ftable[assoc.klass.primary_key]
+          )
+        else
+          cond = table[primary_key].eq(ftable[assoc.primary_key_name])
+        end
 
-          r.join(ftable, Arel::Nodes::InnerJoin).on(cond)
+        if assoc.options[:as]
+          # FIXME Can we assume that this is the polymorphic type field?
+          cond = cond.and(ftable["#{assoc.options[:as]}_type"].eq(model.name))
         end
-      end
 
+        # TODO: Apply association conditions.
+
+        return cond
+      end
     end
 
     module InstanceMethods
@@ -99,17 +97,31 @@ module Mochigome
   # in there?
 
   def self.null_unless(pred, value_func)
+    case_expr(
+      lambda {|t| pred.call(value_func.call(t))},
+      value_func,
+      Arel::Nodes::SqlLiteral.new("NULL")
+    )
+  end
+
+  def self.case_expr(table_pred, then_val, else_val)
     lambda {|t|
-      value = value_func.call(t)
-      val_expr = Arel::Nodes::NamedFunction.new('',[value])
       Arel::Nodes::SqlLiteral.new(
-        "(CASE WHEN #{pred.call(value).to_sql} THEN #{val_expr.to_sql} ELSE NULL END)"
+        "(CASE WHEN #{arel_exprify(table_pred, t)} " +
+        "THEN #{arel_exprify(then_val, t)} " +
+        "ELSE #{arel_exprify(else_val, t)} END)"
       )
     }
   end
 
   private
 
+  def self.arel_exprify(e, t = nil)
+    e = e.call(t) if e.respond_to?(:call)
+    e = Arel::Nodes::NamedFunction.new('',[e]) unless e.respond_to?(:to_sql)
+    e.to_sql
+  end
+
   class ReportFocus
     attr_reader :type_name
     attr_reader :fields
@@ -143,6 +155,7 @@ module Mochigome
       @model = model
       @options = {}
       @options[:fields] = []
+      @options[:custom_subgroup_exprs] = {}
     end
 
     def type_name(n)
@@ -183,6 +196,10 @@ module Mochigome
         end
       end
     end
+
+    def custom_subgroup_expression(name, expr)
+      @options[:custom_subgroup_exprs][name] = expr
+    end
   end
 
   class AggregationSettings

data/lib/model_graph.rb

@@ -11,7 +11,7 @@ module Mochigome
       @graphed_models = Set.new
       @table_to_model = {}
       @assoc_graph = RGL::DirectedAdjacencyGraph.new
-      @edge_relation_funcs = {}
+      @edge_conditions = {}
       @shortest_paths = {}
     end
 
@@ -29,20 +29,13 @@ module Mochigome
       r
     end
 
-    def relation_over_path(path)
-      update_assoc_graph(path)
-      real_path = path.map(&:to_real_model).uniq
-      # Project ensures that we return a Rel, not a Table, even if path is empty
-      rel = real_path.first.arel_table.project
-      (0..(real_path.size-2)).each do |i|
-        rel = relation_func(real_path[i], real_path[i+1]).call(rel)
-      end
-      rel
+    def relation_init(model)
+      update_assoc_graph([model])
+      model.arel_table.project # Project to convert Arel::Table to Arel::Rel
     end
 
-    def relation_func(u, v)
-      @edge_relation_funcs[[u,v]] or
-        raise QueryError.new "No assoc from #{u.name} to #{v.name}"
+    def edge_condition(u, v)
+      @edge_conditions[[u,v]]
     end
 
     def path_thru(models)
@@ -119,7 +112,7 @@ module Mochigome
           edge = [model, foreign_model]
           next if @assoc_graph.has_edge?(*edge) # Ignore duplicate assocs
           @assoc_graph.add_edge(*edge)
-          @edge_relation_funcs[edge] = model.arelified_assoc(name)
+          @edge_conditions[edge] = model.assoc_condition(name)
         end
       end
 

data/lib/query.rb

@@ -22,13 +22,11 @@ module Mochigome
           else [a, a]
         end
 
-        agg_rel = Relation.new(@layer_types) # TODO Only go as far as focus
-        agg_rel.join_to_model(focus_model)
+        agg_rel = Relation.new(@layer_types)
         agg_rel.join_on_path_thru([focus_model, data_model])
         agg_rel.apply_access_filter_func(@access_filter)
 
-        key_models = @ids_rel.spine_layers_thru(focus_model)
-        key_cols = key_models.map{|m| m.arel_primary_key}
+        key_cols = @ids_rel.spine_layers.map{|m| m.arel_primary_key}
 
         agg_fields = data_model.mochigome_aggregation_settings.
           options[:fields].reject{|a| a[:in_ruby]}
@@ -83,8 +81,10 @@ module Mochigome
         Mochigome Version: #{Mochigome::VERSION}
         Report Generated: #{Time.now}
         Layers: #{@layer_types.map(&:name).join(" => ")}
-        AR Path: #{@ids_rel.full_spine_path.map(&:name).join(" => ")}
       eos
+      @ids_rel.joins.each do |src, tgt|
+        root.comment += "Join: #{src.name} -> #{tgt.name}\n"
+      end
       root.comment.gsub!(/(\n|^) +/, "\\1")
 
       r = @ids_rel.clone
@@ -191,14 +191,24 @@ module Mochigome
   private
 
   class Relation
+    attr_reader :joins, :spine_layers
+
     def initialize(layers)
       @model_graph = ModelGraph.new
       @spine_layers = layers
-      @spine = @model_graph.path_thru(layers) or
-        raise QueryError.new("No valid path thru #{layers.inspect}") #TODO Test
-      @models = Set.new @spine.map(&:to_real_model)
-      @rel = @model_graph.relation_over_path(@spine)
-
+      @models = Set.new
+      @spine = []
+      @joins = []
+
+      @spine_layers.map(&:to_real_model).uniq.each do |m|
+        if @rel
+          join_to_model(m)
+        else
+          @rel = @model_graph.relation_init(m)
+          @models.add m
+        end
+        @spine << m
+      end
       @spine_layers.each{|m| select_model_id(m)}
     end
 
@@ -210,16 +220,6 @@ module Mochigome
       @rel.to_sql
     end
 
-    def full_spine_path
-      @spine.dup
-    end
-
-    def spine_layers_thru(model)
-      r = @spine.take_while{|m| m != model}
-      r << model unless r.size == @spine.size
-      r.select{|m| @spine_layers.include? m}
-    end
-
     def clone
       c = super
       c.instance_variable_set :@models, @models.clone
@@ -241,6 +241,14 @@ module Mochigome
 
       raise QueryError.new("No path to #{model}") unless best_path
       join_on_path(best_path)
+
+      # TODO: Write a test that requires the below code to work
+      @models.reject{|n| best_path.include?(n)}.each do |n|
+        cond = @model_graph.edge_condition(n, model)
+        if cond
+          @rel = @rel.where(cond)
+        end
+      end
     end
 
     def join_on_path_thru(path)
@@ -254,8 +262,9 @@ module Mochigome
 
     def join_on_path(path)
       path = path.map(&:to_real_model).uniq
+      join_to_model path.first
       (0..(path.size-2)).map{|i| [path[i], path[i+1]]}.each do |src, tgt|
-        add_join_link src, tgt
+        add_join_link(src, tgt) unless @models.include?(tgt)
       end
     end
 
@@ -305,9 +314,11 @@ module Mochigome
     def add_join_link(src, tgt)
       raise QueryError.new("Can't join from #{src}, not available") unless
         @models.include?(src)
-      return if @models.include?(tgt) # TODO Maybe still apply join conditions?
-      @rel = @model_graph.relation_func(src, tgt).call(@rel)
+      @rel = @rel.join(tgt.arel_table, Arel::Nodes::InnerJoin).on(
+        @model_graph.edge_condition(src, tgt)
+      )
       @models.add tgt
+      @joins << [src, tgt]
     end
   end
 end

data/lib/subgroup_model.rb

@@ -8,6 +8,11 @@ module Mochigome
     def initialize(model, attr)
       @model = model
       @attr = attr
+      if @model.mochigome_focus_settings
+        s = @model.mochigome_focus_settings
+        # @attr_expr will just be nil if there's no custom subgroup expr here
+        @attr_expr = s.options[:custom_subgroup_exprs][attr]
+      end
       @focus_settings = Mochigome::ReportFocusSettings.new(@model)
       @focus_settings.type_name "#{@model.human_name} #{@attr.to_s.humanize}"
       @focus_settings.name lambda{|r| r.send(attr)}
@@ -38,7 +43,11 @@ module Mochigome
     end
 
     def arel_primary_key
-      arel_table[@attr]
+      if @attr_expr
+        @attr_expr
+      else
+        arel_table[@attr]
+      end
     end
 
     def connection

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

@@ -1,6 +1,13 @@
 class Product < ActiveRecord::Base
   acts_as_mochigome_focus do |f|
     f.fields [:price]
+    f.custom_subgroup_expression :name_ends_with_vowel,
+      Mochigome::case_expr(
+        Arel::Nodes::NamedFunction.new("SUBSTR", [Product.arel_table[:name], -1]).
+          in(['a','e','i','o','u','A','E','I','O','U']),
+        "Vowel",
+        "Consonant"
+      ).call(Product.arel_table)
   end
   has_mochigome_aggregations do |a|
     a.fields [

data/test/unit/model_extensions_test.rb

@@ -364,8 +364,8 @@ describe "an ActiveRecord model" do
     assert agg[:in_ruby]
   end
 
-  def assoc_query_words_match(assoc, words)
-    q = assoc.call(Arel::Table.new(:foo).project(Arel.star)).to_sql
+  def assoc_query_words_match(tbl, cond, words)
+    q = Arel::Table.new(:foo).project(Arel.star).join(Arel::Table.new(tbl)).on(cond).to_sql
     cur_word = words.shift
     q.split(/[ .]/).each do |s_word|
       if s_word.gsub(/["'`]+/, '').downcase == cur_word.downcase
@@ -380,7 +380,7 @@ describe "an ActiveRecord model" do
     @model_class.class_eval do
       belongs_to :store
     end
-    assert assoc_query_words_match @model_class.arelified_assoc(:store),
+    assert assoc_query_words_match "stores", @model_class.assoc_condition(:store),
       %w{select * from foo join stores on fake store_id = stores id}
   end
 
@@ -388,7 +388,7 @@ describe "an ActiveRecord model" do
     @model_class.class_eval do
       has_many :stores
     end
-    assert assoc_query_words_match @model_class.arelified_assoc(:stores),
+    assert assoc_query_words_match "stores", @model_class.assoc_condition(:stores),
       %w{select * from foo join stores on fake id = stores whale_id}
   end
 
@@ -396,13 +396,13 @@ describe "an ActiveRecord model" do
     @model_class.class_eval do
       has_one :store
     end
-    assert assoc_query_words_match @model_class.arelified_assoc(:store),
+    assert assoc_query_words_match "stores", @model_class.assoc_condition(:store),
       %w{select * from foo join stores on fake id = stores whale_id}
   end
 
   it "raises AssociationError on attempting to arelify a non-extant assoc" do
     assert_raises Mochigome::AssociationError do
-      Store.arelified_assoc(:dinosaurs)
+      Store.assoc_condition(:dinosaurs)
     end
   end
 

data/test/unit/query_test.rb

@@ -180,7 +180,52 @@ describe Mochigome::Query do
     assert_equal 8, (data_node/1)['Sales count']
   end
 
-  # TODO: Test diamond patterns
+  it "can subgroup layers with custom expressions" do
+    q = Mochigome::Query.new(
+      [
+        Store,
+        Mochigome::SubgroupModel.new(Product, :name_ends_with_vowel),
+        Product
+      ]
+    )
+    data_node = q.run
+    assert_equal "Jane's Store (North)", (data_node/1).name
+    assert_equal "Consonant", (data_node/1/0).name
+    assert_equal 1, (data_node/1/0).children.size
+    assert_equal "Vowel", (data_node/1/1).name
+    assert_equal 2, (data_node/1/1).children.size
+  end
+
+  it "can collect aggregate data with custom expression subgroups" do
+    q = Mochigome::Query.new(
+      [
+        Store,
+        Mochigome::SubgroupModel.new(Product, :name_ends_with_vowel),
+      ],
+      :aggregate_sources => [Product]
+    )
+    data_node = q.run
+    assert_equal "Jane's Store (North)", (data_node/1).name
+    assert_equal "Consonant", (data_node/1/0).name
+    assert_equal @product_b.price, (data_node/1/0)['Products sum price']
+    assert_equal "Vowel", (data_node/1/1).name
+    assert_equal [@product_a, @product_e].map(&:price).sum,
+      (data_node/1/1)['Products sum price']
+  end
+
+  it "can group through a list that has no direct association path" do
+    q = Mochigome::Query.new(
+      [Category, Store, Product],
+      :aggregate_sources => [Sale]
+    )
+    data_node = q.run
+    assert_equal "Category 1", (data_node/0).name
+    assert_equal 15, (data_node/0)["Sales count"]
+    assert_equal "John's Store", (data_node/0/0).name
+    assert_equal 5, (data_node/0/0)["Sales count"]
+    assert_equal "Product A", (data_node/0/0/0).name
+    assert_equal 5, (data_node/0/0/0)["Sales count"]
+  end
 
   it "collects aggregate data by grouping on all layers" do
     q = Mochigome::Query.new(
@@ -305,20 +350,6 @@ describe Mochigome::Query do
     assert_equal 24, data_node['Sales count']
   end
 
-  it "does not collect aggregate data for layers below focus" do
-    q = Mochigome::Query.new(
-      [Owner, Store, Product, Category],
-      :aggregate_sources => [[Product, Sale]]
-    )
-    data_node = q.run
-
-    assert_equal "Product", (data_node/0/0/0)[:internal_type]
-    refute_nil (data_node/0/0/0)['Sales count']
-
-    assert_equal "Category", (data_node/0/0/0/0)[:internal_type]
-    assert_nil (data_node/0/0/0/0)['Sales count']
-  end
-
   it "can collect aggregate data involving joins to tables not on path" do
     q = Mochigome::Query.new(
       [Owner, Store],
@@ -432,7 +463,7 @@ describe Mochigome::Query do
     assert_match c, /^Mochigome Version: #{Mochigome::VERSION}\n/
     assert_match c, /\nReport Generated: \w{3} \w{3} \d+ .+\n/
     assert_match c, /\nLayers: Owner => Store => Product\n/
-    assert_match c, /\nAR Path: Owner => Store => StoreProduct => Product\n/
+    assert_match c, /\nJoin: \w+ -> \w+\n/
   end
 
   it "names the root node 'report' by default" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 1
-  - 6
-  version: 0.1.6
+  - 7
+  version: 0.1.7
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-28 00:00:00 Z
+date: 2012-05-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement