mochigome 0.0.3 → 0.0.4

data/Gemfile

@@ -1,6 +1,7 @@
 source :rubygems
 
 gem 'rails', '2.3.12'
+gem 'arel', '~> 2.1'
 gem 'nokogiri'
 gem 'ruport'
 gem 'rgl'
@@ -8,6 +9,7 @@ gem 'rgl'
 gem 'sqlite3'
 gem 'mysql'
 gem 'factory_girl', '2.0.4'
+gem 'rdoc'
 gem 'rcov'
 gem 'ruby-prof'
 gem 'minitest'

data/Gemfile.lock

@@ -11,6 +11,7 @@ GEM
     activeresource (2.3.12)
       activesupport (= 2.3.12)
     activesupport (2.3.12)
+    arel (2.1.4)
     autowatchr (0.1.5)
       watchr
     color (1.4.1)
@@ -37,6 +38,7 @@ GEM
       rake (>= 0.8.3)
     rake (0.9.2)
     rcov (0.9.10)
+    rdoc (3.9.4)
     rev (0.3.2)
       iobuffer (>= 0.1.3)
     rgl (0.4.0)
@@ -57,6 +59,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  arel (~> 2.1)
   autowatchr
   factory_girl (= 2.0.4)
   minitest
@@ -65,6 +68,7 @@ DEPENDENCIES
   nokogiri
   rails (= 2.3.12)
   rcov
+  rdoc
   rev
   rgl
   ruby-prof

data/Rakefile

@@ -59,12 +59,13 @@ gemspec = Gem::Specification.new do |s|
   s.email        = "david.mike.simon@gmail.com"
   s.homepage     = "http://github.com/DavidMikeSimon/mochigome"
   s.summary      = "User-customizable report generator"
-  s.description  = "Mochigome builds sophisticated report datasets from your ActiveRecord models"
+  s.description  = "Report generator that uses your ActiveRecord associations"
   s.files        = `git ls-files .`.split("\n") - [".gitignore"]
   s.platform     = Gem::Platform::RUBY
   s.require_path = 'lib'
   s.rubyforge_project = '[none]'
 
+  s.add_dependency('arel', '~> 2.1')
   s.add_dependency('ruport')
   s.add_dependency('nokogiri')
   s.add_dependency('rgl')

data/lib/arel_rails2_hacks.rb

@@ -0,0 +1,49 @@
+unless ActiveRecord::ConnectionAdapters::ConnectionPool.methods.include?("table_exists?")
+  module Mochigome
+    class ColumnsHashProxy
+      def initialize(pool)
+        @pool = pool
+        @cache = HashWithIndifferentAccess.new
+      end
+
+      def [](table_name)
+        cached(table_name)
+      end
+
+      private
+
+      def cached(table_name)
+        return @cache[table_name] if @cache.has_key?(:table_name)
+
+        @cache[table_name] = h = HashWithIndifferentAccess.new
+        @pool.with_connection do |c|
+          c.columns(table_name).each do |col|
+            h[col.name] = col
+          end
+        end
+        return h
+      end
+    end
+  end
+
+  class ActiveRecord::ConnectionAdapters::ConnectionPool
+    def table_exists?(name)
+      ActiveRecord::Base.connection_pool.with_connection do |c|
+        c.table_exists?(name)
+      end
+    end
+
+    @@columns_hash_proxy = nil
+    def columns_hash
+      @@columns_hash_proxy ||= Mochigome::ColumnsHashProxy.new(self)
+    end
+  end
+
+  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]}
+      end
+    end
+  end
+end

data/lib/data_node.rb

@@ -37,6 +37,10 @@ module Mochigome
       end
     end
 
+    def /(idx)
+      @children[idx]
+    end
+
     # TODO: Only define xml-related methods if nokogiri loaded
     def to_xml
       doc = Nokogiri::XML::Document.new

data/lib/exceptions.rb

@@ -3,4 +3,5 @@ module Mochigome
   class InvalidLayerError < StandardError; end
   class QueryError < StandardError; end
   class DataNodeError < StandardError; end
+  class AssociationError < StandardError; end
 end

data/lib/mochigome.rb

@@ -3,5 +3,6 @@ require 'exceptions'
 require 'data_node'
 require 'query'
 require 'model_extensions'
+require 'arel_rails2_hacks'
 
 ActiveRecord::Base.send(:include, Mochigome::ModelExtensions)

data/lib/mochigome_ver.rb

@@ -1,3 +1,3 @@
 module Mochigome
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/model_extensions.rb

@@ -1,9 +1,4 @@
 module Mochigome
-  @reportFocusModels = []
-  def self.reportFocusModels
-    @reportFocusModels
-  end
-
   module ModelExtensions
     def self.included(base)
       base.extend(ClassMethods)
@@ -11,75 +6,68 @@ module Mochigome
       base.write_inheritable_attribute :mochigome_focus_settings, nil
       base.class_inheritable_reader :mochigome_focus_settings
 
-      base.write_inheritable_attribute :mochigome_aggregations, []
-      base.class_inheritable_reader :mochigome_aggregations
+      # TODO: Use an ordered hash for this
+      base.write_inheritable_attribute :mochigome_aggregation_settings, nil
+      base.class_inheritable_reader :mochigome_aggregation_settings
     end
 
     module ClassMethods
       def acts_as_mochigome_focus
-        if self.try(:mochigome_focus_settings).try(:orig_class) == self
+        if self.try(:mochigome_focus_settings).try(:model) == self
           raise Mochigome::ModelSetupError.new("Already acts_as_mochigome_focus for #{self.name}")
         end
         settings = ReportFocusSettings.new(self)
         yield settings if block_given?
         write_inheritable_attribute :mochigome_focus_settings, settings
         send(:include, InstanceMethods)
-        Mochigome::reportFocusModels << self
       end
 
       def acts_as_mochigome_focus?
         !!mochigome_focus_settings
       end
 
-      AGGREGATION_FUNCS = {
-        'count' => 'count(*)',
-        'distinct' => 'count(distinct %s)',
-        'average' => 'avg(%s)',
-        'avg' => 'avg(%s)',
-        'minimum' => 'min(%s)',
-        'min' => 'min(%s)',
-        'maximum' => 'max(%s)',
-        'max' => 'max(%s)',
-        'sum' => 'sum(%s)'
-      }
-
-      def has_mochigome_aggregations(aggregations)
-        unless aggregations.respond_to?(:each)
-          raise ModelSetupError.new "Call has_mochigome_aggregations with an Enumerable"
+      # 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}")
         end
+        settings = AggregationSettings.new(self)
+        yield settings if block_given?
+        write_inheritable_attribute :mochigome_aggregation_settings, settings
+      end
 
-        def aggregation_opts(obj)
-          if obj.is_a?(String) or obj.is_a?(Symbol)
-            obj = obj.to_s
-            AGGREGATION_FUNCS.each do |func, expr_pat|
-              if expr_pat.include?('%s')
-                if obj =~ /^#{func}[-_ ](.+)/i
-                  return {:expr => (expr_pat % $1)}
-                end
-              else
-                if obj.downcase == func
-                  return {:expr => expr_pat}
-                end
-              end
-            end
-            return {:expr => obj} # Assume the string is just a plain SQL expression
-          elsif obj.is_a?(Array) and obj.size == 2
-            return {:conditions => obj[1]}.merge(aggregation_opts(obj[0]))
+      def arelified_assoc(name)
+        # TODO: Deal with polymorphic assocs.
+        model = self
+        assoc = reflect_on_association(name)
+        raise AssociationError.new("No such assoc #{name}") unless assoc
+        table = Arel::Table.new(table_name)
+        ftable = Arel::Table.new(assoc.klass.table_name)
+        lambda do |r|
+          # FIXME: This acts as though arel methods are non-destructive,
+          # but they are, right? Except, I can't remove the rel
+          # assignment from relation_over_path...
+          cond = nil
+          if assoc.belongs_to?
+            cond = table[assoc.association_foreign_key].eq(
+              ftable[assoc.klass.primary_key]
+            )
+          else
+            cond = table[primary_key].eq(ftable[assoc.primary_key_name])
           end
-          raise ModelSetupError.new "Invalid aggregation expr: #{obj.inspect}"
-        end
 
-        additions = aggregations.map do |f|
-          case f
-          when String, Symbol then
-            {:name => "%s %s" % [name.pluralize, f.to_s.sub("_", " ")]}.merge(aggregation_opts(f))
-          when Hash then
-            {:name => f.keys.first.to_s}.merge(aggregation_opts(f.values.first))
-          else raise ModelSetupError.new "Invalid aggregation: #{f.inspect}"
+          if assoc.options[:as]
+            # FIXME Can we assume that this is the polymorphic type field?
+            cond = cond.and(ftable["#{assoc.options[:as]}_type"].eq(model.name))
           end
+
+          # TODO: Apply association conditions.
+
+          r.join(ftable, Arel::Nodes::OuterJoin).on(cond)
         end
-        mochigome_aggregations.concat(additions)
       end
+
     end
 
     module InstanceMethods
@@ -89,6 +77,20 @@ module Mochigome
     end
   end
 
+  # FIXME This probably doesn't belong here. Maybe I should have a module
+  # for this kind of stuff and also put the standard aggregation functions
+  # in there?
+
+  def self.null_unless(pred, value_func)
+    lambda {|t|
+      value = value_func.call(t)
+      val_expr = Arel::Nodes::NamedFunction.new('',[value])
+      Arel::Nodes::SqlLiteral.new(
+        "(CASE WHEN #{pred.call(value).to_sql} THEN #{val_expr.to_sql} ELSE NULL END)"
+      )
+    }
+  end
+
   private
 
   class ReportFocus
@@ -98,7 +100,7 @@ module Mochigome
     def initialize(owner, settings)
       @owner = owner
       @name_proc = settings.options[:name] || lambda{|obj| obj.name}
-      @type_name = settings.options[:type_name] || owner.class.name
+      @type_name = settings.options[:type_name] || owner.class.human_name
       @fields = settings.options[:fields] || []
     end
 
@@ -106,10 +108,6 @@ module Mochigome
       @name_proc.call(@owner)
     end
 
-    def data(options = {})
-      field_data.merge(aggregate_data(:all, options))
-    end
-
     def field_data
       h = ActiveSupport::OrderedHash.new
       self.fields.each do |field|
@@ -117,66 +115,15 @@ module Mochigome
       end
       h
     end
-
-    def aggregate_data(assoc_name, options = {})
-      h = ActiveSupport::OrderedHash.new
-      assoc_name = assoc_name.to_sym
-      if assoc_name == :all
-        @owner.class.reflections.each do |name, assoc|
-          h.merge! aggregate_data(name, options)
-        end
-      else
-        assoc = @owner.class.reflections[assoc_name]
-        assoc_object = @owner
-        # TODO: Are there other ways context could matter besides :through assocs?
-        # TODO: What if a through reflection goes through _another_ through reflection?
-        if options.has_key?(:context) && assoc.through_reflection
-          # FIXME: This seems like it's repeating Query work
-          join_objs = assoc_object.send(assoc.through_reflection.name)
-          options[:context].each do |obj|
-            next unless join_objs.include?(obj)
-            assoc = assoc.source_reflection
-            assoc_object = obj
-            break
-          end
-        end
-        assoc.klass.mochigome_aggregations.each do |agg|
-          # TODO: There *must* be a better way to do this query
-          # It's ugly, involves an ActiveRecord creation, and causes lots of DB hits
-          sel_expr = "(#{agg[:expr]}) AS x"
-          cond_expr = agg[:conditions] ? agg[:conditions] : "1=1"
-          if assoc.belongs_to? # FIXME: or has_one
-            obj = assoc_object.send(assoc.name)
-            row = obj.class.find(obj.id, :select => sel_expr, :conditions => cond_expr)
-          else
-            row = assoc_object.send(assoc.name).first(:select => sel_expr, :conditions => cond_expr)
-          end
-          h[agg[:name]] = self.class.auto_numerify(row.x)
-        end
-      end
-      h
-    end
-
-    def self.auto_numerify(data)
-      # It's already some more specific type, leave it alone
-      return data unless data.is_a?(String)
-
-      # Try to turn data into an integer or float if appropriate
-      data = data.strip
-      if data =~ /\A[+-]?\d+(\.\d+)?\Z/
-        return ($1 and !$1.blank?) ? data.to_f : data.to_i
-      else
-        return data
-      end
-    end
   end
 
   class ReportFocusSettings
     attr_reader :options
-    attr_reader :orig_class
+    attr_reader :model
+    attr_reader :ordering
 
-    def initialize(orig_class)
-      @orig_class = orig_class
+    def initialize(model)
+      @model = model
       @options = {}
       @options[:fields] = []
     end
@@ -192,16 +139,15 @@ module Mochigome
       @options[:name] = n.to_proc
     end
 
-    def fields(fields)
-      def complain_if_reserved(s)
-        ['name', 'id', 'type', 'internal_type'].each do |reserved|
-          if s.gsub(/ +/, "_").underscore == reserved
-            raise ModelSetupError.new "Field name \"#{s}\" conflicts with reserved term \"#{reserved}\""
-          end
-        end
-        s
-      end
+    def ordering(n)
+      @options[:ordering] = n.to_s
+    end
 
+    def get_ordering
+      @options[:ordering] || @model.primary_key.to_s
+    end
+
+    def fields(fields)
       unless fields.respond_to?(:each)
         raise ModelSetupError.new "Call f.fields with an Enumerable"
       end
@@ -209,11 +155,11 @@ module Mochigome
       @options[:fields] += fields.map do |f|
         case f
         when String, Symbol then {
-          :name => complain_if_reserved(f.to_s.strip),
+          :name => Mochigome::complain_if_reserved_name(f.to_s.strip),
           :value_func => lambda{|obj| obj.send(f.to_sym)}
         }
         when Hash then {
-          :name => complain_if_reserved(f.keys.first.to_s.strip),
+          :name => Mochigome::complain_if_reserved_name(f.keys.first.to_s.strip),
           :value_func => f.values.first.to_proc
         }
         else raise ModelSetupError.new "Invalid field: #{f.inspect}"
@@ -221,4 +167,138 @@ module Mochigome
       end
     end
   end
+
+  class AggregationSettings
+    attr_reader :options
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+      @options = {}
+      @options[:fields] = []
+    end
+
+    def fields(aggs)
+      unless aggs.is_a?(Enumerable)
+        raise ModelSetupError.new "Call a.fields with an Enumerable"
+      end
+
+      @options[:fields].concat(aggs.map {|f|
+        case f
+        when String, Symbol then
+          {
+            :name => "%s %s" % [@model.name.pluralize, f.to_s.sub("_", " ")]
+          }.merge(Mochigome::split_out_aggregation_procs(f))
+        when Hash then
+          if f.size == 1
+            {
+              :name => f.keys.first.to_s
+            }.merge(Mochigome::split_out_aggregation_procs(f.values.first))
+          else
+            {
+              :name => f[:name],
+              :value_proc => Mochigome::value_proc(f[:value]),
+              :agg_proc => Mochigome::aggregation_proc(f[:aggregation])
+            }
+          end
+        else
+          raise ModelSetupError.new "Invalid aggregation: #{f.inspect}"
+        end
+      })
+    end
+
+    def hidden_fields(aggs)
+      orig_keys = Set.new @options[:fields].map{|a| a[:name]}
+      fields(aggs)
+      @options[:fields].each do |h|
+        next if orig_keys.include? h[:name]
+        h[:hidden] = true
+      end
+    end
+
+    def fields_in_ruby(aggs)
+      @options[:fields].concat(aggs.map {|f|
+        raise ModelSetupError.new "Invalid ruby agg #{f.inspect}" unless f.is_a?(Hash)
+        {
+          :name => f.keys.first.to_s,
+          :ruby_proc => f.values.first,
+          :in_ruby => true
+        }
+      })
+    end
+  end
+
+  def self.complain_if_reserved_name(s)
+    test_s = s.gsub(/ +/, "_").underscore
+    ['name', 'id', 'type', 'internal_type'].each do |reserved|
+      if test_s == reserved
+        raise ModelSetupError.new "Field name \"#{s}\" conflicts with reserved term \"#{reserved}\""
+      end
+    end
+    s
+  end
+
+  AGGREGATION_FUNCS = {
+    :count => lambda{|a| a.count},
+    :distinct => lambda{|a| a.count(true)},
+    :average => lambda{|a| a.average},
+    :avg => :average,
+    :minimum => lambda{|a| a.minimum},
+    :min => :minimum,
+    :maximum => lambda{|a| a.maximum},
+    :max => :maximum,
+    :sum => lambda{|a| a.sum}
+  }
+
+  # Given an object, tries to coerce it into a proc that takes a node
+  # and returns an expression node to collect some aggregate data from it.
+  def self.aggregation_proc(obj)
+    if obj.is_a?(Symbol)
+      orig_name = obj
+      2.times do
+        # Lookup twice to allow for indirect aliases in AGGREGATION_FUNCS
+        obj = AGGREGATION_FUNCS[obj] if obj.is_a?(Symbol)
+      end
+      raise ModelSetupError.new "Can't find aggregation function #{orig_name}" unless obj
+      obj
+    elsif obj.is_a?(Proc)
+      obj
+    else
+      raise ModelSetupError.new "Invalid aggregation function #{obj.inspect}"
+    end
+  end
+
+  # Given an object, tries to coerce it into a proc that takes a relation
+  # and returns a node for some value in it to be aggregated over
+  def self.value_proc(obj)
+    if obj.is_a?(Symbol)
+      lambda {|t| t[obj]}
+    elsif obj.is_a?(Proc)
+      obj
+    else
+      raise ModelSetupError.new "Invalid value function #{obj.inspect}"
+    end
+  end
+
+  def self.split_out_aggregation_procs(obj)
+    case obj
+    when Symbol, String
+      vals = obj.to_s.split(/[ _]/).map(&:downcase).map(&:to_sym)
+    when Array
+      vals = obj.dup
+    else
+      raise ModelSetupError.new "Invalid aggregation type: #{obj.inspect}"
+    end
+
+    if vals.size == 1
+      vals << :id # TODO : Use real primary key
+    elsif vals.size != 2
+      raise ModelSetupError.new "Wrong # of components for agg: #{obj.inspect}"
+    end
+
+    {
+      :agg_proc => aggregation_proc(vals.first),
+      :value_proc => value_proc(vals.last)
+    }
+  end
 end