gitter 1.1.3

data/lib/gitter/facet.rb

@@ -0,0 +1,95 @@
+require 'gitter/utils'
+
+module Gitter
+
+  class FacetData
+    include Utils
+
+    attr_reader :facet, :raw_value, :count
+    delegate :grid, :name, to: :facet
+    delegate :h, to: :grid
+
+    def initialize facet, raw_value, label, count 
+      @facet, @raw_value, @label, @count = facet, raw_value, label, count 
+    end
+
+    def value
+      @value ||= facet.format raw_value
+    end
+
+    def params
+      @params ||= grid.scoped_params name => raw_value
+    end
+
+    def selected?
+      @selected ||= facet.selected_value == raw_value.to_s
+    end
+
+    def label
+      #@label || grid.translate(:facets, raw_value) || '-'
+      @label || raw_value || '-'
+    end
+
+    def link
+      @link ||= begin
+        p = grid.params.dup 
+        p.delete name
+        p[name] = raw_value if raw_value.present?
+        p = grid.scoped_params p
+        p[:page] = 1
+
+        value_class = selected? ? 'facet_value_selected' : 'selected' 
+        value_tag = h.content_tag :span, label, class: value_class
+        value_tag = h.link_to value_tag, url_for(p)
+
+        if selected? or not facet.selected?
+          count_tag = h.content_tag :span, "(#{count})", class: 'facet_count'
+          #count_tag = h.link_to count_tag,  url_for(p.merge(show: true))
+        else
+          count_tag = ''
+        end
+
+        h.content_tag :span, (value_tag + count_tag), {class: 'facet_entry'}, false
+      end
+    end
+
+    def to_s
+      "#{name}:#{value}(#{raw_value})=#{count}"
+    end
+
+  end
+
+  class Facet
+    attr_reader :filter
+    delegate :grid, :name, :selected_value, :selected?, :format, to: :filter
+
+    def initialize filter
+      @filter = filter
+    end
+
+    def label
+      filter.label || grid.translate(:facets, name)
+    end
+
+    def params_for_any
+      grid.scoped_params grid.params.reject{|k,v| k == name}
+    end
+
+    def selected_data opts = {}
+      data(opts).detect{|d|d.selected?}
+    end
+
+    def data opts = {}
+      values_to_counts = filter.counts
+      values = opts[:include_zeros] ? filter.distinct_values(grid.driver) : values_to_counts.keys
+      values.map do |value,label|
+        FacetData.new self, value, label, (values_to_counts[value]||0)
+      end
+    end
+
+    def to_s
+      "#{self.class}(#{name},label=#{label})"
+    end
+  end
+
+end

data/lib/gitter/filters.rb

@@ -0,0 +1,4 @@
+require 'gitter/filters/abstract_filter'
+require 'gitter/filters/block_filter'
+require 'gitter/filters/select_filter'
+require 'gitter/filters/column_filter'

data/lib/gitter/filters/abstract_filter.rb

@@ -0,0 +1,94 @@
+  class AbstractFilter
+
+    attr_reader :grid, :name, :input_options, :input_tag, :formatter, :order, :label
+
+    def initialize grid, name, opts = {}
+       @grid, @name = grid, name
+       @label = opts.delete(:label){grid.translate(:filters, name)}
+       @input_options = opts.delete(:input){nil}
+       @input_tag = opts.delete(:input_tag){nil}
+       @include_blank = opts.delete(:include_blank){false}
+       
+       @formatter = opts.delete(:formatter){nil}
+       @param_scoped = opts.delete(:param_scoped){true}
+       @order = opts.delete(:order){nil}
+
+       # replace shortcut
+       if coll = opts.delete(:input_collection){nil}
+         (@input_options||={})[:collection] = coll
+       end
+       @opts = opts
+    end
+
+    def input?
+      @input_options || @input_tag
+    end
+
+    def include_blank?
+      @include_blank
+    end
+
+    def param_scoped?
+      @param_scoped
+    end
+
+    def selected_value
+      @selected_value ||= grid.filter_value name
+    end
+
+    def selected?
+      selected_value.present?
+    end
+
+    def counts driver = grid.filtered_driver
+      { true => apply(driver.unordered).count }
+    end
+
+    def distinct_values driver = nil
+      [ true, false ]
+    end
+
+    def input_tag
+      return '' unless input?
+
+      @input_tag ||= if col = collection
+        col = [''] + col if include_blank? && col.size > 1
+        select_tag col
+      else
+        text_field_tag
+      end
+    end
+
+    def text_field_tag
+      @text_field_tag ||= h.text_field_tag scoped_name, grid.params[name.intern], :class => 'grid'
+    end
+
+    def select_tag collection 
+      h.select_tag scoped_name, h.options_for_select(collection, grid.params[name.intern]), :class => 'grid'
+    end
+
+    def format value
+      case formatter
+      when Hash then formatter[value]
+      when Proc then formatter.call value
+      else value;
+      end
+    end
+
+    private
+    def scoped_name
+      "#{grid.key}[#{name}]"
+    end
+
+    def collection
+      input_options.respond_to?(:[]) && input_options[:collection]
+    end
+
+    def h
+      @h ||= grid.h
+    end
+
+    def sort_hash hash
+      hash.keys.sort.inject({}){|memo,k|memo[k] = hash[k]; memo}
+    end
+end

data/lib/gitter/filters/block_filter.rb

@@ -0,0 +1,16 @@
+module Gitter
+
+  class BlockFilter < AbstractFilter
+
+     def initialize grid, name, options ={}, &block
+       raise ArgumentError, "no block given" unless block
+       @block = block
+       super grid, name, options
+     end
+
+     def apply driver, value = nil 
+       driver.new @block.call(driver.scope, value)
+     end
+     
+  end
+end

data/lib/gitter/filters/column_filter.rb

@@ -0,0 +1,50 @@
+module Gitter
+
+  class ColumnFilter < AbstractFilter
+
+    attr_reader :columns, :values
+
+    def initialize grid, name, opts = {}
+      @columns = [opts[:column]||opts[:columns]||name].flatten
+      @values = opts[:values]
+      super
+    end
+
+    def apply driver, value = nil
+      return driver if value.blank?
+
+      attr_values = columns.inject({}){|memo,column| memo[column] = value; memo}
+      driver.where attr_values, @opts
+    end
+
+    def counts driver = grid.filtered_driver
+      if columns.size == 1
+	#sort_hash ordered(driver).group(columns.first).count
+	sort_hash driver.unordered.group(columns.first).count
+      else
+        super
+      end
+    end
+
+    def distinct_values driver = grid.filtered_driver
+      if columns.size == 1
+        values || driver.unordered.distinct_values(columns.first).sort
+      else
+        super
+      end
+    end
+
+    private
+    def ordered driver
+      order_attr = case order
+          when true then columns.first
+	  when String, Symbol then order
+	  else nil;
+          end
+      s = driver.unordered
+      s = s.order(order_attr) if order_attr
+      s
+    end
+  end
+
+end 

data/lib/gitter/filters/select_filter.rb

@@ -0,0 +1,43 @@
+module Gitter
+
+  class SelectFilter < AbstractFilter
+
+    attr_reader :filters, :values
+
+    def initialize grid, name, filters, opts = {} 
+      super grid, name, opts
+      @filters = filters.inject({}){|memo,filter| memo[filter.name] = filter; memo}
+      @values = opts[:values]
+      if @input_options == true
+        @input_options = {}
+        @input_options[:collection] = @filters.keys
+      end
+    end
+
+    def apply driver, value 
+      if filter = @filters[value]
+        filter.apply driver
+      else
+        driver
+      end
+    end
+
+    def counts driver = nil
+      values_names = Hash === values ? values.keys : values
+      @filters.values.inject({}) do |memo,filter|
+        if !values_names || values_names.include?(filter.name)
+          count = filter.counts[true]
+          memo[filter.name] = count if count > 0
+        end
+        memo
+      end
+    end
+
+    # returns map { :name => label }
+    def distinct_values driver = nil
+      @distinct_values ||= values || @filters.values.inject({}){|memo, filter| memo[filter.name] = filter.label; memo }
+    end
+
+  end
+
+end

data/lib/gitter/grid.rb

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

data/lib/gitter/header.rb

@@ -0,0 +1,44 @@
+module Gitter
+
+  class Header
+    def self.blank
+      new :blank, false
+    end
+
+    attr_reader :grid, :content, :html_options, :column
+
+    def initialize grid, *args
+      opts = args.extract_options!
+      raise ArgumentError, 'too many arguments' if args.size > 1
+      @grid = grid
+      @content = args.first
+      @column = opts.delete(:column){nil}
+      @html_options = opts
+    end
+
+    def label
+      @label ||= case content
+	when false then ''
+	when Symbol then grid.translate(:headers, name)
+        else content
+      end
+    end
+
+    def link *args
+      if column
+        column.link label, *args
+      else
+	label
+      end
+    end
+
+    def name
+      @name ||= Symbol === content ? content : 'n/a'
+    end
+
+    def to_s
+      "Header(#{name},html_options=#{html_options},#{column ? ',col':''},label=#{label})"
+    end
+  end
+
+end

data/lib/gitter/helpers.rb

@@ -0,0 +1,44 @@
+module Gitter
+  module Helpers
+
+    def name
+      @name ||= self.class.name.underscore
+    end
+
+    # used to scope params of requests 
+    def key
+      @key ||= :grid#name.intern
+    end
+
+    def scoped_params params
+      { key => params }
+    end
+
+    def mark *keys
+      { mark: keys.map{|k|filter_value k}.select{|v|v.present?} }
+    end
+
+    def highlight text, *keys
+      h.highlight "#{text}", mark(*keys)[:mark] 
+    end
+
+    def h
+      @decorator.h
+    end
+
+    def decorate *args
+      @decorator.decorate
+    end
+
+    def input_tags
+      @input_tags ||= begin
+        res = {}
+        filters.each do |filter|
+          res[filter.name] = filter.input_tag if filter.input?
+        end
+        res
+      end
+    end
+
+  end
+end

data/lib/gitter/i18n.rb

@@ -0,0 +1,11 @@
+require 'i18n'
+
+module Gitter
+  module I18n
+
+   def translate prefix, key
+     ::I18n.translate "gitter.#{name}.#{prefix}.#{key}", default: key.to_s.humanize
+   end
+ 
+  end
+end

data/lib/gitter/model.rb

@@ -0,0 +1,40 @@
+module Gitter
+  module Model
+
+    def self.included base
+      base.send :attr_reader, :model
+    end
+
+    # evaluate data (string or proc) in context of grid
+    def eval data, model = nil
+      instance_variable_set :"@model", model
+      attributes.each do |name,block|
+        instance_variable_set :"@#{name}", instance_eval(&block)
+      end
+
+      res = instance_eval &data
+
+      remove_instance_variable :"@model"
+      attributes.each do |name,block|
+        remove_instance_variable :"@#{name}"
+      end
+
+      res
+    end
+
+    def decorate *args
+      @decorator.decorate *args
+    end
+
+    def attribute name, &block
+      self.class.send :attr_reader, name
+      attributes[name] = block or raise ArgumentError, "missing block for model #{model}"
+    end
+
+    private
+    def attributes
+      @attributes||={}
+    end
+
+  end
+end