gitter 1.1.3

data/lib/gitter/pivot.rb

@@ -0,0 +1,107 @@
+module Gitter
+  
+  module Pivot
+
+    def pivot_cells *groups
+      opts = groups.extract_options!
+      sum = opts[:sum]
+      count = opts[:count]; count = :id if count == true
+
+      groups = [groups].flatten
+
+      cells = self.scope
+      groups.each{ |g| cells = cells.group(g)}
+      cells = cells.sum(sum) if sum
+      cells = cells.count(:id) if count
+      cells
+    end
+
+    def x_axis *args
+      if args.present?
+        @x_axis = Axis.new self, *args 
+      else
+        @x_axis or raise ConfigurationError, 'undefined x_axis'
+      end
+    end 
+
+    def y_axis *args
+      if args.present?
+        @y_axis = Axis.new self, *args 
+      else
+        @y_axis or raise ConfigurationError, 'undefined y_axis'
+      end
+    end 
+
+    def cell &cell 
+      if cell
+        @cell ||= cell
+      else
+        @cell or raise ConfigurationError, 'undefined cell'
+      end
+    end
+  
+    def drill_down *names
+      if names.present?
+        @drill_down ||= facet_for names
+      else
+        @drill_down ||= @filters.keys
+      end
+    end
+
+    def input_tags
+      []
+    end
+  
+    def columns
+      @columns ||= x_axis.titles.map{|x|Column.new self, x} 
+    end
+
+    def header_rows
+      @header_rows ||= begin
+        row = [''] + x_axis.titles
+        row = row.map{|h|Gitter::Header.new self, h}
+        [row]
+      end
+    end
+  
+    def rows scope = self.scope
+      y_axis.data_titles.map do |y,y_title|
+        row = []
+        row << Gitter::Cell.new(y_title)
+        row += x_axis.data.map do |x|
+          content = cell.call data_scope, x, y
+          Gitter::Cell.new content
+        end
+      end
+    end
+
+    # returns [ down, current, ups ]
+    def drill_down_facets
+      drill = drill_down.reverse
+      i = drill.find_index{|f|f.selected?}
+      if i == 0
+        down = nil
+	current, *ups = drill[0..-1]
+      else
+        down, current, *ups = drill[i-1..-1]
+      end
+
+      [ down, current, ups ]
+    end
+
+    private
+    def data_scope
+      @data_scope ||= scope.group(x_axis.attr).group(y_axis.attr)
+    end
+
+    def facet_for arg
+      if arg.respond_to? :map
+         arg.map{|a|facet_for a}
+      else
+        filter = @filters[arg] or raise ConfigurationError, "unknown filter #{arg}"
+	Facet.new filter
+      end
+    end
+
+  end
+end

data/lib/gitter/pivot_grid.rb

@@ -0,0 +1,23 @@
+require 'gitter/driver'
+require 'gitter/base'
+require 'gitter/pivot'
+require 'gitter/breadcrumbs'
+require 'gitter/csv'
+require 'gitter/i18n'
+require 'gitter/helpers'
+require 'gitter/model'
+
+module Gitter
+
+  class PivotGrid
+    include Gitter::Base
+    include Gitter::Driver
+    include Gitter::Pivot
+    include Gitter::Breadcrumbs
+    include Gitter::CSV
+    include Gitter::I18n
+    include Gitter::Helpers
+    include Gitter::Model
+  end
+
+end

data/lib/gitter/railtie.rb

@@ -0,0 +1,8 @@
+module Gitter
+
+  class Railtie < Rails::Railtie
+    config.after_initialize do 
+      #ApplicationController.send :include, Gitter::Controller
+    end
+  end
+end

data/lib/gitter/table.rb

@@ -0,0 +1,149 @@
+require 'action_view'
+
+module Gitter
+
+  class TableCell 
+    include ActionView::Helpers::NumberHelper
+
+
+    attr_reader :x, :y, :content
+
+    def initialize x, y, content
+      @x, @y, @content = x, y, content
+    end
+
+    def html opts = {}
+      Table.tag :td, formatted_content, opts.merge(class: "#{x} #{y}")
+    end
+
+    def header?
+      false
+    end
+
+    def formatted_content
+      number_with_delimiter content, delimiter: '.'
+    end
+  end
+
+  class TableHeaderCell < TableCell
+    attr_reader :content
+
+    def initialize content
+      @content = content
+    end
+
+    def html opts = {}
+      Table.tag :th, formatted_content, opts
+    end
+
+    def header?
+      true
+    end
+
+    def formatted_content
+      content
+    end
+
+  end
+
+  class Table
+    extend ActionView::Helpers::TagHelper
+    extend ActionView::Helpers::OutputSafetyHelper
+ 
+    def self.tag tag, content, opts = {}
+      opts = opts.merge(class: "#{opts[:class]} grid pivot")
+      content_tag tag, raw(content), opts
+    end
+
+    attr_reader :title, :x_axis, :y_axis, :data, :opts
+
+    # axis: responds to each, yielding [key,title] or key 
+    #   # data: hash from [x_key,y_key] to cell_array 
+    def initialize title, x_axis, y_axis, data, opts = {}
+      @title, @x_axis, @y_axis, @data, @opts = title, x_axis, y_axis, data, opts
+      @cells = data.dup
+      if label = opts[:show_sums]
+        add_sums
+        @x_axis = add_sum_label_to_axis @x_axis, label
+        @y_axis = add_sum_label_to_axis @y_axis, label
+      end
+    end
+
+    def empty?
+      data.empty?
+    end
+
+    def rows
+      @rows ||= begin
+        rows = []
+        rows << x_header if x_header
+
+        rows + (y_axis||[nil]).map do |y,y_title|
+           row = (x_axis||[nil]).map do |x,x_title|
+             cell = @cells[cell_key(x,y)]
+             cell = yield cell, x, y if block_given?
+             TableCell.new x, y, cell
+	   end
+           row.unshift TableHeaderCell.new(y_title||y) if y_axis
+	   row
+        end
+      end 
+    end
+
+    def html
+      @html ||= begin
+        h = rows.map do |row|
+          Table.tag :tr, (row.map{|cell| cell.html} * "\n")
+        end * "\n"
+	Table.tag :table, h
+      end
+    end
+
+    private
+
+    def x_header
+      @x_header ||= begin 
+        if x_axis
+          h = x_axis.map{|key,title| TableHeaderCell.new(title||key) }
+          h.unshift TableHeaderCell.new('') if y_axis
+          h
+        else
+          nil 
+        end
+      end
+    end
+
+    def cell_key x, y
+      if x.nil? || y.nil?
+        x.nil? ? y : x
+      else
+        [x,y]
+      end
+    end
+
+    def add_sums
+      xsums, ysums = {}, {}
+      sum = 0
+      @cells.each do |key,value|
+        x, y = *key
+        xsums[y] = (xsums[y]||0) + value
+        ysums[x] = (ysums[x]||0) + value
+        sum += value
+      end
+      xsums.each{|y,sum| @cells[cell_key(:sum,y)] = sum}
+      ysums.each{|x,sum| @cells[cell_key(x,:sum)] = sum}
+      @cells[[:sum,:sum]] = sum
+      @cells
+    end
+
+    def add_sum_label_to_axis axis, label = nil
+      label = 'Sum' unless String === label
+      case axis
+      when Array then axis + [[:sum, label]]
+      when Hash  then axis.merge(:sum => label)
+      else nil;
+      end
+    end
+
+  end
+end

data/lib/gitter/utils.rb

@@ -0,0 +1,12 @@
+module Gitter
+  
+  module Utils
+    # dirty hack to avoid rails' sorted query in url
+    def url_for params
+      p = params.dup
+      query = p.map{|key, value| value.to_query(key) } * '&'
+      "#{h.url_for({})}?#{query}"
+    end
+  end
+
+end

data/lib/gitter/version.rb

@@ -0,0 +1,3 @@
+module Gitter
+  VERSION = "1.1.3"
+end

data/spec/breadcrumbs_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+include Gitter
+
+describe Grid do
+
+  it 'should handle one breadcrumb' do
+    g = PersonGrid.new :name => 'bla'
+    g.breadcrumbs.should == { 'Name' => 'bla' }
+  end
+
+  it 'should handle breadcrumb with label' do
+    g = PersonGrid.new :name3 => 'bla'
+    g.breadcrumbs.should == { 'Three' => 'bla' }
+  end
+
+  it 'should handle many breadcrumbs' do
+    g = PersonGrid.new :name => 'Mike', :surname => 'Miller'
+    g.breadcrumbs.should == { 'Name' => 'Mike', 'Surname' => 'Miller' }
+
+    g = PersonGrid.new :surname => 'Miller', :name => 'Mike'
+    g.breadcrumbs.should == { 'Surname' => 'Miller', 'Name' => 'Mike' }
+  end
+end

data/spec/column_filter_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+include Persons
+
+describe Gitter do
+
+  context 'column filter' do 
+    check_include Max,          :name => 'Max'
+    check_include Lisa,         :surname => 'Adult' 
+    check_include John, Dana,   :surname => 'Twen' 
+  end
+
+  context 'column filter with :column' do 
+    check_include Max,          :name2 => 'Max'
+  end
+
+  context 'column filter with instance ignore_case' do 
+    check_include [],          :name => 'max'
+    check_include [],          :name => 'max', :ignore_case => false
+    check_include Max,         :name => 'max', :ignore_case => true
+  end
+
+  context 'column filter with instance inexact' do 
+    check_include [],          :name => 'ax'
+    check_include [],          :name => 'ax', :exact => true
+    check_include Max,         :name => 'ax', :exact => false
+  end
+
+  context 'column filter with many columns' do 
+    check_include Max,          :any_name => 'Max'
+    check_include Max,          :any_name => 'Kid'
+  end
+
+  context 'column filter with many columns with ignore_case' do 
+    check_include [],           :any_name => 'max'
+    check_include [],           :any_name => 'ax', :exact => true
+    check_include Max,          :any_name => 'ax', :exact => false
+    check_include [],           :any_name => 'id'
+    check_include [],           :any_name => 'id', :exact => true
+    check_include Max,          :any_name => 'id', :exact => false
+  end
+
+  context 'column filter with many columns with inexact' do 
+    check_include [],          :any_name => 'max'
+    check_include [],          :any_name => 'max', :ignore_case => false
+    check_include Max,         :any_name => 'max', :ignore_case => true
+    check_include [],          :any_name => 'kid'
+    check_include [],          :any_name => 'kid', :ignore_case => false
+    check_include Max,         :any_name => 'kid', :ignore_case => true
+  end
+
+  context 'column filter with ignore_case' do 
+    check_include Max,         :name_ignore => 'max'
+    check_include Max,         :name_ignore => 'Max'
+
+    check_include [],          :name_ignore => 'max', :ignore_case => false
+    check_include Max,         :name_ignore => 'Max', :ignore_case => false
+
+    check_include Max,         :name_ignore => 'max', :ignore_case => true
+    check_include Max,         :name_ignore => 'Max', :ignore_case => true
+  end
+
+  context 'column filter with instance inexact' do 
+    check_include Max,         :name_inexact => 'ax'
+    check_include Max,         :name_inexact => 'Max'
+
+    check_include [],          :name_inexact => 'ax',  :exact => true
+    check_include Max,         :name_inexact => 'Max', :exact => true
+
+    check_include Max,         :name_inexact => 'ax',  :exact => false
+    check_include Max,         :name_inexact => 'Max', :exact => false
+  end
+
+  context 'search'  do 
+    check_include Max,          :search_name => 'Max'
+    check_include Max,          :search_name => 'max'
+    check_include Max,          :search_name => 'ax'
+    check_include [],           :search_name => 'Kid'
+  end
+end

data/spec/column_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+include Gitter
+
+describe Column do
+  it 'should have name and header' do
+    g = PersonGrid.new
+    col_spec = g.columns.detect_name :name
+    col_spec.name.should == :name
+
+    col= g.columns.detect_name :name
+    col.name.should == :name
+    col.header.should == 'Name'
+  end
+
+  it 'should have settable header' do
+    g = PersonGrid.new
+    col_spec = g.columns.detect_name :full_name
+    col_spec.name.should == :full_name
+     
+    col = g.columns.detect_name :full_name
+    col.name.should == :full_name
+    col.header.should == 'Full name'
+  end
+
+  it 'should have a ColumnSpec' do
+    g = PersonGrid.new
+    col= g.columns.detect_name :name
+    col.spec.class.should == ColumnSpec
+  end
+
+  it 'should have settable attribute' do
+    class Foo < Gitter::Grid
+      scope do Person.scoped end
+      column :name1, :column => :name
+    end   
+    g = Foo.new
+    col_spec = g.columns.detect_name :name1
+    col_spec.name.should == :name1
+     
+    col = g.columns.detect_name :name1
+    col.name.should == :name1
+    col.header.should == 'Name1'
+  end
+
+  it 'should have headers' do
+    g = PersonGrid.new
+    g.headers.should == [ 'Name', 'Full name', 'Job Title' ]
+  end
+
+  it 'should have rows' do
+    g = PersonGrid.new 
+    g.rows.size.should == 7
+
+    g = PersonGrid.new :order => :name
+    g.rows.size.should == 7
+    g.rows.should == [
+       ["Dana", "Dana Twen", "teacher"],
+       ["Dick", "Dick Teeny", "student"],
+       ["Joe", "Joe Teen", "student"],
+       ["John", "John Twen", "teacher"],
+       ["Lisa", "Lisa Adult", "dentist"],
+       ["Max", "Max Kid", "student"],
+       ["Tina", "Tina Child", "student"]
+    ]
+  end
+
+  it 'should order columns' do
+    g = PersonGrid.new :order => :profession
+    g.rows.size.should == 7
+    g.rows.map{|r|r.last}.should == [
+       "dentist",
+       "student",
+       "student",
+       "student",
+       "student",
+       "teacher",
+       "teacher"
+    ]
+  end
+
+  it 'should order columns ascending' do
+    g = PersonGrid.new :order => :profession, :desc => false
+    g.rows.size.should == 7
+    g.rows.map{|r|r.last}.should == [
+       "dentist",
+       "student",
+       "student",
+       "student",
+       "student",
+       "teacher",
+       "teacher"
+    ]
+  end
+
+  it 'should order columns descending' do
+    g = PersonGrid.new :order => :profession, :desc => true
+    g.rows.size.should == 7
+    g.rows.map{|r|r.last}.should == [
+       "teacher",
+       "teacher",
+       "student",
+       "student",
+       "student",
+       "student",
+       "dentist"
+    ]
+  end
+
+  it 'should order columns descending with given descend' do
+    g = PersonGrid.new :order => :profession, :desc => 'profession DESC'
+    g.rows.size.should == 7
+    g.rows.map{|r|r.last}.should == [
+       "teacher",
+       "teacher",
+       "student",
+       "student",
+       "student",
+       "student",
+       "dentist"
+    ]
+  end
+
+  it 'should order complex columns' do
+    g = PersonGrid.new :order => :full_name
+    g.rows.size.should == 7
+    g.rows.should == [
+       ["Dana", "Dana Twen",  "teacher"],
+       ["Dick", "Dick Teeny", "student"],
+       ["Joe",  "Joe Teen",   "student"],
+       ["John", "John Twen",  "teacher"],
+       ["Lisa", "Lisa Adult", "dentist"],
+       ["Max",  "Max Kid",    "student"],
+       ["Tina", "Tina Child", "student"]
+    ]
+  end
+
+  it 'should order complex columns descending' do
+    g = PersonGrid.new :order => :full_name, :desc => true
+    g.rows.size.should == 7
+    g.rows.should == [
+       ["Tina", "Tina Child", "student"],
+       ["Max",  "Max Kid",    "student"],
+       ["Lisa", "Lisa Adult", "dentist"],
+       ["John", "John Twen",  "teacher"],
+       ["Joe",  "Joe Teen",   "student"],
+       ["Dick", "Dick Teeny", "student"],
+       ["Dana", "Dana Twen",  "teacher"]
+    ]
+  end
+
+  it 'should raise error for unknown order column' do
+    expect { 
+      PersonGrid.new :order => :bla 
+    }.to raise_error( 
+      ArgumentError, /order/ 
+    )
+  end
+end