mochigome 0.1 → 0.1.1

data/Rakefile

@@ -58,8 +58,8 @@ gemspec = Gem::Specification.new do |s|
   s.authors      = ["David Mike Simon"]
   s.email        = "david.mike.simon@gmail.com"
   s.homepage     = "http://github.com/DavidMikeSimon/mochigome"
-  s.summary      = "User-customizable report generator"
-  s.description  = "Report generator that uses your ActiveRecord associations"
+  s.summary      = "The do-what-I-mean report generator"
+  s.description  = "Report generator that graphs over ActiveRecord associations"
   s.files        = `git ls-files .`.split("\n") - [".gitignore"]
   s.platform     = Gem::Platform::RUBY
   s.require_path = 'lib'
@@ -69,6 +69,7 @@ gemspec = Gem::Specification.new do |s|
   s.add_dependency('ruport')
   s.add_dependency('nokogiri')
   s.add_dependency('rgl')
+  s.add_dependency('activerecord')
 end
 
 Gem::PackageTask.new(gemspec) do |pkg|

data/lib/mochigome_ver.rb

@@ -1,3 +1,3 @@
 module Mochigome
-  VERSION = "0.1"
+  VERSION = "0.1.1"
 end

data/lib/model_graph.rb

@@ -4,28 +4,30 @@ require 'rgl/traversal'
 module Mochigome
   private
 
-  module ModelGraph
-    @@graphed_models = Set.new
-    @@table_to_model = {}
-    @@assoc_graph = RGL::DirectedAdjacencyGraph.new
-    @@edge_relation_funcs = {}
-    @@shortest_paths = {}
+  class ModelGraph
+    def initialize
+      @graphed_models = Set.new
+      @table_to_model = {}
+      @assoc_graph = RGL::DirectedAdjacencyGraph.new
+      @edge_relation_funcs = {}
+      @shortest_paths = {}
+    end
 
     # Take an expression and return a Set of all models it references
-    def self.expr_models(e)
+    def expr_models(e)
       r = Set.new
       [:expr, :left, :right].each do |m|
         r += expr_models(e.send(m)) if e.respond_to?(m)
       end
       if e.respond_to?(:relation)
-        model = @@table_to_model[e.relation.name]
+        model = @table_to_model[e.relation.name]
         raise ModelSetupError.new("Table->model lookup error") unless model
         r.add model
       end
       r
     end
 
-    def self.relation_over_path(path, rel = nil)
+    def relation_over_path(path, rel = nil)
       real_path = path.map{|e| (e.real_model? ? e : e.model)}.uniq
       # Project ensures that we return a Rel, not a Table, even if path is empty
       rel ||= real_path.first.arel_table.project
@@ -35,12 +37,12 @@ module Mochigome
       rel
     end
 
-    def self.relation_func(u, v)
-      @@edge_relation_funcs[[u,v]] or
+    def relation_func(u, v)
+      @edge_relation_funcs[[u,v]] or
         raise QueryError.new "No assoc from #{u.name} to #{v.name}"
     end
 
-    def self.path_thru(models)
+    def path_thru(models)
       update_assoc_graph(models)
       model_queue = models.dup
       path = [model_queue.shift]
@@ -51,7 +53,7 @@ module Mochigome
         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]]
+          seg = @shortest_paths[[real_src,real_tgt]]
           unless seg
             raise QueryError.new("No path: #{real_src.name} to #{real_tgt.name}")
           end
@@ -68,20 +70,42 @@ module Mochigome
       path
     end
 
-    def self.update_assoc_graph(models)
+    private
+
+    def update_assoc_graph(models)
       model_queue = models.dup
       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
+        next if @graphed_models.include? model
+        @graphed_models.add model
         added_models << model
 
-        if @@table_to_model.has_key?(model.table_name)
-          raise ModelError.new("Table #{model.table_name} used twice")
+        if @table_to_model.has_key?(model.table_name)
+          # TODO Test this!
+          # Find the nearest common ancestor that derives from AR::Base
+          common = nil
+          [model, @table_to_model[model.table_name]].each do |tgt|
+            a = tgt.ancestors
+            a = a.select{|c| c.ancestors.include?(ActiveRecord::Base)}
+            if common.nil?
+              common = a
+            else
+              common = common & a
+            end
+          end
+
+          if common.empty? || common.first == ActiveRecord::Base
+            raise ModelSetupError.new(
+              "Unrelated models %s and %s both claim to use table %s" %
+              [model, @table_to_model[model.table_name], model.table_name]
+            )
+          end
+          @table_to_model[model.table_name] = common.first
+        else
+          @table_to_model[model.table_name] = model
         end
-        @@table_to_model[model.table_name] = model
 
         model.reflections.
         reject{|name, assoc| assoc.through_reflection}.
@@ -91,25 +115,25 @@ module Mochigome
           next if assoc.options[:polymorphic] # TODO How to deal with these? Check for matching has_X assoc?
           foreign_model = assoc.klass
           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)
-          unless @@graphed_models.include?(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)
+          unless @graphed_models.include?(foreign_model)
             model_queue.push(foreign_model)
           end
         end
       end
 
       added_models.each do |model|
-        next unless @@assoc_graph.has_vertex?(model)
-        path_tree = @@assoc_graph.bfs_search_tree_from(model).reverse
+        next unless @assoc_graph.has_vertex?(model)
+        path_tree = @assoc_graph.bfs_search_tree_from(model).reverse
         path_tree.depth_first_search do |tgt_model|
           next if tgt_model == model
           path = [tgt_model]
           while (parent = path_tree.adjacent_vertices(path.first).first)
             path.unshift parent
           end
-          @@shortest_paths[[model,tgt_model]] = path
+          @shortest_paths[[model,tgt_model]] = path
         end
 
         # Use through reflections as a hint for preferred indirect paths
@@ -123,8 +147,8 @@ module Mochigome
             # FIXME Can't handle polymorphic through reflection
           end
           edge = [model,foreign_model]
-          next if @@shortest_paths[edge].try(:size).try(:<, 3)
-          @@shortest_paths[edge] = [model, join_model, foreign_model]
+          next if @shortest_paths[edge].try(:size).try(:<, 3)
+          @shortest_paths[edge] = [model, join_model, foreign_model]
         end
       end
     end

data/lib/query.rb

@@ -3,7 +3,6 @@ module Mochigome
     def initialize(layer_types, options = {})
       # TODO: Validate layer types: not empty, AR, act_as_mochigome_focus
       @layer_types = layer_types
-      @layers_path = ModelGraph.path_thru(@layer_types)
 
       @name = options.delete(:root_name).try(:to_s) || "report"
       @access_filter = options.delete(:access_filter) || lambda {|cls| {}}
@@ -28,10 +27,8 @@ module Mochigome
         agg_rel.join_on_path_thru([focus_model, data_model])
         agg_rel.apply_access_filter_func(@access_filter)
 
-        focus_idx = @layers_path.index(focus_model)
-        key_path = focus_idx ? @layers_path.take(focus_idx+1) : @layers_path
-        key_path = key_path.select{|m| @layer_types.include?(m)}
-        key_cols = key_path.map{|m| m.arel_primary_key}
+        key_models = @ids_rel.spine_layers_thru(focus_model)
+        key_cols = key_models.map{|m| m.arel_primary_key}
 
         agg_fields = data_model.mochigome_aggregation_settings.
           options[:fields].reject{|a| a[:in_ruby]}
@@ -86,7 +83,7 @@ module Mochigome
         Mochigome Version: #{Mochigome::VERSION}
         Report Generated: #{Time.now}
         Layers: #{@layer_types.map(&:name).join(" => ")}
-        AR Path: #{@layers_path.map(&:name).join(" => ")}
+        AR Path: #{@ids_rel.full_spine_path.map(&:name).join(" => ")}
       eos
       root.comment.gsub!(/(\n|^) +/, "\\1")
 
@@ -191,11 +188,12 @@ module Mochigome
 
   class Relation
     def initialize(layers)
+      @model_graph = ModelGraph.new
       @spine_layers = layers
-      @spine = ModelGraph.path_thru(layers) or
+      @spine = @model_graph.path_thru(layers) or
         raise QueryError.new("No valid path thru #{layers.inspect}") #TODO Test
       @models = Set.new @spine
-      @rel = ModelGraph.relation_over_path(@spine)
+      @rel = @model_graph.relation_over_path(@spine)
 
       @spine_layers.each{|m| select_model_id(m)}
     end
@@ -208,6 +206,16 @@ 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 :@spine, @spine.dup
@@ -222,7 +230,7 @@ module Mochigome
       # Route to it in as few steps as possible, closer to spine end if tie.
       best_path = nil
       (@spine.reverse + (@models.to_a - @spine)).each do |link_model|
-        path = ModelGraph.path_thru([link_model, model])
+        path = @model_graph.path_thru([link_model, model])
         if path && (best_path.nil? || path.size < best_path.size)
           best_path = path
         end
@@ -233,7 +241,7 @@ module Mochigome
     end
 
     def join_on_path_thru(path)
-      join_on_path(ModelGraph.path_thru(path).uniq)
+      join_on_path(@model_graph.path_thru(path).uniq)
     end
 
     def join_on_path(path)
@@ -248,7 +256,7 @@ module Mochigome
     end
 
     def select_expr(e)
-      ModelGraph.expr_models(e).each{|m| join_to_model(m)}
+      @model_graph.expr_models(e).each{|m| join_to_model(m)}
       @rel = @rel.project(e)
     end
 
@@ -264,7 +272,7 @@ module Mochigome
         end
       end
 
-      ModelGraph.expr_models(cond).each{|m| join_to_model(m)}
+      @model_graph.expr_models(cond).each{|m| join_to_model(m)}
       @rel = @rel.where(cond)
     end
 
@@ -289,7 +297,7 @@ module Mochigome
       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 = ModelGraph.relation_func(src, tgt).call(@rel)
+      @rel = @model_graph.relation_func(src, tgt).call(@rel)
       @models.add tgt
     end
   end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  version: "0.1"
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - David Mike Simon
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-09 00:00:00 Z
+date: 2012-04-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -73,7 +74,21 @@ dependencies:
   prerelease: false
   type: :runtime
   name: rgl
-description: Report generator that uses your ActiveRecord associations
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+  prerelease: false
+  type: :runtime
+  name: activerecord
+description: Report generator that graphs over ActiveRecord associations
 email: david.mike.simon@gmail.com
 executables: []
 
@@ -159,6 +174,6 @@ rubyforge_project: "[none]"
 rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: User-customizable report generator
+summary: The do-what-I-mean report generator
 test_files: []