mochigome 0.0.8 → 0.0.9

data/Gemfile

@@ -7,7 +7,7 @@ gem 'ruport'
 gem 'rgl'
 
 gem 'sqlite3'
-gem 'mysql'
+gem 'mysql2', '~> 0.2.0'
 gem 'factory_girl', '2.0.4'
 gem 'rdoc'
 gem 'rcov'

data/Gemfile.lock

@@ -23,7 +23,7 @@ GEM
     minitest (2.5.0)
     mynyml-redgreen (0.7.1)
       term-ansicolor (>= 1.0.4)
-    mysql (2.8.1)
+    mysql2 (0.2.18)
     nokogiri (1.5.0)
     pdf-writer (1.1.8)
       color (>= 1.4.0)
@@ -64,7 +64,7 @@ DEPENDENCIES
   factory_girl (= 2.0.4)
   minitest
   mynyml-redgreen
-  mysql
+  mysql2 (~> 0.2.0)
   nokogiri
   rails (= 2.3.12)
   rcov

data/lib/arel_rails2_hacks.rb

@@ -42,7 +42,7 @@ unless ActiveRecord::ConnectionAdapters::ConnectionPool.methods.include?("table_
   class ActiveRecord::ConnectionAdapters::SQLiteAdapter
     def select_rows(sql, name = nil)
       execute(sql, name).map do |row|
-        row.keys.select{|key| key.is_a? Integer}.map{|key| row[key]}
+        row.keys.select{|key| key.is_a? Integer}.sort.map{|key| row[key]}
       end
     end
   end

data/lib/data_node.rb

@@ -41,6 +41,12 @@ module Mochigome
       @children[idx]
     end
 
+    def dup
+      twin = super
+      twin.instance_variable_set(:@children, @children.map{|c| c.dup})
+      twin
+    end
+
     # TODO: Only define xml-related methods if nokogiri loaded
     def to_xml
       doc = Nokogiri::XML::Document.new

data/lib/mochigome.rb

@@ -4,6 +4,7 @@ require 'data_node'
 require 'query'
 require 'model_extensions'
 require 'formatting'
+require 'subgroup_model'
 require 'arel_rails2_hacks'
 
 ActiveRecord::Base.send(:include, Mochigome::ModelExtensions)

data/lib/mochigome_ver.rb

@@ -1,3 +1,3 @@
 module Mochigome
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/lib/model_extensions.rb

@@ -12,6 +12,19 @@ module Mochigome
     end
 
     module ClassMethods
+      def real_model?
+        true
+      end
+
+      # TODO: Use this instead of calling Table.new all over the place
+      def arel_table
+        Arel::Table.new(table_name)
+      end
+
+      def arel_primary_key
+        arel_table[primary_key]
+      end
+
       def acts_as_mochigome_focus
         if self.try(:mochigome_focus_settings).try(:model) == self
           raise Mochigome::ModelSetupError.new("Already acts_as_mochigome_focus for #{self.name}")

data/lib/query.rb

@@ -4,9 +4,10 @@ require 'rgl/traversal'
 module Mochigome
   class Query
     def initialize(layer_types, options = {})
-      # TODO: Validate layer types: not empty, AR, act_as_mochigome_focus, graph correctly, no repeats
+      # TODO: Validate layer types: not empty, AR, act_as_mochigome_focus
       @layer_types = layer_types
-      @layers_path = self.class.path_thru(layer_types)
+      @layers_path = self.class.path_thru(@layer_types)
+      @layers_path or raise QueryError.new("No valid path thru layer list") #TODO Test
 
       @name = options.delete(:root_name).try(:to_s) || "report"
       @access_filter = options.delete(:access_filter) || lambda {|cls| {}}
@@ -16,14 +17,17 @@ module Mochigome
       end
 
       @ids_rel = self.class.relation_over_path(@layers_path).
-        project(@layers_path.map{|m|
-          Arel::Table.new(m.table_name)[m.primary_key]
-        })
+        project(@layers_path.map{|m| m.arel_primary_key})
       @ids_rel = access_filtered_relation(@ids_rel, @layers_path)
 
       # TODO: Validate that aggregate_sources is in the correct format
       aggs_by_model = {}
-      aggregate_sources.each do |focus_cls, data_cls|
+      aggregate_sources.each do |a|
+        if a.instance_of?(Array)
+          focus_cls, data_cls = a.first, a.second
+        else
+          focus_cls, data_cls = a, a
+        end
         aggs_by_model[focus_cls] ||= []
         aggs_by_model[focus_cls] << data_cls
       end
@@ -39,7 +43,12 @@ module Mochigome
 
         @aggregate_rels[focus_model] = {}
         data_models.each do |data_model|
-          f2d_path = self.class.path_thru([focus_model, data_model]) #TODO: Handle nil here
+          if focus_model == data_model
+            f2d_path = [focus_model]
+          else
+            #TODO: Handle nil here
+            f2d_path = self.class.path_thru([focus_model, data_model])
+          end
           agg_path = nil
           key_path = nil
           f2d_path.each do |link_model|
@@ -63,15 +72,12 @@ module Mochigome
             end
           end
 
-          key_cols = key_path.map{|m|
-            Arel::Table.new(m.table_name)[m.primary_key]
-          }
+          key_cols = key_path.map{|m| m.arel_primary_key }
 
           agg_data_rel = self.class.relation_over_path(agg_path, focus_rel.dup)
           agg_data_rel = access_filtered_relation(agg_data_rel, @layers_path + agg_path)
           data_tbl = Arel::Table.new(data_model.table_name)
           agg_fields = data_model.mochigome_aggregation_settings.options[:fields].reject{|a| a[:in_ruby]}
-          agg_data_rel.project # FIXME ??? What is this for?
           agg_fields.each_with_index do |a, i|
             agg_data_rel.project(a[:value_proc].call(data_tbl).as("d#{i}"))
           end
@@ -115,22 +121,29 @@ module Mochigome
       end
       if cond.is_a?(Array)
         return root if cond.empty?
-        unless cond.all?{|obj| obj.class == cond.first.class}
-          raise QueryError.new("Query target objects must all be the same type")
+        cond = cond.inject(nil) do |expr, obj|
+          cls = obj.class
+          tbl = Arel::Table.new(cls.table_name)
+          subexpr = tbl[cls.primary_key].eq(obj.id)
+          expr ? expr.or(subexpr) : subexpr
         end
-        unless @layer_types.any?{|layer| cond.first.is_a?(layer)}
-          raise QueryError.new("Query target's class must be in layer list")
+      end
+      if cond
+        self.class.expr_tables(cond).each do |t|
+          raise QueryError.new("Condition table #{t} not in layer list") unless
+            @layers_path.any?{|m| m.table_name == t}
         end
-        cls = cond.first.class
-        cond = Arel::Table.new(cls.table_name)[cls.primary_key].in(cond.map(&:id))
       end
 
       q = @ids_rel.dup
       q.where(cond) if cond
       ids_table = @layer_types.first.connection.select_rows(q.to_sql)
-      ids_table = ids_table.map{|row| row.map{|cell| cell.to_i}}
+      ids_table = ids_table.map do |row|
+        # FIXME: Should do this conversion based on type of column
+        row.map{|cell| cell =~ /^\d+$/ ? cell.to_i : cell}
+      end
 
-      fill_layers(ids_table, {:root => root}, @layer_types)
+      fill_layers(ids_table, {[] => root}, @layer_types)
 
       @aggregate_rels.each do |focus_model, data_model_rels|
         super_types = @layer_types.take_while{|m| m != focus_model}
@@ -150,10 +163,10 @@ module Mochigome
                 c = data_tree
                 super_cols.each_with_index do |sc_num, sc_idx|
                   break if aggs_count+sc_idx >= row.size-1
-                  col_num = aggs_count + super_cols[sc_num]
-                  c = (c[row[col_num].to_i] ||= {})
+                  col_num = aggs_count + sc_num
+                  c = (c[row[col_num]] ||= {})
                 end
-                c[row.last.to_i] = row.take(aggs_count)
+                c[row.last] = row.take(aggs_count)
               end
             end
             insert_aggregate_data_fields(root, data_tree, data_model)
@@ -196,7 +209,7 @@ module Mochigome
       r
     end
 
-    def fill_layers(ids_table, parents, types, parent_col_num = nil)
+    def fill_layers(ids_table, parents, types, parent_col_nums = [])
       return if types.size == 0
 
       model = types.first
@@ -207,10 +220,8 @@ module Mochigome
       ids_table.each do |row|
         cur_id = row[col_num]
         layer_ids.add cur_id
-        if parent_col_num
-          cur_to_parent[cur_id] ||= Set.new
-          cur_to_parent[cur_id].add row[parent_col_num]
-        end
+        cur_to_parent[cur_id] ||= Set.new
+        cur_to_parent[cur_id].add parent_col_nums.map{|i| row[i]}
       end
 
       layer = {}
@@ -221,23 +232,19 @@ module Mochigome
         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] = obj.class.name
+        dn[:internal_type] = model.name
 
-        if parent_col_num
-          duping = false
-          cur_to_parent.fetch(obj.id).each do |parent_id|
-            parents.fetch(parent_id) << (duping ? dn.dup : dn)
-            duping = true
-          end
-        else
-          parents[:root] << dn
+        cur_to_parent.fetch(obj.id).each do |parent_ids_seq|
+          duped = dn.dup
+          parents.fetch(parent_ids_seq) << duped
+          layer[parent_ids_seq + [obj.id]] = duped
         end
-        layer[obj.id] = dn
       end
 
-      fill_layers(ids_table, layer, types.drop(1), col_num)
+      fill_layers(ids_table, layer, types.drop(1), parent_col_nums + [col_num])
     end
 
     def insert_aggregate_data_fields(node, table, data_model)
@@ -263,15 +270,28 @@ module Mochigome
 
     # TODO: Move the stuff below into its own module
 
+    def self.expr_tables(e)
+      # TODO: This is kind of hacky, Arel probably has a better way
+      # to do this with its API.
+      r = Set.new
+      [:expr, :left, :right].each do |m|
+        r += expr_tables(e.send(m)) if e.respond_to?(m)
+      end
+      r.add e.relation.name if e.respond_to?(:relation)
+      r
+    end
+
     @@graphed_models = Set.new
     @@assoc_graph = RGL::DirectedAdjacencyGraph.new
     @@edge_relation_funcs = {}
     @@shortest_paths = {}
 
     def self.relation_over_path(path, rel = nil)
-      rel ||= Arel::Table.new(path.first.table_name)
-      (0..(path.size-2)).each do |i|
-        rel = relation_func(path[i], path[i+1]).call(rel)
+      # Project ensures that we don't return a Table even if path is empty
+      real_path = path.map{|e| (e.real_model? ? e : e.model)}.uniq
+      rel ||= Arel::Table.new(real_path.first.table_name).project
+      (0..(real_path.size-2)).each do |i|
+        rel = relation_func(real_path[i], real_path[i+1]).call(rel)
       end
       rel
     end
@@ -283,14 +303,21 @@ module Mochigome
 
     def self.path_thru(models)
       update_assoc_graph(models)
-      path = [models.first]
-      (0..(models.size-2)).each do |i|
-        u = models[i]
-        v = models[i+1]
-        next if u == v
-        seg = @@shortest_paths[[u,v]]
-        raise QueryError.new("Can't travel from #{u.name} to #{v.name}") unless seg
-        seg.drop(1).each{|step| path << step}
+      model_queue = models.dup
+      path = [model_queue.shift]
+      until model_queue.empty?
+        src = path.last
+        tgt = model_queue.shift
+        real_src = src.real_model? ? src : src.model
+        real_tgt = tgt.real_model? ? tgt : tgt.model
+        unless real_src == real_tgt
+          seg = @@shortest_paths[[real_src,real_tgt]]
+          unless seg
+            raise QueryError.new("No path: #{real_src.name} to #{real_tgt.name}")
+          end
+          path.concat seg.take(seg.size-1).drop(1)
+        end
+        path << tgt
       end
       unless path.uniq.size == path.size
         raise QueryError.new(
@@ -306,6 +333,7 @@ module Mochigome
       added_models = []
       until model_queue.empty?
         model = model_queue.shift
+        next if model.is_a?(SubgroupModel)
         next if @@graphed_models.include? model
         @@graphed_models.add model
         added_models << model

data/lib/subgroup_model.rb

@@ -0,0 +1,102 @@
+module Mochigome
+  # An instance of SubgroupModel acts like a class that derives from
+  # AR::Base, but is used to do subgrouping in Query and does not
+  # interact with the database itself.
+  class SubgroupModel
+    attr_reader :model, :attr
+
+    def initialize(model, attr)
+      @model = model
+      @attr = attr
+      @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)}
+    end
+
+    def name
+      "#{@model}%#{@attr}"
+    end
+
+    def human_name
+      "#{@model.human_name} #{@attr.to_s.humanize}"
+    end
+
+    def real_model?
+      false
+    end
+
+    def arel_table
+      @model.arel_table
+    end
+
+    def primary_key
+      @attr
+    end
+
+    def arel_primary_key
+      arel_table[@attr]
+    end
+
+    def connection
+      @model.connection
+    end
+
+    def mochigome_focus_settings
+      @focus_settings
+    end
+
+    def acts_as_mochigome_focus?
+      true
+    end
+
+    def all(options = {})
+      c = options[:conditions]
+      unless c.is_a?(Hash) && c.size == 1 && c[@attr].is_a?(Array)
+        raise QueryError.new("Invalid conditions given to SubgroupModel#all")
+      end
+      recs = c[@attr].map do |val|
+        SubgroupPseudoRecord.new(self, val)
+      end
+      # TODO: Support some kind of custom ordering
+      recs.sort!{|a,b| a.value <=> b.value}
+      recs
+    end
+  end
+
+  private
+
+  class SubgroupPseudoRecord
+    attr_reader :subgroup_model, :value
+
+    def initialize(subgroup_model, value)
+      @subgroup_model = subgroup_model
+      @value = value
+    end
+
+    def id
+      @value
+    end
+
+    def mochigome_focus
+      SubgroupPseudoRecordReportFocus.new(self)
+    end
+  end
+
+  class SubgroupPseudoRecordReportFocus
+    def initialize(rec)
+      @rec = rec
+    end
+
+    def type_name
+      @rec.subgroup_model.human_name
+    end
+
+    def name
+      @rec.value
+    end
+
+    def field_data
+      {}
+    end
+  end
+end

data/test/app_root/config/database-my.yml

@@ -1,4 +1,4 @@
 test:
-  adapter: mysql
-  database: "mochigome_testing"
+  adapter: mysql2
+  database: "mochi_test"
   username: root

data/test/unit/data_node_test.rb

@@ -16,6 +16,15 @@ describe Mochigome::DataNode do
     assert_equal "bar", datanode.name
   end
 
+  it "can be duplicated deeply" do
+    datanode = Mochigome::DataNode.new(:foo, :bar)
+    twin = datanode.dup
+    datanode << Mochigome::DataNode.new(:xyzzy, :froboz)
+    assert_empty twin.children
+    datanode.name = "Mike"
+    assert_equal "bar", twin.name
+  end
+
   describe "when created empty" do
     before do
       @datanode = Mochigome::DataNode.new(:data, :john_doe)

data/test/unit/query_test.rb

@@ -167,6 +167,29 @@ describe Mochigome::Query do
     end
   end
 
+  it "can subgroup layers by attributes" do
+    q = Mochigome::Query.new(
+      [Mochigome::SubgroupModel.new(Owner, :last_name), Owner, Store, Product]
+    )
+    data_node = q.run
+    assert_equal "Smith", (data_node/1).name
+    assert_equal "John Smith", (data_node/1/0).name
+    assert_equal "John's Store", (data_node/1/0/0).name
+    assert_equal "Product A", (data_node/1/0/0/0).name
+  end
+
+  it "can subgroup layers by attributes without including layer model" do
+    q = Mochigome::Query.new(
+      [Mochigome::SubgroupModel.new(Owner, :last_name), Store, Product]
+    )
+    data_node = q.run
+    assert_equal "Smith", (data_node/1).name
+    assert_equal "John's Store", (data_node/1/0).name
+    assert_equal "Product A", (data_node/1/0/0).name
+  end
+
+  # TODO: Test diamond patterns
+
   it "collects aggregate data by grouping on all layers" do
     q = Mochigome::Query.new(
       [Owner, Store, Product],
@@ -190,6 +213,55 @@ describe Mochigome::Query do
     assert_equal 2, (data_node/1/0/0)['Sales count']
   end
 
+  it "collects aggregate data in subgroups" do
+    q = Mochigome::Query.new(
+      [Mochigome::SubgroupModel.new(Owner, :last_name), Owner, Store, Product],
+      :aggregate_sources => [[Product, Sale]]
+    )
+    data_node = q.run
+
+    assert_equal "Smith", (data_node/1).name
+    assert_equal 8, (data_node/1)['Sales count']
+    assert_equal "John Smith", (data_node/1/0).name
+    assert_equal 8, (data_node/1/0)['Sales count']
+    assert_equal "John's Store", (data_node/1/0/0).name
+    assert_equal 8, (data_node/1/0/0)['Sales count']
+    assert_equal "Product A", (data_node/1/0/0/0).name
+    assert_equal 5, (data_node/1/0/0/0)['Sales count']
+  end
+
+  it "collects aggregate data in subgroups going farther than layer list" do
+    q = Mochigome::Query.new(
+      [Mochigome::SubgroupModel.new(Owner, :last_name), Owner, Store],
+      :aggregate_sources => [[Product, Sale]]
+    )
+    data_node = q.run
+
+    assert_equal "Smith", (data_node/1).name
+    assert_equal 8, (data_node/1)['Sales count']
+    assert_equal "John Smith", (data_node/1/0).name
+    assert_equal 8, (data_node/1/0)['Sales count']
+    assert_equal "John's Store", (data_node/1/0/0).name
+    assert_equal 8, (data_node/1/0/0)['Sales count']
+  end
+
+  it "collects aggregate data using data model as focus if focus not supplied" do
+    q = Mochigome::Query.new(
+      [Owner, Store, Product],
+      :aggregate_sources => [Sale]
+    )
+
+    data_node = q.run
+
+    assert_equal "Jane's Store (North)", (data_node/1/0).name
+    assert_equal 11, (data_node/1/0)['Sales count']
+
+    assert_equal "Jane Doe", (data_node/1).name
+    assert_equal 16, (data_node/1)['Sales count']
+
+    assert_equal 24, data_node['Sales count']
+  end
+
   it "collects aggregate data on layers above the focus" do
     q = Mochigome::Query.new(
       [Owner, Store, Product],
@@ -360,13 +432,6 @@ describe Mochigome::Query do
     end
   end
 
-  it "will not allow a query on targets of different types" do
-    q = Mochigome::Query.new([Owner, Store, Product])
-    assert_raises Mochigome::QueryError do
-      q.run([@store_x, @john])
-    end
-  end
-
   it "will not allow a query on targets not in the layer list" do
     q = Mochigome::Query.new([Product])
     assert_raises Mochigome::QueryError do
@@ -413,5 +478,12 @@ describe Mochigome::Query do
     assert_equal 1, q.instance_variable_get(:@ids_rel).to_sql.scan(/join .stores./i).size
   end
 
+  it "complains if run given a condition on an unused table" do
+    q = Mochigome::Query.new([Product, Store])
+    assert_raises Mochigome::QueryError do
+      q.run(Arel::Table.new(Category.table_name)[:id].eq(41))
+    end
+  end
+
   # TODO: Test that access filter join paths are followed, rather than closest path
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: 
   segments: 
   - 0
   - 0
-  - 8
-  version: 0.0.8
+  - 9
+  version: 0.0.9
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-12 00:00:00 Z
+date: 2012-03-16 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -98,6 +98,7 @@ files:
 - lib/mochigome_ver.rb
 - lib/model_extensions.rb
 - lib/query.rb
+- lib/subgroup_model.rb
 - test/app_root/app/controllers/application_controller.rb
 - test/app_root/app/controllers/owners_controller.rb
 - test/app_root/app/models/boring_datum.rb