mochigome 0.0.10 → 0.1

data/lib/arel_rails2_hacks.rb

@@ -39,6 +39,7 @@ unless ActiveRecord::ConnectionAdapters::ConnectionPool.methods.include?("table_
     end
   end
 
+  # FIXME: Shouldn't use select_rows anymore
   class ActiveRecord::ConnectionAdapters::SQLiteAdapter
     def select_rows(sql, name = nil)
       execute(sql, name).map do |row|

data/lib/mochigome.rb

@@ -1,8 +1,9 @@
 require 'mochigome_ver'
 require 'exceptions'
+require 'model_extensions'
+require 'model_graph'
 require 'data_node'
 require 'query'
-require 'model_extensions'
 require 'formatting'
 require 'subgroup_model'
 require 'arel_rails2_hacks'

data/lib/mochigome_ver.rb

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

data/lib/model_graph.rb

@@ -0,0 +1,132 @@
+require 'rgl/adjacency'
+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 = {}
+
+    # Take an expression and return a Set of all models it references
+    def self.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]
+        raise ModelSetupError.new("Table->model lookup error") unless model
+        r.add model
+      end
+      r
+    end
+
+    def self.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
+      (0..(real_path.size-2)).each do |i|
+        rel = relation_func(real_path[i], real_path[i+1]).call(rel)
+      end
+      rel
+    end
+
+    def self.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)
+      update_assoc_graph(models)
+      model_queue = models.dup
+      path = [model_queue.shift]
+      until model_queue.empty?
+        src = path.last
+        tgt = model_queue.shift
+        next if src == tgt
+        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(
+          "Path thru #{models.map(&:name).join('-')} doubles back: " +
+          path.map(&:name).join('-')
+        )
+      end
+      path
+    end
+
+    def self.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
+        added_models << model
+
+        if @@table_to_model.has_key?(model.table_name)
+          raise ModelError.new("Table #{model.table_name} used twice")
+        end
+        @@table_to_model[model.table_name] = model
+
+        model.reflections.
+        reject{|name, assoc| assoc.through_reflection}.
+        each do |name, assoc|
+          # TODO: What about self associations?
+          # TODO: What about associations to the same model on different keys?
+          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)
+            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
+        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
+        end
+
+        # Use through reflections as a hint for preferred indirect paths
+        model.reflections.
+        select{|name, assoc| assoc.through_reflection}.
+        each do |name, assoc|
+          begin
+            foreign_model = assoc.klass
+            join_model = assoc.through_reflection.klass
+          rescue NameError
+            # 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]
+        end
+      end
+    end
+  end
+end

data/lib/query.rb

@@ -1,243 +1,116 @@
-require 'rgl/adjacency'
-require 'rgl/traversal'
-
 module Mochigome
   class Query
     def initialize(layer_types, options = {})
       # 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 or raise QueryError.new("No valid path thru layer list") #TODO Test
+      @layers_path = ModelGraph.path_thru(@layer_types)
 
       @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
       aggregate_sources = options.delete(:aggregate_sources) || []
       unless options.empty?
         raise QueryError.new("Unknown options: #{options.keys.inspect}")
       end
 
-      @ids_rel = self.class.relation_over_path(@layers_path).
-        project(@layers_path.map{|m| m.arel_primary_key})
-      @ids_rel = access_filtered_relation(@ids_rel, @layers_path)
+      @ids_rel = Relation.new(@layer_types)
+      @ids_rel.apply_access_filter_func(@access_filter)
 
-      # TODO: Validate that aggregate_sources is in the correct format
-      aggs_by_model = {}
+      @aggregate_rels = {}
       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
+        focus_model, data_model = case a
+          when Array then [a.first, a.second]
+          else [a, a]
         end
-        aggs_by_model[focus_cls] ||= []
-        aggs_by_model[focus_cls] << data_cls
-      end
 
-      @aggregate_rels = {}
-      aggs_by_model.each do |focus_model, data_models|
-        # Need to do a relation over the entire path in case query has
-        # a condition on something other than the focus model layer.
-        # TODO: Would be better to only do this if necesssitated by the
-        # conditions supplied to the query when it is ran, and/or
-        # the access filter.
-        focus_rel = self.class.relation_over_path(@layers_path)
-
-        @aggregate_rels[focus_model] = {}
-        data_models.each do |data_model|
-          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|
-            remainder = f2d_path.drop_while{|m| m != link_model}
-            next if (remainder.drop(1) & @layers_path).size > 0
-            if @layers_path.include?(link_model)
-              agg_path = remainder
-              key_path = @layers_path.take(@layers_path.index(focus_model)+1)
-              break
-            else
-              # Route it from the closest layer model
-              @layers_path.reverse.each do |layer|
-                p = self.class.path_thru([layer, link_model]) + remainder.drop(1) # TODO: Handle path_thru returning nil
-                next if (p.drop(1) & @layers_path).size > 0
-                next if p.uniq.size != p.size
-                if agg_path.nil? || p.size < agg_path.size
-                  agg_path = p
-                  key_path = @layers_path
-                end
-              end
-            end
-          end
+        agg_rel = Relation.new(@layer_types) # TODO Only go as far as focus
+        agg_rel.join_to_model(focus_model)
+        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}
+
+        agg_fields = data_model.mochigome_aggregation_settings.
+          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
 
-          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)
-          agg_fields = data_model.mochigome_aggregation_settings.options[:fields].reject{|a| a[:in_ruby]}
-          agg_joined_models = @layers_path + agg_path
-          agg_fields.each_with_index do |a, i|
-            (a[:joins] || []).each do |m|
-              unless agg_joined_models.include?(m)
-                cand = nil
-                agg_joined_models.each do |agg_join_src_m|
-                  p = self.class.path_thru([agg_join_src_m, m])
-                  if p && (cand.nil? || p.size < cand.size)
-                    cand = p
-                  end
-                end
-                if cand
-                  agg_data_rel = self.class.relation_over_path(cand, agg_data_rel)
-                  agg_joined_models += cand
-                else
-                  raise QueryError.new("Can't join from query to agg join model #{m.name}") # TODO: Test this
-                end
-              end
+        @aggregate_rels[focus_model] ||= {}
+        @aggregate_rels[focus_model][data_model] = (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
-            d_expr = a[:value_proc].call(data_model.arel_table)
-            agg_data_rel.project(d_expr.as("d#{i}"))
-          end
 
-          @aggregate_rels[focus_model][data_model] = (0..key_cols.length).map{|n|
-            lambda {|cond|
-              d_rel = agg_data_rel.dup
-              d_cols = key_cols.take(n) + [data_model.arel_primary_key]
-              d_cols.each_with_index do |col, i|
-                d_rel.project(col.as("g#{i}")).group(col)
-              end
-              d_rel.where(cond) if cond
-
-              # FIXME: This subtable won't be necessary for all aggregation funcs.
-              # When we can avoid it, we should, for performance.
-              a_rel = Arel::SelectManager.new(
-                Arel::Table.engine,
-                Arel.sql("(#{d_rel.to_sql}) as mochigome_data")
-              )
-              d_tbl = Arel::Table.new("mochigome_data")
-              agg_fields.each_with_index do |a, i|
-                a_rel.project(a[:agg_proc].call(d_tbl["d#{i}"]))
-              end
-              key_cols.take(n).each_with_index do |col, i|
-                outer_name = "og#{i}"
-                a_rel.project(d_tbl["g#{i}"].as(outer_name)).group(outer_name)
-              end
-              a_rel
-            }
+            # 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
-
+        }
       end
     end
 
     def run(cond = nil)
-      root = DataNode.new(:report, @name)
-
-      if cond.is_a?(ActiveRecord::Base)
-        cond = [cond]
-      end
-      if cond.is_a?(Array)
-        return root if cond.empty?
-        cond = cond.inject(nil) do |expr, obj|
-          subexpr = obj.class.arel_primary_key.eq(obj.id)
-          expr ? expr.or(subexpr) : subexpr
-        end
-      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.real_model? && m.table_name == t}
-        end
-      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 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}, @layer_types)
+      root = create_node_tree(cond)
+      load_aggregate_data(root, cond)
+      return root
+    end
 
-      @aggregate_rels.each do |focus_model, data_model_rels|
-        super_types = @layer_types.take_while{|m| m != focus_model}
-        super_cols = super_types.map{|m| @layers_path.find_index(m)}
-        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 = {}
-            # Each row has aggs_count data fields, followed by the id fields
-            # from least specific to most.
-            @layer_types.first.connection.select_rows(q.to_sql).each do |row|
-              if row.size == aggs_count
-                data_tree = row.take(aggs_count)
-              else
-                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 + sc_num
-                  c = (c[row[col_num]] ||= {})
-                end
-                c[row.last] = row.take(aggs_count)
-              end
-            end
-            insert_aggregate_data_fields(root, data_tree, data_model)
-          end
-        end
-      end
+    private
 
+    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(" => ")}
         AR Path: #{@layers_path.map(&:name).join(" => ")}
       eos
-      root.comment.gsub!(/\n +/, "\n")
-      root.comment.lstrip!
-
-      return root
-    end
+      root.comment.gsub!(/(\n|^) +/, "\\1")
 
-    private
+      r = @ids_rel.dup
+      r.apply_condition(cond)
+      ids_table = @layer_types.first.connection.select_all(r.to_sql)
+      fill_layers(ids_table, {[] => root}, @layer_types)
 
-    def access_filtered_relation(r, models)
-      joined = Set.new
-      models.uniq.each do |model|
-        h = @access_filter.call(model)
-        h.delete(:join_paths).try :each do |path|
-          (0..(path.size-2)).each do |i|
-            next if models.include?(path[i+1]) or joined.include?(path[i+1])
-            r = self.class.relation_func(path[i], path[i+1]).call(r)
-            joined.add path[i+1]
-          end
-        end
-        if h[:condition]
-          r = r.where(h.delete(:condition))
-        end
-        unless h.empty?
-          raise QueryError.new("Unknown assoc filter keys #{h.keys.inspect}")
-        end
-      end
-      r
+      root
     end
 
-    def fill_layers(ids_table, parents, types, parent_col_nums = [])
-      return if types.size == 0
+    def fill_layers(ids_table, parents, types, type_idx = 0)
+      return if type_idx >= types.size
 
-      model = types.first
-      col_num = @layers_path.find_index(model)
+      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[col_num]
+        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_col_nums.map{|i| row[i]}
+        cur_to_parent[cur_id].add parent_types.map{|m| row["#{m.name}_id"]}
       end
 
       layer = {}
@@ -260,7 +133,36 @@ module Mochigome
         end
       end
 
-      fill_layers(ids_table, layer, types.drop(1), parent_col_nums + [col_num])
+      fill_layers(ids_table, layer, types, type_idx + 1)
+    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
+              end
+            end
+            insert_aggregate_data_fields(node, data_tree, data_model)
+          end
+        end
+      end
     end
 
     def insert_aggregate_data_fields(node, table, data_model)
@@ -283,122 +185,112 @@ module Mochigome
         end
       end
     end
+  end
 
-    # TODO: Move the stuff below into its own module
+  private
 
-    # Take an expression and return a Set of all tables it references
-    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
+  class Relation
+    def initialize(layers)
+      @spine_layers = layers
+      @spine = ModelGraph.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)
+
+      @spine_layers.each{|m| select_model_id(m)}
     end
 
-    @@graphed_models = Set.new
-    @@assoc_graph = RGL::DirectedAdjacencyGraph.new
-    @@edge_relation_funcs = {}
-    @@shortest_paths = {}
-
-    def self.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
-      (0..(real_path.size-2)).each do |i|
-        rel = relation_func(real_path[i], real_path[i+1]).call(rel)
-      end
-      rel
+    def to_arel
+      @rel.clone
     end
 
-    def self.relation_func(u, v)
-      @@edge_relation_funcs[[u,v]] or
-        raise QueryError.new "No assoc from #{u.name} to #{v.name}"
+    def to_sql
+      @rel.to_sql
     end
 
-    def self.path_thru(models)
-      update_assoc_graph(models)
-      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)
+    def clone
+      c = super
+      c.instance_variable_set :@spine, @spine.dup
+      c.instance_variable_set :@models, @models.dup
+      c.instance_variable_set :@rel, @rel.project
+      c
+    end
+
+    def join_to_model(model)
+      return if @models.include?(model)
+
+      # 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])
+        if path && (best_path.nil? || path.size < best_path.size)
+          best_path = path
         end
-        path << tgt
       end
-      unless path.uniq.size == path.size
-        raise QueryError.new(
-          "Path thru #{models.map(&:name).join('-')} doubles back: " +
-          path.map(&:name).join('-')
-        )
+
+      raise QueryError.new("No path to #{model}") unless best_path
+      join_on_path(best_path)
+    end
+
+    def join_on_path_thru(path)
+      join_on_path(ModelGraph.path_thru(path).uniq)
+    end
+
+    def join_on_path(path)
+      path = path.map{|e| (e.real_model? ? e : e.model)}.uniq
+      (0..(path.size-2)).map{|i| [path[i], path[i+1]]}.each do |src, tgt|
+        add_join_link src, tgt
       end
-      path
     end
 
-    def self.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
-        added_models << model
-
-        model.reflections.
-        reject{|name, assoc| assoc.through_reflection}.
-        each do |name, assoc|
-          # TODO: What about self associations?
-          # TODO: What about associations to the same model on different keys?
-          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)
-            model_queue.push(foreign_model)
-          end
+    def select_model_id(m)
+      @rel = @rel.project(m.arel_primary_key.as("#{m.name}_id"))
+    end
+
+    def select_expr(e)
+      ModelGraph.expr_models(e).each{|m| join_to_model(m)}
+      @rel = @rel.project(e)
+    end
+
+    def apply_condition(cond)
+      return unless cond
+      if cond.is_a?(ActiveRecord::Base)
+        cond = [cond]
+      end
+      if cond.is_a?(Array)
+        cond = cond.inject(nil) do |expr, obj|
+          subexpr = obj.class.arel_primary_key.eq(obj.id)
+          expr ? expr.or(subexpr) : subexpr
         end
       end
 
-      added_models.each do |model|
-        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
-        end
+      ModelGraph.expr_models(cond).each{|m| join_to_model(m)}
+      @rel = @rel.where(cond)
+    end
 
-        # Use through reflections as a hint for preferred indirect paths
-        model.reflections.
-        select{|name, assoc| assoc.through_reflection}.
-        each do |name, assoc|
-          begin
-            foreign_model = assoc.klass
-            join_model = assoc.through_reflection.klass
-          rescue NameError
-            # 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]
+    def apply_access_filter_func(func)
+      @models.each do |m|
+        h = func.call(m)
+        h.delete(:join_paths).try :each do |path|
+          join_on_path path
+        end
+        if h[:condition]
+          apply_condition h.delete(:condition)
+        end
+        unless h.empty?
+          raise QueryError.new("Unknown assoc filter keys #{h.keys.inspect}")
         end
       end
     end
+
+    private
+
+    def add_join_link(src, tgt)
+      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)
+      @models.add tgt
+    end
   end
 end

data/lib/subgroup_model.rb

@@ -14,7 +14,7 @@ module Mochigome
     end
 
     def name
-      "#{@model}%#{@attr}"
+      "#{@model}$#{@attr}" # Warning: This has to be a valid SQL field name
     end
 
     def human_name

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

@@ -3,7 +3,7 @@ class Sale < ActiveRecord::Base
     a.fields [:count, {
       "Gross" => [:sum, lambda {|t|
         Product.arel_table[:price]
-      }, {:joins => [Product]}]
+      }]
     }]
   end
 

data/test/unit/query_test.rb

@@ -65,13 +65,6 @@ describe Mochigome::Query do
     assert_empty obj.children
   end
 
-  it "returns an empty DataNode if given an empty array" do
-    q = Mochigome::Query.new([Category, Product])
-    data_node = q.run([])
-    assert_empty data_node
-    assert_no_children data_node
-  end
-
   it "returns all possible results if no conditions given" do
     q = Mochigome::Query.new([Category, Product])
     data_node = q.run()
@@ -88,8 +81,7 @@ describe Mochigome::Query do
 
   it "can build a one-layer DataNode when given an arbitrary Arel condition" do
     q = Mochigome::Query.new([Product])
-    tbl = Arel::Table.new(Product.table_name)
-    data_node = q.run(tbl[:name].eq(@product_a.name))
+    data_node = q.run(Product.arel_table[:name].eq(@product_a.name))
     assert_equal_children [@product_a], data_node
     assert_no_children data_node/0
   end
@@ -447,18 +439,11 @@ describe Mochigome::Query do
     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
-      q.run(@category1)
-    end
-  end
-
   it "can use a provided access filter function to limit query results" do
     af = proc do |cls|
       return {} unless cls == Product
       return {
-        :condition => Arel::Table.new(Product.table_name)[:category_id].gt(0)
+        :condition => Product.arel_table[:category_id].gt(0)
       }
     end
     q = Mochigome::Query.new([Product], :access_filter => af)
@@ -472,7 +457,7 @@ describe Mochigome::Query do
       return {} unless cls == Product
       return {
         :join_paths => [[Product, StoreProduct, Store]],
-        :condition => Arel::Table.new(Store.table_name)[:name].matches("Jo%")
+        :condition => Store.arel_table[:name].matches("Jo%")
       }
     end
     q = Mochigome::Query.new([Product], :access_filter => af)
@@ -486,18 +471,17 @@ describe Mochigome::Query do
       return {} unless cls == Product
       return {
         :join_paths => [[Product, StoreProduct, Store]],
-        :condition => Arel::Table.new(Store.table_name)[:name].matches("Jo%")
+        :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 "complains if run given a condition on an unused table" do
+  it "automatically joins if run given a condition on a new 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
+    dn = q.run(Category.arel_table[:name].eq(@category1.name))
+    assert_equal 2, dn.children.size
   end
 
   # TODO: Test that access filter join paths are followed, rather than closest path

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
   - 0
-  - 0
-  - 10
-  version: 0.0.10
+  - 1
+  version: "0.1"
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-01 00:00:00 Z
+date: 2012-04-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -97,6 +96,7 @@ files:
 - lib/mochigome.rb
 - lib/mochigome_ver.rb
 - lib/model_extensions.rb
+- lib/model_graph.rb
 - lib/query.rb
 - lib/subgroup_model.rb
 - test/app_root/app/controllers/application_controller.rb