mochigome 0.2.1 → 0.2.2

data/lib/mochigome_ver.rb

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

data/lib/model_extensions.rb

@@ -6,7 +6,7 @@ module Mochigome
       base.write_inheritable_attribute :mochigome_focus_settings, nil
       base.class_inheritable_reader :mochigome_focus_settings
 
-      # FIXME: Unclear on how this interacts with inheritance...
+      # FIXME: Unclear on how this should interact with inheritance...
       base.write_inheritable_attribute :mochigome_aggregation_settings_sets, {}
       base.class_inheritable_reader :mochigome_aggregation_settings_sets
     end

data/lib/query.rb

@@ -3,7 +3,8 @@ module Mochigome
     def initialize(layers, options = {})
       @name = options.delete(:root_name).try(:to_s) || "report"
       access_filter = options.delete(:access_filter) || lambda {|cls| {}}
-      aggregate_sources = options.delete(:aggregate_sources) || []
+      aggregate_sources = options.delete(:aggregate_sources) || {}
+      @fieldsets = options.delete(:fieldsets) || {}
       unless options.empty?
         raise QueryError.new("Unknown options: #{options.keys.inspect}")
       end
@@ -21,8 +22,32 @@ module Mochigome
       layer_paths = [[]] if layer_paths.empty? # Create at least one QueryLine
       @lines = layer_paths.map{ |path| QueryLine.new(path, access_filter) }
 
-      aggregate_sources.each do |a|
-        @lines.each{|line| line.add_aggregate_source(a)}
+      # Given a simple array of aggregates, just apply to every point
+      if aggregate_sources.is_a?(Array)
+        as_hash = ActiveSupport::OrderedHash.new
+        aggregate_sources.each do |a|
+          layer_paths.each do |path|
+            (0..path.size).each do |len|
+              key = [:report] + path.take(len)
+              as_hash[key] ||= []
+              as_hash[key] << a unless as_hash[key].include?(a)
+            end
+          end
+        end
+        aggregate_sources = as_hash
+      end
+
+      aggregate_sources.each do |path, aggs|
+        models_path = path.drop(1) # Remove the :report symbol at the start
+        tgt_line = @lines.find do |line|
+          line.layer_path.take(models_path.size) == models_path
+        end
+        unless tgt_line
+          raise QueryError.new("Cannot find path #{path.inspect} for agg")
+        end
+        aggs.each do |a|
+          tgt_line.add_aggregate_source(models_path.size, a)
+        end
       end
     end
 
@@ -32,7 +57,7 @@ module Mochigome
       @lines.each do |line|
         tbl = line.build_id_table(cond)
         parent_models = []
-        line.layer_types.each do |model|
+        line.layer_path.each do |model|
           tbl.each do |ids_row|
             i = ids_row["#{model.name}_id"]
             if i
@@ -82,6 +107,7 @@ module Mochigome
     def generate_datanodes(model_ids)
       model_datanodes = {}
       model_ids.keys.each do |model|
+        model_datanodes[model.name] ||= {}
         # TODO: Find a way to do this without loading all recs at one time
         model.all(
           :conditions => {model.primary_key => model_ids[model].to_a},
@@ -89,10 +115,10 @@ module Mochigome
         ).each_with_index do |rec, seq_idx|
           f = rec.mochigome_focus
           dn = DataNode.new(f.type_name, f.name)
-          dn.merge!(f.field_data)
+          dn.merge!(f.field_data(@fieldsets[model]))
           dn[:id] = rec.id
           dn[:internal_type] = model.name
-          (model_datanodes[model.name] ||= {})[rec.id] = [dn, seq_idx]
+          model_datanodes[model.name][rec.id] = [dn, seq_idx]
         end
       end
       return model_datanodes
@@ -113,7 +139,7 @@ module Mochigome
         # by the order of the records themselves.
         # TODO: This way of getting model_idx could create problems
         # if a class appears more than once in the tree.
-        model_idx = @lines.index{|line| line.layer_types.any?{|m| m.name == model}}
+        model_idx = @lines.index{|line| line.layer_path.any?{|m| m.name == model}}
         (ordered_children[model_idx] ||= {})[seq_idx] = dn
       end
       ordered_children.keys.sort.each do |k|
@@ -130,7 +156,7 @@ module Mochigome
       root.comment += "Report Generated: #{Time.now}\n"
       @lines.each_with_index do |line, i|
         root.comment += "Query Line #{i+1}:\n"
-        root.comment += "  #{line.layer_types.map(&:name).join("=>")}\n"
+        root.comment += "  #{line.layer_path.map(&:name).join("=>")}\n"
         root.comment += "  Join Paths:\n"
         line.ids_rel.join_path_descriptions.each do |d|
           root.comment += "    #{d}\n"
@@ -143,21 +169,21 @@ module Mochigome
   private
 
   class QueryLine
-    attr_accessor :layer_types
+    attr_accessor :layer_path
     attr_accessor :ids_rel
 
-    def initialize(layer_types, access_filter)
+    def initialize(layer_path, access_filter)
       # TODO: Validate layer types: not empty, AR, act_as_mochigome_focus
-      @layer_types = layer_types
+      @layer_path = layer_path
       @access_filter = access_filter
 
-      @ids_rel = Relation.new(@layer_types)
+      @ids_rel = Relation.new(@layer_path)
       @ids_rel.apply_access_filter_func(@access_filter)
 
       @aggregate_rels = ActiveSupport::OrderedHash.new
     end
 
-    def add_aggregate_source(a)
+    def add_aggregate_source(depth, a)
       focus_model, data_model, agg_setting_name = nil, nil, nil
       if a.is_a?(Array) then
         focus_model = a.select{|e| e.is_a?(Class)}.first
@@ -167,17 +193,19 @@ module Mochigome
         focus_model = data_model = a
         agg_setting_name = :default
       end
-      # FIXME Raise exception if a isn't in a correct format
-
-      agg_rel = Relation.new(@layer_types)
-      agg_rel.join_on_path_thru([focus_model, data_model])
-      agg_rel.apply_access_filter_func(@access_filter)
+      # TODO Raise exception if a isn't correctly formatted
 
-      key_cols = @ids_rel.spine_layers.map{|m| m.arel_primary_key}
+      agg_rel = Relation.new(@layer_path.take(depth))
+      key_cols = agg_rel.spine_layers.map{|m| m.arel_primary_key}
+      data_cols = key_cols + [data_model.arel_primary_key]
 
       agg_fields = data_model.
         mochigome_aggregation_settings(agg_setting_name).
         options[:fields].reject{|a| a[:in_ruby]}
+
+      agg_rel.join_on_path_thru([focus_model, data_model])
+      agg_rel.apply_access_filter_func(@access_filter)
+
       agg_fields.each_with_index do |a, i|
         d_expr = a[:value_proc].call(data_model.arel_table)
         d_expr = d_expr.expr if d_expr.respond_to?(:expr)
@@ -187,36 +215,34 @@ module Mochigome
       agg_rel_key = {
         :focus_model => focus_model,
         :data_model => data_model,
-        :agg_setting_name => agg_setting_name
+        :agg_setting_name => agg_setting_name,
+        :depth => depth
       }
 
-      @aggregate_rels[agg_rel_key] = (0..key_cols.length).map{|n|
-        lambda {|cond|
-          data_rel = agg_rel.clone
-          data_rel.apply_condition(cond)
-          data_cols = key_cols.take(n) + [data_model.arel_primary_key]
-          inner_rel = data_rel.to_arel
-          data_cols.each_with_index do |col, i|
-            inner_rel.project(col.as("g%03u" % i)).group(col)
-          end
+      @aggregate_rels[agg_rel_key] = lambda {|cond|
+        inner_rel = agg_rel.dup
+        inner_rel.apply_condition(cond)
+        inner_query = inner_rel.to_arel
+        data_cols.each_with_index do |col, i|
+          inner_query.project(col.as("g%03u" % i)).group(col)
+        end
 
-          # FIXME: This subtable won't be necessary for all aggregation funcs.
-          # When we can avoid it, we should, for performance.
-          rel = Arel::SelectManager.new(
-            Arel::Table.engine,
-            Arel.sql("(#{inner_rel.to_sql}) as mochigome_data")
-          )
-          d_tbl = Arel::Table.new("mochigome_data")
-          agg_fields.each_with_index do |a, i|
-            name = "d%03u" % i
-            rel.project(a[:agg_proc].call(d_tbl[name]).as(name))
-          end
-          key_cols.take(n).each_with_index do |col, i|
-            name = "g%03u" % i
-            rel.project(d_tbl[name].as(name)).group(name)
-          end
-          rel
-        }
+        # FIXME: This subselect won't be necessary for all aggregation funcs.
+        # When we can avoid it, we should, because subselects are slow.
+        rel = Arel::SelectManager.new(
+          Arel::Table.engine,
+          Arel.sql("(#{inner_query.to_sql}) as mochigome_data")
+        )
+        d_tbl = Arel::Table.new("mochigome_data")
+        agg_fields.each_with_index do |a, i|
+          name = "d%03u" % i
+          rel.project(a[:agg_proc].call(d_tbl[name]).as(name))
+        end
+        key_cols.each_with_index do |col, i|
+          name = "g%03u" % i
+          rel.project(d_tbl[name].as(name)).group(name)
+        end
+        rel
       }
     end
 
@@ -230,7 +256,7 @@ module Mochigome
     end
 
     def build_id_table(cond)
-      if @layer_types.empty?
+      if @layer_path.empty?
         return []
       else
         r = @ids_rel.clone
@@ -245,40 +271,34 @@ module Mochigome
     end
 
     def load_aggregate_data(node, cond)
-      @aggregate_rels.each do |key, rel_funcs|
+      @aggregate_rels.each do |key, rel_func|
         data_model = key[:data_model]
         agg_name = key[:agg_setting_name]
         agg_settings = data_model.mochigome_aggregation_settings(agg_name)
 
-        rel_funcs.each do |rel_func|
-          q = rel_func.call(cond)
-          data_tree = {}
-          connection.select_all(q.to_sql).each do |row|
-            group_values = row.keys.select{|k| k.start_with?("g")}.sort.map{|k| denilify(row[k])}
-            data_values = row.keys.select{|k| k.start_with?("d")}.sort.map{|k| row[k]}
-            if group_values.empty?
-              data_tree = data_values
-            else
-              c = data_tree
-              group_values.take(group_values.size-1).each do |group_id|
-                c = (c[group_id] ||= {})
-              end
-              c[group_values.last] = data_values
-            end
-          end
-          insert_aggregate_data_fields(node, data_tree, agg_settings, 0)
+        q = rel_func.call(cond)
+        data_table = {}
+        connection.select_all(q.to_sql).each do |row|
+          group_values = row.keys.select{|k| k.start_with?("g")}.sort.map{|k| denilify(row[k])}
+          data_values = row.keys.select{|k| k.start_with?("d")}.sort.map{|k| row[k]}
+          data_table[group_values] = data_values
         end
+        insert_aggregate_data_fields(node, data_table, agg_settings, [], key[:depth])
       end
     end
 
-    def insert_aggregate_data_fields(node, table, agg_settings, depth)
-      return unless depth == 0 || node[:internal_type] == @layer_types[depth-1].name
-      if table.is_a? Array
+    def insert_aggregate_data_fields(node, table, agg_settings, path, tgt_depth)
+      # Ignore nodes inserted by other QueryLines
+      return unless path.size == 0 || node[:internal_type] == @layer_path[path.size-1].name
+
+      if path.size == tgt_depth
         fields = agg_settings.options[:fields]
         # Pre-fill the node with default values in the right order
         fields.each{|fld| node[fld[:name]] = fld[:default] unless fld[:hidden] }
         agg_row = {} # Hold regular results here to be used in ruby-based fields
-        fields.reject{|fld| fld[:in_ruby]}.zip(table).each do |fld, v|
+        node_data = table[path]
+        return unless node_data
+        fields.reject{|fld| fld[:in_ruby]}.zip(node_data).each do |fld, v|
           v ||= fld[:default]
           agg_row[fld[:name]] = v
           node[fld[:name]] = v unless fld[:hidden]
@@ -286,13 +306,9 @@ module Mochigome
         fields.select{|fld| fld[:in_ruby]}.each do |fld|
           node[fld[:name]] = fld[:ruby_proc].call(agg_row)
         end
-        node.children.each do |c|
-          insert_aggregate_data_fields(c, [], agg_settings, depth+1)
-        end
       else
         node.children.each do |c|
-          subtable = table[c[:id]] || []
-          insert_aggregate_data_fields(c, subtable, agg_settings, depth+1)
+          insert_aggregate_data_fields(c, table, agg_settings, path + [c[:id]], tgt_depth)
         end
       end
     end

data/lib/subgroup_model.rb

@@ -118,7 +118,7 @@ module Mochigome
       @rec.value
     end
 
-    def field_data
+    def field_data(fieldset_names = nil)
       {}
     end
   end

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

@@ -1,5 +1,7 @@
 class Owner < ActiveRecord::Base
-  acts_as_mochigome_focus
+  acts_as_mochigome_focus do |f|
+    f.fieldset :age, ["birth_date", "age"]
+  end
 
   has_many :stores
 

data/test/unit/query_test.rb

@@ -12,7 +12,8 @@ describe Mochigome::Query do
 
     @product_e = create(:product, :name => "Product E") # No category
 
-    @john = create(:owner, :first_name => "John", :last_name => "Smith")
+    @john = create(:owner, :first_name => "John", :last_name => "Smith",
+                  :birth_date => 25.years.ago)
     @store_x = create(:store, :name => "John's Store", :owner => @john)
 
     @jane = create(:owner, :first_name => "Jane", :last_name => "Doe",
@@ -654,6 +655,7 @@ describe Mochigome::Query do
       :aggregate_sources => [Sale]
     )
     dn = q.run
+    assert_equal 24, dn['Sales count']
     assert_equal "John Smith", (dn/0).name
     assert_equal 8, (dn/0)['Sales count']
     assert_equal "John's Store", (dn/0/0).name
@@ -661,4 +663,36 @@ describe Mochigome::Query do
     assert_equal "Category 1", (dn/0/1).name
     assert_equal 5, (dn/0/1)['Sales count']
   end
+
+  it "can limit aggregations to certain points on the layer tree" do
+    q = Mochigome::Query.new(
+      {:report => {Owner => [Store, Category]}},
+      :aggregate_sources => {
+        [:report] => [Sale],
+        [:report, Owner, Store] => [Sale]
+      }
+    )
+    dn = q.run
+    assert_equal 24, dn['Sales count']
+    assert_equal "John Smith", (dn/0).name
+    refute (dn/0).has_key?('Sales count')
+    assert_equal "John's Store", (dn/0/0).name
+    assert_equal 8, (dn/0/0)['Sales count']
+    assert_equal "Category 1", (dn/0/1).name
+    refute (dn/0/1).has_key?('Sales count')
+  end
+
+  it "can specify which fieldsets to use for particular models" do
+    q = Mochigome::Query.new(
+      [Owner],
+      :fieldsets => {
+        Owner => [:default, :age]
+      }
+    )
+    dn = q.run
+    assert_equal "John Smith", (dn/0).name
+    assert_equal 25, (dn/0)["age"]
+    assert_equal "Jane Doe", (dn/1).name
+    assert_equal 30.years.ago.to_date, (dn/1)["birth_date"]
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-09-27 00:00:00 Z
+date: 2012-10-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement