pivotable 0.0.2 → 0.0.3

data/lib/pivotable/expression/abstract.rb

@@ -0,0 +1,33 @@
+class Pivotable::Expression::Abstract
+  attr_reader :name, :model, :via
+
+  def initialize(model, name, options = {})
+    @name  = name.to_s
+    @model = model
+    @via   = process_via options[:via]
+
+    raise ArgumentError, "Could not find DB attribute for '#{@name}', please specify a :via option" if via.blank?
+  end
+
+  def to_select
+    not_implemented
+  end
+
+  def to_group
+    not_implemented
+  end
+
+  protected
+
+    def process_via(value)
+      case value
+      when String # Pure SQL string
+        value
+      when Symbol
+        model.arel_table[value]
+      else
+        model.arel_table[name.to_sym]
+      end
+    end
+
+end

data/lib/pivotable/expression/calculation.rb

@@ -0,0 +1,39 @@
+class Pivotable::Expression::Calculation < Pivotable::Expression::Abstract
+
+  attr_reader :function
+
+  def initialize(model, name, options = {})
+    super
+    @function = options[:function] if options[:function].is_a?(Symbol)
+
+    if via.is_a?(Arel::Attribute)
+      raise ArgumentError, "No calculation function provided for '#{@name}'. Please provide a :function option" unless function
+      @via = via.send(function)
+    end
+  end
+
+  def to_select
+    case via
+    when String
+      "#{via} AS #{model.connection.quote(name)}"
+    else
+      via.clone.as(model.connection.quote(name))
+    end
+  end
+
+  def to_group
+    raise RuntimeError, "Cannot group by calculation"
+  end
+
+  protected
+
+    def process_via(value)
+      case value
+      when Arel::Expression
+        value
+      else
+        super
+      end
+    end
+
+end

data/lib/pivotable/expression/generic.rb

@@ -0,0 +1,29 @@
+class Pivotable::Expression::Generic < Pivotable::Expression::Abstract
+
+  def to_select
+    case via
+    when String
+      "#{via} AS #{model.connection.quote(name)}"
+    else
+      via.as(name.to_sym)
+    end
+  end
+
+  def to_group
+    via.clone
+  end
+
+  protected
+
+    def process_via(value)
+      case value
+      when Symbol
+        model.arel_table[value]
+      when Arel::Attribute
+        value
+      else
+        super
+      end
+    end
+
+end

data/lib/pivotable/expression.rb

@@ -0,0 +1,5 @@
+module Pivotable::Expression
+  autoload :Abstract, "pivotable/expression/abstract"
+  autoload :Generic, "pivotable/expression/generic"
+  autoload :Calculation, "pivotable/expression/calculation"
+end

data/lib/pivotable/model.rb

@@ -2,11 +2,6 @@
 module Pivotable::Model
   extend ActiveSupport::Concern
 
-  included do
-    class_attribute :_pivotable
-    self._pivotable = {}
-  end
-
   module ClassMethods
 
     # Pivotable definition for a model. Example:
@@ -14,35 +9,33 @@ module Pivotable::Model
     #   class Stat < ActiveRecord::Base
     #
     #     # Add your rotations
-    #     pivotable do
-    #
-    #       rotation :overall do
-    #         sum :visits
-    #       end
-    #
-    #       # Rotations can in herit parent definitions
-    #       rotation :by_day => :overall do
-    #         by :day
-    #       end
-    #
+    #     pivotable :overall do
+    #       sum :visits
     #     end
     #
-    #     # Add your custom rotations, e.g. for admins
-    #     pivotable :admin do
+    #     # Rotations can in herit parent definitions
+    #     pivotable :daily => :overall do
+    #       by :day
+    #     end
     #
-    #       rotation :overall do
-    #         sum :visits
-    #         maximum :bounce_rate
-    #       end
+    #     # Add "namespaced" rotations, e.g. for admins
+    #     pivotable "admin:daily" => :daily do
+    #       maximum :bounce_rate
+    #     end
     #
+    #     # Can be expressed as
+    #     pivotable :admin, :extended => [:admin, :daily] do
+    #       sum :bot_impressions
     #     end
     #
     #   end
     #
-    def pivotable(name = nil, &block)
-      name = name.present? ? name.to_sym : :_default
-      _pivotable[name] ||= Pivotable::Collection.new(self)
-      _pivotable[name.to_sym].instance_eval(&block) if block
+    def pivotable(*tokens, &block)
+      name, parent = tokens.extract_options!.to_a.first
+      name, parent = Pivotable.name(tokens, name), Pivotable.name(parent)
+      raise ArgmentError, "A name must be provided" unless name
+
+      _pivotable[name] = Pivotable::Rotation.new(self, name, parent, &block) if block
       _pivotable[name]
     end
 
@@ -51,5 +44,9 @@ module Pivotable::Model
       scoped.pivot(*args)
     end
 
+    def _pivotable
+      @_pivotable ||= {}
+    end
+
   end
 end

data/lib/pivotable/pivoting.rb

@@ -7,13 +7,14 @@ module Pivotable::Pivoting
   #   # Use custom (e.g. admin) rotation
   #   Stat.pivot(:admin, :by_day)
   #
+  #   # Same as
+  #   Stat.pivot("admin:by_day")
+  #
   #   # Combine it with relations & scopes
   #   Stat.latest.order('some_column').pivot(:by_day).paginate :page => 1
   #
-  def pivot(*args)
-    rotation = args.pop
-    scope    = args.first.is_a?(Symbol) ? args.shift : nil
-    klass.pivotable(scope)[rotation].merge(self)
+  def pivot(*parts)
+    klass.pivotable(*parts).merge(self)
   end
 
 end

data/lib/pivotable/rotation.rb

@@ -1,51 +1,101 @@
 class Pivotable::Rotation
 
-  attr_reader :collection, :name, :parent, :block, :selects, :groups, :joins, :loaded
-  delegate    :model, :to => :collection
+  attr_reader :model, :name, :parent, :block, :selects, :groups, :joins, :loaded
   alias       :loaded? :loaded
 
-  def initialize(collection, name, parent = nil, &block)
-    @collection = collection
-    @name       = name.to_sym
-    @parent     = parent.to_sym if parent
-    @selects    = []
-    @groups     = []
-    @joins      = []
-    @block      = block
-    @loaded     = false
-  end
-
-  def sum(*cols)
-    calculate :sum, *cols
+  def initialize(model, name, parent = nil, &block)
+    @model   = model
+    @name    = name
+    @parent  = parent
+    @selects = []
+    @groups  = []
+    @joins   = []
+    @block   = block
+    @loaded  = false
   end
 
+  # Calculate minimum. Calls #calculate with :via => :minimum.
+  # See #calulate for examples.
   def minimum(*cols)
-    calculate :minimum, *cols
+    opts = cols.extract_options!.update :function => :minimum
+    calculate *(cols << opts)
   end
 
+  # Calculate maximum. Calls #calculate with :via => :maximum.
+  # See #calulate for examples.
   def maximum(*cols)
-    calculate :maximum, *cols
+    opts = cols.extract_options!.update :function => :maximum
+    calculate *(cols << opts)
   end
 
+  # Calculate sum. Calls #calculate with :via => :sum.
+  # See #calulate for examples.
+  def sum(*cols)
+    opts = cols.extract_options!.update :function => :sum
+    calculate *(cols << opts)
+  end
+
+  # Calculate sum. Calls #calculate with :via => :average.
+  # See #calulate for examples.
   def average(*cols)
-    calculate :average, *cols
+    opts = cols.extract_options!.update :function => :average
+    calculate *(cols << opts)
   end
 
-  def by(*cols)
-    cols = columns(*cols)
-    @selects += cols
-    @groups  += cols
+  # Calculate value. Examples:
+  #
+  #   # Simple function
+  #   calculate :views, :function => :sum
+  #   # => SELECT SUM(table.views) AS views FROM table
+  #
+  #   # Use a special column
+  #   calculate :page_views, :via => :views, :function => :sum
+  #   # => SELECT SUM(table.views) AS page_views FROM table
+  #
+  #   # Use a custom SQL
+  #   calculate :page_views, :via => "SUM(table.views)"
+  #   # => SELECT SUM(table.views) AS page_views FROM table
+  #
+  #   # Use an AREL expressions
+  #   calculate :page_views, :via => Model.arel_table[:views].sum
+  #   # => SELECT SUM(table.views) AS page_views FROM table
+  #
+  def calculate(*cols)
+    opts = cols.extract_options!
+    cols.each do |col|
+      @selects << Pivotable::Expression::Calculation.new(model, col, opts)
+    end
   end
 
-  def calculate(function, *cols)
-    columns(*cols).each do |col|
-      col.calculate!(function)
-      @selects << col
+  # Group by a column. Examples:
+  #
+  #   # Simple function
+  #   by :page_id
+  #   # => SELECT table.page_id FROM table GROUP BY page_id
+  #
+  #   # Use a special column
+  #   by :pageid, :via => page_id
+  #   # => SELECT table.page_id AS pageid FROM table GROUP BY page_id
+  #
+  #   # Use a custom SQL
+  #   by :page_id, :via => "page_id * 2"
+  #   # => SELECT page_id * 2 AS page_id FROM table GROUP BY page_id * 2
+  #
+  #   # Use an AREL attributes
+  #   by :pageid, :via => Model.arel_table[:page_id]
+  #   # => SELECT table.page_id AS pageid FROM table GROUP BY page_id
+  #
+  def by(*cols)
+    opts = cols.extract_options!
+    cols.each do |col|
+      expr = Pivotable::Expression::Generic.new(model, col, opts)
+      @selects << expr
+      @groups  << expr
     end
   end
 
-  def joins(*names)
-    @joins += names
+  def joins(*args)
+    @joins += args
   end
 
   def merge(relation)
@@ -66,21 +116,12 @@ class Pivotable::Rotation
     relation
   end
 
-  private
+  def load!
+    return if loaded?
 
-    def load!
-      return if loaded?
-
-      instance_eval &collection[parent].block if parent
-      instance_eval &block
-      @loaded = true
-    end
-
-    def columns(*cols)
-      opts = cols.extract_options!
-      cols.map do |col|
-        Pivotable::Column.new(model, col, opts)
-      end
-    end
+    instance_eval &model.pivotable(parent).block if parent
+    instance_eval &block
+    @loaded = true
+  end
 
 end

data/lib/pivotable.rb

@@ -1,13 +1,19 @@
 require "active_support/core_ext"
 require "active_record"
 require "active_record/relation"
+require "abstract"
 
 module Pivotable
   autoload :Model,      "pivotable/model"
   autoload :Pivoting,   "pivotable/pivoting"
   autoload :Rotation,   "pivotable/rotation"
-  autoload :Column,     "pivotable/column"
-  autoload :Collection, "pivotable/collection"
+  autoload :Expression, "pivotable/expression"
+
+  def self.name(*tokens)
+    result = tokens.flatten.map {|i| i.to_s.strip }.reject(&:blank?).join(':')
+    result unless result.blank?
+  end
+
 end
 
 ActiveRecord::Base.class_eval do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: pivotable
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Dimitrij Denissenko
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-05 00:00:00 +01:00
+date: 2011-07-21 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -75,8 +75,10 @@ extra_rdoc_files: []
 files: 
 - README.markdown
 - lib/pivotable/pivoting.rb
-- lib/pivotable/column.rb
-- lib/pivotable/collection.rb
+- lib/pivotable/expression/generic.rb
+- lib/pivotable/expression/calculation.rb
+- lib/pivotable/expression/abstract.rb
+- lib/pivotable/expression.rb
 - lib/pivotable/rotation.rb
 - lib/pivotable/model.rb
 - lib/pivotable.rb

data/lib/pivotable/collection.rb

@@ -1,17 +0,0 @@
-class Pivotable::Collection < Hash
-
-  attr_reader :model
-
-  def initialize(model)
-    @model = model
-    super()
-  end
-
-  # Adds a new rotation to this collection
-  def rotation(name, &block)
-    name, parent = name.is_a?(Hash) ? name.to_a.first : [name, nil]
-    item = Pivotable::Rotation.new(self, name, parent, &block)
-    self[item.name] = item
-  end
-
-end

data/lib/pivotable/column.rb

@@ -1,35 +0,0 @@
-class Pivotable::Column
-
-  attr_reader :attribute
-
-  def initialize(model, attribute, options = {})
-    @as        = options[:as]
-    @attribute = case attribute
-    when Arel::Attribute
-      attribute
-    else
-      model.arel_table[attribute]
-    end
-    raise ArgumentError, "Invalid attribute #{attribute.inspect}" unless @attribute
-  end
-
-  def name
-    @as || attribute.name
-  end
-
-  def calculate!(function)
-    @as     ||= attribute.name
-    @function = attribute.send(function)
-  end
-
-  def to_select
-    select = (@function || attribute).clone
-    select.as(@as.to_s) if @as
-    select
-  end
-
-  def to_group
-    attribute.clone
-  end
-
-end