mochigome 0.1.14 → 0.1.15

data/TODO

@@ -5,5 +5,6 @@
 - 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?
 - Automatically set default to 0 on sum and count aggregation
-- Treat through-associations as hints for preferred paths
 - Better handling of nil in subgroup fields
+- Handle has_and_belongs_to_many correctly
+- Deal with ignore_assoc properly in both directions and when we see :through assocs

data/lib/mochigome_ver.rb

@@ -1,3 +1,3 @@
 module Mochigome
-  VERSION = "0.1.14"
+  VERSION = "0.1.15"
 end

data/lib/model_extensions.rb

@@ -6,9 +6,9 @@ module Mochigome
       base.write_inheritable_attribute :mochigome_focus_settings, nil
       base.class_inheritable_reader :mochigome_focus_settings
 
-      # TODO: Use an ordered hash for this
-      base.write_inheritable_attribute :mochigome_aggregation_settings, nil
-      base.class_inheritable_reader :mochigome_aggregation_settings
+      # FIXME: Unclear on how this interacts with inheritance...
+      base.write_inheritable_attribute :mochigome_aggregation_settings_sets, {}
+      base.class_inheritable_reader :mochigome_aggregation_settings_sets
     end
 
     module ClassMethods
@@ -45,13 +45,18 @@ module Mochigome
 
       # TODO: Split out aggregation stuff into its own module
 
-      def has_mochigome_aggregations
-        if self.try(:mochigome_aggregation_settings).try(:model) == self
-          raise Mochigome::ModelSetupError.new("Already aggregation settings for #{self.name}")
+      def has_mochigome_aggregations(name = :default)
+        name = name.to_sym
+        if mochigome_aggregation_settings_sets[name].try(:model) == self
+          raise Mochigome::ModelSetupError.new("Can't overwrite aggregation settings for #{self.name}")
         end
         settings = AggregationSettings.new(self)
         yield settings if block_given?
-        write_inheritable_attribute :mochigome_aggregation_settings, settings
+        mochigome_aggregation_settings_sets[name] = settings
+      end
+
+      def mochigome_aggregation_settings(name = :default)
+        mochigome_aggregation_settings_sets[name]
       end
 
       def assoc_condition(name)

data/lib/query.rb

@@ -17,9 +17,14 @@ module Mochigome
 
       @aggregate_rels = ActiveSupport::OrderedHash.new
       aggregate_sources.each do |a|
-        focus_model, data_model = case a
-          when Array then [a.first, a.second]
-          else [a, 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
 
         agg_rel = Relation.new(@layer_types)
@@ -28,15 +33,21 @@ module Mochigome
 
         key_cols = @ids_rel.spine_layers.map{|m| m.arel_primary_key}
 
-        agg_fields = data_model.mochigome_aggregation_settings.
+        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)
           agg_rel.select_expr(d_expr.as("d%03u" % i))
         end
 
-        @aggregate_rels[focus_model] ||= ActiveSupport::OrderedHash.new
-        @aggregate_rels[focus_model][data_model] = (0..key_cols.length).map{|n|
+        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)
@@ -134,55 +145,53 @@ module Mochigome
     end
 
     def load_aggregate_data(node, cond)
-      @aggregate_rels.each do |focus_model, data_model_rels|
-        # TODO Actually get the key types found in init for this aggregation
-        super_types = @layer_types.take_while{|m| m != focus_model}
-        data_model_rels.each do |data_model, rel_funcs|
-          aggs = data_model.mochigome_aggregation_settings.options[:fields]
-          aggs_count = aggs.reject{|a| a[:in_ruby]}.size
-          rel_funcs.each do |rel_func|
-            q = rel_func.call(cond)
-            data_tree = {}
-            @layer_types.first.connection.select_all(q.to_sql).each do |row|
-              group_values = row.keys.select{|k| k.start_with?("g")}.sort.map{|k| 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
+      @aggregate_rels.each do |key, rel_funcs|
+        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 = {}
+          @layer_types.first.connection.select_all(q.to_sql).each do |row|
+            group_values = row.keys.select{|k| k.start_with?("g")}.sort.map{|k| 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
-            insert_aggregate_data_fields(node, data_tree, data_model)
           end
+          insert_aggregate_data_fields(node, data_tree, agg_settings)
         end
       end
     end
 
-    def insert_aggregate_data_fields(node, table, data_model)
+    def insert_aggregate_data_fields(node, table, agg_settings)
       if table.is_a? Array
-        fields = data_model.mochigome_aggregation_settings.options[:fields]
+        fields = agg_settings.options[:fields]
         # Pre-fill the node with all fields in the right order
-        fields.each{|agg| node[agg[:name]] = agg[:default] unless agg[:hidden] }
-        agg_row = {} # Hold regular aggs here to be used in ruby-based aggs
-        fields.reject{|agg| agg[:in_ruby]}.zip(table).each do |agg, v|
-          v ||= agg[:default]
-          agg_row[agg[:name]] = v
-          node[agg[:name]] = v unless agg[:hidden]
+        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|
+          v ||= fld[:default]
+          agg_row[fld[:name]] = v
+          node[fld[:name]] = v unless fld[:hidden]
         end
-        fields.select{|agg| agg[:in_ruby]}.each do |agg|
-          node[agg[:name]] = agg[:ruby_proc].call(agg_row)
+        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, [], data_model)
+          insert_aggregate_data_fields(c, [], agg_settings)
         end
       else
         node.children.each do |c|
           subtable = table[c[:id]] || []
-          insert_aggregate_data_fields(c, subtable, data_model)
+          insert_aggregate_data_fields(c, subtable, agg_settings)
         end
       end
     end

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

@@ -9,6 +9,7 @@ class Product < ActiveRecord::Base
         "Consonant"
       ).call(Product.arel_table)
   end
+
   has_mochigome_aggregations do |a|
     a.fields [
       :sum_price,
@@ -24,6 +25,10 @@ class Product < ActiveRecord::Base
     a.fields_in_ruby [ {"Count squared" => lambda{|row| row["Secret count"].try(:**, 2)}} ]
   end
 
+  has_mochigome_aggregations(:averaging) do |a|
+    a.fields [:average_price]
+  end
+
   belongs_to :category
   has_many :store_products
   has_many :stores, :through => :store_products

data/test/unit/query_test.rb

@@ -275,6 +275,15 @@ describe Mochigome::Query do
     assert_equal (2*@product_c.price).to_f.to_s, (data_node/1/0/0)['Gross'].to_f.to_s
   end
 
+  it "can use a named aggregate data setting" do
+    q = Mochigome::Query.new(
+      [Owner],
+      :aggregate_sources => [[Product, :averaging]]
+    )
+    data_node = q.run
+    assert_equal ((19.95*4 + 5)/5).to_f.to_s, data_node['Products average price'].to_f.to_s
+  end
+
   it "collects aggregate data in subgroups" do
     q = Mochigome::Query.new(
       [Mochigome::SubgroupModel.new(Owner, :last_name), Owner, Store, Product],

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 0
   - 1
-  - 14
-  version: 0.1.14
+  - 15
+  version: 0.1.15
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-03 00:00:00 Z
+date: 2012-06-04 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement