mochigome 0.1.22 → 0.2.0

data/TODO

@@ -2,8 +2,8 @@
 - Replace all the TODOs and FIXMEs with whatever they're asking for (additional checks, use of ordered indifferent hashes instead of arrays of hashes, etc.)
 - If there is more than one association from model A to model B and they're both focusable, pick the one with no conditions. If all the associations have conditions, complain and require that the correct association be manually specified (where "correct" might mean none of them should be valid)
   - 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?
+- Named subsets of different 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? Slow, tho...
 - Automatically set default to 0 on sum and count aggregation
 - Better handling of nil in subgroup fields
 - Handle has_and_belongs_to_many correctly
@@ -12,3 +12,10 @@
 - Allow row counts that skip layers (i.e. a school count report on School$region, SchoolDetail$comp_shelter should have a top-level box that summarizes the # of schools that do and do not have competency shelters)
 - Some kind of on-write caching feature for records that would be expensive to fully re-aggregate every time (i.e. AttendanceRecord)
 - Some cancan joins must be allowed to double-back over already-joined tables (i.e. the troublesome SchoolStudent ability)
+- Don't take aggregations deeper than focus model layer unless appropriate
+  - How to determine "appropriate"? Maybe if the path from data to lower layer adds
+    additional restrictions? For example, on Student->Class, it makes sense
+    to aggregate Student::AttendanceRecord on the Class layer
+    but it wouldn't make sense to aggregate Student::AttendanceRecord all the
+    way down on Student->Assignment because Assignment results would
+    just be a copy of the Student layer results.

data/lib/data_node.rb

@@ -30,10 +30,11 @@ module Mochigome
     def <<(item)
       if item.is_a?(Array)
         item.map {|i| self << i}
-      else
-        raise DataNodeError.new("New child #{item} is not a DataNode") unless item.is_a?(DataNode)
+      elsif item.is_a?(DataNode)
         @children << item
         @children.last
+      else
+        raise DataNodeError.new("Can't adopt #{item.inspect}, it's not a DataNode")
       end
     end
 
@@ -47,18 +48,16 @@ module Mochigome
       twin
     end
 
-    # TODO: Only define xml-related methods if nokogiri loaded
     def to_xml
       doc = Nokogiri::XML::Document.new
       append_xml_to(doc)
       doc
     end
 
-    # TODO: Only define ruport-related methods if ruport is loaded
     def to_flat_ruport_table
       col_names = flat_column_names
       table = Ruport::Data::Table.new(:column_names => col_names)
-      append_rows_to(table, col_names.size)
+      append_rows_to(table, col_names)
       table
     end
 
@@ -66,7 +65,7 @@ module Mochigome
       table = []
       col_names = flat_column_names
       table << col_names
-      append_rows_to(table, col_names.size)
+      append_rows_to(table, col_names)
       table
     end
 
@@ -97,27 +96,38 @@ module Mochigome
       x.add_child(node)
     end
 
-    # TODO: Should handle trickier situations involving datanodes not having various columns
     def flat_column_names
       colnames = (["name"] + keys).
         reject{|key| key.to_s.start_with?("_")}.
         map{|key| "#{@type_name}::#{key}"}
       choices = @children.map(&:flat_column_names)
-      colnames += choices.max_by(&:size) || []
+      colnames += choices.flatten(1).uniq || []
       colnames
     end
 
-    # TODO: Should handle trickier situations involving datanodes not having various columns
-    def append_rows_to(table, pad, stack = [])
-      row_vals = keys.reject{|k| k.to_s.start_with?("_")}.map{|k| self[k]}
-      stack.push([@name] + row_vals)
+    def append_rows_to(table, colnames, row = nil)
+      row = colnames.map{nil} if row.nil?
+
+      added_cell_indices = []
+      colnames.each_with_index do |k, i|
+        if k =~ /^#{@type_name}::(.+)$/
+          attr_name = $1
+          if attr_name.to_sym == :name
+            row[i] = name
+          else
+            row[i] = self[attr_name.to_sym]
+          end
+          added_cell_indices << i
+        end
+      end
+
       if @children.size > 0
-        @children.each {|child| child.send(:append_rows_to, table, pad, stack)}
+        @children.each {|child| child.send(:append_rows_to, table, colnames, row)}
       else
-        row = stack.flatten(1)
-        table << (row + Array.new(pad - row.size, nil))
+        table << row.dup
       end
-      stack.pop
+
+      added_cell_indices.each{|i| row[i] = nil}
     end
   end
 end

data/lib/mochigome_ver.rb

@@ -1,3 +1,3 @@
 module Mochigome
-  VERSION = "0.1.22"
+  VERSION = "0.2.0"
 end

data/lib/model_extensions.rb

@@ -154,22 +154,23 @@ module Mochigome
 
   class ReportFocus
     attr_reader :type_name
-    attr_reader :fields
 
     def initialize(owner, settings)
       @owner = owner
       @name_proc = settings.options[:name] || lambda{|obj| obj.name}
       @type_name = settings.options[:type_name] || owner.class.human_name
-      @fields = settings.options[:fields] || []
+      @fieldsets = settings.options[:fieldsets] || {}
     end
 
     def name
       @name_proc.call(@owner)
     end
 
-    def field_data
+    def field_data(fieldset_names = nil)
+      fieldset_names ||= [:default]
       h = ActiveSupport::OrderedHash.new
-      self.fields.each do |field|
+      field_descs = fieldset_names.map{|n|@fieldsets[n]}.compact.flatten(1).uniq
+      field_descs.each do |field|
         h[field[:name]] = field[:value_func].call(@owner)
       end
       h
@@ -184,7 +185,7 @@ module Mochigome
     def initialize(model)
       @model = model
       @options = {}
-      @options[:fields] = []
+      @options[:fieldsets] = {}
       @options[:custom_subgroup_exprs] = ActiveSupport::OrderedHash.new
       @options[:custom_assocs] = ActiveSupport::OrderedHash.new
       @options[:ignore_assocs] = Set.new
@@ -210,11 +211,15 @@ module Mochigome
     end
 
     def fields(fields)
+      fieldset(:default, fields)
+    end
+
+    def fieldset(name, fields)
       unless fields.respond_to?(:each)
-        raise ModelSetupError.new "Call f.fields with an Enumerable"
+        raise ModelSetupError.new "Call f.fieldset with an Enumerable"
       end
 
-      @options[:fields] += fields.map do |f|
+      field_descs = fields.map do |f|
         case f
         when String, Symbol then {
           :name => Mochigome::complain_if_reserved_name(f.to_s.strip),
@@ -227,6 +232,7 @@ module Mochigome
         else raise ModelSetupError.new "Invalid field: #{f.inspect}"
         end
       end
+      (@options[:fieldsets][name.to_sym] ||= []).concat field_descs
     end
 
     def custom_subgroup_expression(name, expr)

data/lib/query.rb

@@ -1,91 +1,216 @@
 module Mochigome
   class Query
-    def initialize(layer_types, options = {})
-      # TODO: Validate layer types: not empty, AR, act_as_mochigome_focus
-      @layer_types = layer_types
-
+    def initialize(layers, options = {})
       @name = options.delete(:root_name).try(:to_s) || "report"
-      @access_filter = options.delete(:access_filter) || lambda {|cls| {}}
-      # TODO: Validate that aggregate_sources is in the correct format
+      access_filter = options.delete(:access_filter) || lambda {|cls| {}}
       aggregate_sources = options.delete(:aggregate_sources) || []
       unless options.empty?
         raise QueryError.new("Unknown options: #{options.keys.inspect}")
       end
 
-      @ids_rel = Relation.new(@layer_types)
-      @ids_rel.apply_access_filter_func(@access_filter)
+      if layers.is_a? Array
+        layer_paths = [layers]
+      else
+        unless layers.is_a?(Hash) &&
+        layers.size == 1 &&
+        layers.keys.first == :report
+          raise QueryError.new("Invalid layer tree")
+        end
+        layer_paths = Query.tree_root_to_leaf_paths(layers.values.first)
+      end
+      layer_paths = [[]] if layer_paths.empty? # Create at least one QueryLine
+      @lines = layer_paths.map{ |path| QueryLine.new(path, access_filter) }
 
-      @aggregate_rels = ActiveSupport::OrderedHash.new
       aggregate_sources.each do |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
-          data_model = a.select{|e| e.is_a?(Class)}.last
-          agg_setting_name = a.select{|e| e.is_a?(Symbol)}.first || :default
-        else
-          focus_model = data_model = a
-          agg_setting_name = :default
+        @lines.each{|line| line.add_aggregate_source(a)}
+      end
+    end
+
+    def run(cond = nil)
+      model_ids = {}
+      parental_seqs = {}
+      @lines.each do |line|
+        tbl = line.build_id_table(cond)
+        parent_models = []
+        line.layer_types.each do |model|
+          tbl.each do |ids_row|
+            i = ids_row["#{model.name}_id"]
+            if i
+              (model_ids[model] ||= Set.new).add(i)
+              parental_seq_key = parent_models.zip(
+                parent_models.map{|pm| ids_row["#{pm}_id"]}
+              )
+              (parental_seqs[parental_seq_key] ||= Set.new).add([model.name, i])
+            end
+          end
+          parent_models << model.name
         end
+      end
 
-        agg_rel = Relation.new(@layer_types)
-        agg_rel.join_on_path_thru([focus_model, data_model])
-        agg_rel.apply_access_filter_func(@access_filter)
+      model_datanodes = generate_datanodes(model_ids)
+      root = create_root_node
+      add_datanode_children([], root, model_datanodes, parental_seqs)
+      @lines.each do |line|
+        line.load_aggregate_data(root, cond)
+      end
+      return root
+    end
 
-        key_cols = @ids_rel.spine_layers.map{|m| m.arel_primary_key}
+    private
 
-        agg_fields = data_model.
-          mochigome_aggregation_settings(agg_setting_name).
-          options[:fields].reject{|a| a[:in_ruby]}
-        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)
-          agg_rel.select_expr(d_expr.as("d%03u" % i))
-        end
+    def self.tree_root_to_leaf_paths(t)
+      if t.is_a?(Hash)
+        t.map{|k, v|
+          tree_root_to_leaf_paths(v).map{|p| [k] + p}
+        }.flatten(1)
+      elsif t.is_a?(Array)
+        t.map{|v| tree_root_to_leaf_paths(v)}.flatten(1)
+      else
+        [[t]]
+      end
+    end
 
-        agg_rel_key = {
-          :focus_model => focus_model,
-          :data_model => data_model,
-          :agg_setting_name => agg_setting_name
-        }
+    def generate_datanodes(model_ids)
+      model_datanodes = {}
+      model_ids.keys.each do |model|
+        # 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},
+          :order => model.mochigome_focus_settings.get_ordering
+        ).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[:id] = rec.id
+          dn[:internal_type] = model.name
+          (model_datanodes[model.name] ||= {})[rec.id] = [dn, seq_idx]
+        end
+      end
+      return model_datanodes
+    end
 
-        @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
+    def add_datanode_children(path, node, model_datanodes, parental_seqs)
+      path_children = parental_seqs[path]
+      return unless path_children
+      ordered_children = {}
+      path_children.each do |model, i|
+        src_dn, seq_idx = model_datanodes[model][i]
+        dn = src_dn.clone
+        full_path = path + [[model, i]]
+        dn[:_report_path] = full_path.map(&:first).join("___")
+        add_datanode_children(full_path, dn, model_datanodes, parental_seqs)
 
-            # 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
-          }
-        }
+        # Sorting by left-to-right class order in Query layer tree, then
+        # 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}}
+        (ordered_children[model_idx] ||= {})[seq_idx] = dn
+      end
+      ordered_children.keys.sort.each do |k|
+        subhash = ordered_children[k]
+        subhash.keys.sort.each do |seqkey|
+          node.children << subhash[seqkey]
+        end
       end
     end
 
-    def run(cond = nil)
-      root = create_node_tree(cond)
-      load_aggregate_data(root, cond)
-      return root
+    def create_root_node
+      root = DataNode.new(:report, @name)
+      root.comment = <<-eos
+        Mochigome Version: #{Mochigome::VERSION}
+        Report Generated: #{Time.now}
+        eos
+        # FIXME Show layers and joins for all lines individually
+        #Layers: #{@layer_types.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")
+        return root
     end
+  end
 
-    private
+  private
+
+  class QueryLine
+    attr_accessor :layer_types
+    attr_accessor :ids_rel
+
+    def initialize(layer_types, access_filter)
+      # TODO: Validate layer types: not empty, AR, act_as_mochigome_focus
+      @layer_types = layer_types
+      @access_filter = access_filter
+
+      @ids_rel = Relation.new(@layer_types)
+      @ids_rel.apply_access_filter_func(@access_filter)
+
+      @aggregate_rels = ActiveSupport::OrderedHash.new
+    end
+
+    def add_aggregate_source(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
+        data_model = a.select{|e| e.is_a?(Class)}.last
+        agg_setting_name = a.select{|e| e.is_a?(Symbol)}.first || :default
+      else
+        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)
+
+      key_cols = @ids_rel.spine_layers.map{|m| m.arel_primary_key}
+
+      agg_fields = data_model.
+        mochigome_aggregation_settings(agg_setting_name).
+        options[:fields].reject{|a| a[:in_ruby]}
+      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)
+        agg_rel.select_expr(d_expr.as("d%03u" % i))
+      end
+
+      agg_rel_key = {
+        :focus_model => focus_model,
+        :data_model => data_model,
+        :agg_setting_name => agg_setting_name
+      }
+
+      @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
+
+          # 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
+        }
+      }
+    end
 
     def connection
       ActiveRecord::Base.connection
@@ -96,71 +221,19 @@ module Mochigome
       (v.nil? || v.to_s.strip.empty?) ? "(None)" : v
     end
 
-    def create_node_tree(cond)
-      root = DataNode.new(:report, @name)
-      root.comment = <<-eos
-        Mochigome Version: #{Mochigome::VERSION}
-        Report Generated: #{Time.now}
-        Layers: #{@layer_types.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")
-
-      unless @layer_types.empty?
+    def build_id_table(cond)
+      if @layer_types.empty?
+        return []
+      else
         r = @ids_rel.clone
         r.apply_condition(cond)
         ids_sql = r.to_sql
-        if ids_sql
-          ids_table = connection.select_all(ids_sql).map do |row|
-            row.each do |k,v|
-              row[k] = denilify(v)
-            end
+        return connection.select_all(ids_sql).map do |row|
+          row.each do |k,v|
+            row[k] = denilify(v)
           end
-          fill_layers(ids_table, {[] => root}, @layer_types)
         end
       end
-
-      root
-    end
-
-    def fill_layers(ids_table, parents, types, type_idx = 0)
-      return if type_idx >= types.size
-
-      model = types[type_idx]
-      layer_ids = Set.new
-      cur_to_parent = {}
-
-      parent_types = types.take(type_idx)
-      ids_table.each do |row|
-        cur_id = row["#{model.name}_id"]
-        layer_ids.add cur_id
-        cur_to_parent[cur_id] ||= Set.new
-        cur_to_parent[cur_id].add parent_types.map{|m| row["#{m.name}_id"]}
-      end
-
-      layer = {}
-      model.all( # TODO: Find a way to do this with data streaming
-        :conditions => {model.primary_key => layer_ids.to_a},
-        :order => model.mochigome_focus_settings.get_ordering
-      ).each do |obj|
-        f = obj.mochigome_focus
-        dn = DataNode.new(f.type_name, f.name)
-        dn.merge!(f.field_data)
-
-        # TODO: Maybe make special fields below part of ModelExtensions?
-        dn[:id] = obj.id
-        dn[:internal_type] = model.name
-
-        cur_to_parent.fetch(obj.id).each do |parent_ids_seq|
-          cloned = dn.clone
-          parents.fetch(parent_ids_seq) << cloned
-          layer[parent_ids_seq + [obj.id]] = cloned
-        end
-      end
-
-      fill_layers(ids_table, layer, types, type_idx + 1)
     end
 
     def load_aggregate_data(node, cond)
@@ -185,15 +258,16 @@ module Mochigome
               c[group_values.last] = data_values
             end
           end
-          insert_aggregate_data_fields(node, data_tree, agg_settings)
+          insert_aggregate_data_fields(node, data_tree, agg_settings, 0)
         end
       end
     end
 
-    def insert_aggregate_data_fields(node, table, agg_settings)
+    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
         fields = agg_settings.options[:fields]
-        # Pre-fill the node with all fields in the right order
+        # 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|
@@ -205,12 +279,12 @@ module Mochigome
           node[fld[:name]] = fld[:ruby_proc].call(agg_row)
         end
         node.children.each do |c|
-          insert_aggregate_data_fields(c, [], agg_settings)
+          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)
+          insert_aggregate_data_fields(c, subtable, agg_settings, depth+1)
         end
       end
     end

data/lib/subgroup_model.rb

@@ -27,7 +27,8 @@ module Mochigome
     end
 
     def name
-      "#{@model}$#{@attr}" # Warning: This has to be a valid SQL field name
+      # This works as both a valid SQL field name and a valid XML tag name
+      "#{@model}__#{@attr}"
     end
 
     def human_name

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

@@ -43,6 +43,10 @@ class CreateTables < ActiveRecord::Migration
       t.timestamps
       t.string :a
       t.string :b
+      t.string :c
+      t.string :d
+      t.string :e
+      t.string :f
       t.integer :product_id
       t.integer :x
     end

data/test/unit/data_node_test.rb

@@ -102,11 +102,12 @@ describe Mochigome::DataNode do
       @datanode.merge! [{:id => 400}, {:apples => 1}, {:box_cutters => 2}, {:can_openers => 3}]
       emp1 = @datanode << Mochigome::DataNode.new(:employee, :alice)
       emp1.merge! [{:id => 500}, {:x => 9}, {:y => 8}, {:z => 7}, {:internal_type => "Cyborg"}, {:_foo => "bar"}]
+      emp1 << Mochigome::DataNode.new(:phone, :android)
       emp2 = @datanode << Mochigome::DataNode.new(:employee, :bob)
       emp2.merge! [{:id => 600}, {:x => 5}, {:y => 4}, {:z => 8734}, {:internal_type => "Human"}]
       emp2 << Mochigome::DataNode.new(:pet, :lassie)
 
-      @titles = [
+      @expected_titles = [
         "corporation::name",
         "corporation::id",
         "corporation::apples",
@@ -118,12 +119,15 @@ describe Mochigome::DataNode do
         "employee::y",
         "employee::z",
         "employee::internal_type",
+        "phone::name",
         "pet::name"
       ]
+      @expected_row_1 = ['acme', 400, 1, 2, 3, 'alice', 500,  9, 8, 7, "Cyborg", "android", nil]
+      @expected_row_2 = ['acme', 400, 1, 2, 3, 'bob', 600, 5, 4, 8734, "Human", nil, "lassie"]
     end
 
     it "can convert to an XML document with correct attributes and elements" do
-      # Why stringify and reparse? So that we could use another XML generator
+      # Why stringify and reparse? So that implementation could use another XML generator
       doc = Nokogiri::XML(@datanode.to_xml.to_s)
 
       comment = doc.xpath('/node[@type="Corporation"]/comment()').first
@@ -140,9 +144,10 @@ describe Mochigome::DataNode do
       assert_equal "bob", emp_nodes.last['name']
       assert_equal "Cyborg", emp_nodes.first['internal_type']
       assert_equal "4", emp_nodes.last.xpath('datum[@name="Y"]').first.content
+      assert_equal "android", emp_nodes.first.xpath('node').first['name']
       assert_equal "lassie", emp_nodes.last.xpath('node').first['name']
 
-      # Keys that start with an underscore are to be turned into so-named elems
+      # Keys that start with an underscore are to be turned into special elems
       assert_empty emp_nodes.first.xpath('datum').select{|datum|
         datum['name'] =~ /foo/i
       }
@@ -151,16 +156,16 @@ describe Mochigome::DataNode do
 
     it "can convert to a flattened Ruport table" do
       table = @datanode.to_flat_ruport_table
-      assert_equal @titles, table.column_names
-      assert_equal ['acme', 400, 1, 2, 3, 'alice', 500,  9, 8, 7, "Cyborg", nil], table.data[0].to_a
-      assert_equal ['acme', 400, 1, 2, 3, 'bob', 600, 5, 4, 8734, "Human", "lassie"], table.data[1].to_a
+      assert_equal @expected_titles, table.column_names
+      assert_equal @expected_row_1, table.data[0].to_a
+      assert_equal @expected_row_2, table.data[1].to_a
     end
 
     it "can convert to a flat array of arrays" do
       a = @datanode.to_flat_arrays
-      assert_equal @titles, a[0]
-      assert_equal ['acme', 400, 1, 2, 3, 'alice', 500, 9, 8, 7, "Cyborg", nil], a[1]
-      assert_equal ['acme', 400, 1, 2, 3, 'bob', 600, 5, 4, 8734, "Human", "lassie"], a[2]
+      assert_equal @expected_titles, a[0]
+      assert_equal @expected_row_1, a[1]
+      assert_equal @expected_row_2, a[2]
     end
   end
 end

data/test/unit/model_extensions_test.rb

@@ -142,17 +142,34 @@ describe "an ActiveRecord model" do
       @model_class.mochigome_focus_settings.get_ordering
   end
 
-  it "can specify fields" do
+  it "can specify fields without name that act as fieldset named 'default'" do
     @model_class.class_eval do
       acts_as_mochigome_focus do |f|
         f.fields ["a", "b"]
       end
     end
-    i = @model_class.new(:a => "abc", :b => "xyz")
+    i = @model_class.new(:a => "abc", :b => "xyz", :c => "123")
     expected = ActiveSupport::OrderedHash.new
     expected["a"] = "abc"
     expected["b"] = "xyz"
     assert_equal expected, i.mochigome_focus.field_data
+    assert_equal expected, i.mochigome_focus.field_data([:default])
+  end
+
+  it "can specify and request fieldsets with custom names" do
+    @model_class.class_eval do
+      acts_as_mochigome_focus do |f|
+        f.fieldset :foo, ["c", "d"]
+        f.fieldset :bar, ["e"]
+        f.fieldset :zap, ["f"]
+      end
+    end
+    i = @model_class.new(:c => "cat", :d => "dog", :e => "elephant", :f => "ferret")
+    expected = ActiveSupport::OrderedHash.new
+    expected["f"] = "ferret"
+    expected["c"] = "cat"
+    expected["d"] = "dog"
+    assert_equal expected, i.mochigome_focus.field_data([:zap, :foo])
   end
 
   it "has no report focus data if no fields are specified" do

data/test/unit/query_test.rb

@@ -148,6 +148,14 @@ describe Mochigome::Query do
     assert_no_children data_node/0/0
   end
 
+  it "can build a two-layer tree from a simple list-equivalent layer tree" do
+    q = Mochigome::Query.new({:report => {Category => Product}})
+    data_node = q.run(@category1)
+    assert_equal_children [@category1], data_node
+    assert_equal_children [@product_a, @product_b], data_node/0
+    assert_no_children data_node/0/0
+  end
+
   it "cannot build a Query through disconnected layers" do
     assert_raises Mochigome::QueryError do
       q = Mochigome::Query.new([Category, BoringDatum])
@@ -170,6 +178,16 @@ describe Mochigome::Query do
     end
   end
 
+  it "can build a three-layer tree from a simple list-equivalent layer tree" do
+    q = Mochigome::Query.new({:report => {Owner => {Store => Product}}})
+    data_node = q.run([@john, @jane])
+      assert_equal_children [@john, @jane], data_node
+      assert_equal_children [@store_x], data_node/0
+      assert_equal_children [@store_y, @store_z], data_node/1
+      assert_equal_children [@product_a, @product_c], data_node/0/0
+      assert_equal_children [@product_c, @product_d], data_node/1/1
+  end
+
   it "can subgroup layers by attributes" do
     q = Mochigome::Query.new(
       [Mochigome::SubgroupModel.new(Owner, :last_name), Owner, Store, Product]
@@ -517,9 +535,6 @@ describe Mochigome::Query do
     data_node = q.run([@store_x, @store_y, @store_z])
     c = data_node.comment
     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, /\nJoin: \w+ -> \w+\n/
   end
 
   it "names the root node 'report' by default" do
@@ -570,18 +585,6 @@ describe Mochigome::Query do
     refute dn.children.any?{|c| c.name == "Product E"}
   end
 
-  it "access filter joins will not duplicate joins already in the query" do
-    af = proc do |cls|
-      return {} unless cls == Product
-      return {
-        :join_paths => [[Product, StoreProduct, Store]],
-        :condition => Store.arel_table[:name].matches("Jo%")
-      }
-    end
-    q = Mochigome::Query.new([Product, Store], :access_filter => af)
-    assert_equal 1, q.instance_variable_get(:@ids_rel).to_sql.scan(/join .stores./i).size
-  end
-
   it "automatically joins if run given a condition on a new table" do
     q = Mochigome::Query.new([Product, Store])
     dn = q.run(Category.arel_table[:name].eq(@category1.name))
@@ -633,4 +636,29 @@ describe Mochigome::Query do
     assert_equal "Widget 6", (dn/5).name
     assert_equal 3, (dn/5).children.size
   end
+
+  it "can create cross-group reports when given a layer tree" do
+    q = Mochigome::Query.new({:report => {Owner => [Store, Category]}})
+    dn = q.run
+    assert_equal "John Smith", (dn/0).name
+    assert_equal 3, (dn/0).children.size
+    assert_equal "John's Store", (dn/0/0).name
+    assert_equal "Store", (dn/0/0)[:internal_type]
+    assert_equal "Category 1", (dn/0/1).name
+    assert_equal "Category", (dn/0/1)[:internal_type]
+  end
+
+  it "can run aggregations on cross-group reports" do
+    q = Mochigome::Query.new(
+      {:report => {Owner => [Store, Category]}},
+      :aggregate_sources => [Sale]
+    )
+    dn = q.run
+    assert_equal "John Smith", (dn/0).name
+    assert_equal 8, (dn/0)['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
+    assert_equal 5, (dn/0/1)['Sales count']
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 55
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 22
-  version: 0.1.22
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-17 00:00:00 Z
+date: 2012-09-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement