gitter 1.1.3

data/lib/gitter/breadcrumbs.rb

@@ -0,0 +1,44 @@
+require 'active_support/concern'
+  
+module Gitter
+  module Breadcrumbs
+    include Utils
+
+    extend ActiveSupport::Concern
+
+    def breadcrumbs
+      @breadcrumbs ||= begin
+        p = {}
+        text = filters.map do |filter|
+          p[filter.label] = filter_value(filter.name)
+        end
+        p
+      end
+    end
+
+    def render_breadcrumbs delim = '>', params = {}
+      delim_tag = h.content_tag :span, delim, {class: 'breadcrumb_delim'}
+
+      p = {}
+      breadcrumbs = filters.map do |filter|
+        value = filter_value filter.name
+        if value.present?
+          s =  h.content_tag :span, "#{filter.label}:", class: 'breadcrumb_key'
+          s += h.content_tag :span, value,              class: 'breadcrumb_value'            
+          p[filter.name] = value
+          h.link_to s, url_for(scoped_params(p).merge(params))
+        else
+          nil
+        end
+      end.compact
+
+      if breadcrumbs.present? 
+        h.content_tag :span, breadcrumbs.join(delim_tag), {class: 'breadcrumbs'}, false
+      else
+        nil
+      end
+    end
+
+  end
+
+end

data/lib/gitter/cell.rb

@@ -0,0 +1,11 @@
+module Gitter
+
+  class Cell
+
+    attr_reader :content, :html_options
+
+    def initialize content, html_options = {}
+      @content, @html_options = content, html_options
+    end
+  end
+end

data/lib/gitter/column.rb

@@ -0,0 +1,142 @@
+module Gitter
+
+  class Column
+
+    attr_reader :grid, :name, :headers, :attr, :block, :order, :order_desc, :uniq, :map, :html_options
+
+    def initialize grid, name, opts = {}, &block
+      @grid, @name, @block = grid, name, block
+      @attr = opts.delete(:column){name}
+      @order = opts.delete :order
+      @order = attr if @order == true
+      @order_desc = opts.delete :order_desc
+      @uniq = opts.delete :uniq
+      @map = opts.delete(:map){true}
+      @html_options = opts.delete(:html_options){{}}
+      if opts.has_key?(:header) || opts.has_key?(:headers)  # handle :header => false correctly
+         header_opts = opts.delete(:header){opts.delete(:headers)}
+         @headers = [header_opts].flatten.map do |header_opt|
+           case header_opt
+           when Hash
+             content = header_opt.delete(:content)
+             h_opts = header_opt
+           else
+             content = header_opt
+             h_opts = {}
+           end
+           Header.new grid, content, h_opts.merge(:column => self)
+        end
+      else
+        @headers = [Header.new(grid, name, opts.merge(:column => self))]
+      end
+    end
+
+    def cells model
+      res = if map && Array === model
+        model.map{|m| cells m}
+      else
+        cell model
+      end 
+
+      # set consecutively equal cells to nil
+      if uniq && Array === res
+        current = nil 
+        r = res.map do |el|
+          if el != current || current.nil?
+            current = el
+	  else
+            nil
+	  end 
+	end
+	r
+      else
+        res
+      end
+    end
+
+    def ordered
+      d = grid.filtered_driver
+
+      return d unless ordered? 
+
+      desc = case (p = grid.params[:desc])
+        when true, 'true' then order_desc || true
+        when false, 'false' then false 
+        else p 
+      end
+
+      case order
+      when :cell
+        array_sort(d,desc){|model|cell model}
+      when Proc
+        array_sort(d,desc){|model|grid.eval(order,model)}
+      else
+        d.order order, desc
+      end
+    end
+
+    def desc?
+      @desc ||= to_boolean grid.params[:desc]
+    end
+
+    def ordered?
+      @ordered ||= grid.params[:order] == name.to_s
+    end
+
+    def link label = nil, params = {}, options = {}
+      label ||= headers.first.label
+      if @order
+        img = order_img_tag(options)
+        label = grid.h.content_tag :span, img + label if ordered?
+        grid.h.link_to label, order_params.deep_merge(params), options
+      else
+        label
+      end
+    end
+
+    def to_s
+      "Column(#{name},ordered=#{ordered?},#{headers.size} headers)"
+    end
+
+    private
+
+    def order_img_tag opts = {}
+      desc_img = opts.delete(:desc_img){'sort_desc.gif'}
+      asc_img  = opts.delete(:asc_img){'sort_asc.gif'}
+      grid.h.image_tag( desc? ? desc_img : asc_img)
+    end
+
+    def to_boolean s
+      not (s && s.match(/true|t|1$/i)).nil?
+    end
+
+    # if current params contain order for this column then revert direction 
+    # else add order_params for this column to current params
+    def order_params
+      @order_params ||= begin
+        p = grid.params.dup
+        if ordered?
+          p[:desc] = !desc?
+        else
+          p = p.merge order: name, desc: false 
+        end
+        grid.scoped_params p
+      end
+    end
+
+    def cell model
+      grid.decorate model
+      if block
+        content = grid.eval block, model
+      else
+        model.send(attr) || ''
+      end
+    end
+
+    def array_sort driver, desc
+      arr = driver.scope.map{|model| [yield(model),model]}
+      driver.new arr.sort{|a,b| (desc ? -1 : 1)*(a<=>b) }.map{|a|a[1]}
+    end
+  end
+
+end

data/lib/gitter/columns.rb

@@ -0,0 +1,110 @@
+require 'active_support/concern'
+require 'gitter/column'
+require 'gitter/header'
+require 'gitter/cell'
+  
+module Gitter
+  module Columns
+    extend ActiveSupport::Concern
+  
+    included do
+      alias_method_chain :scope, :columns
+    end
+  
+    def header_row
+      @current_header_row = []
+      yield
+      (@header_rows||=[]) << @current_header_row
+    end
+
+    def header *args
+      @current_header_row << Header.new(self,*args)
+    end
+
+    def column name, opts = {}, &block
+      (@columns||= {})[name] = Column.new self, name, opts, &block
+    end
+  
+    def scope_with_columns &scope
+      if scope
+        scope_without_columns &scope
+      else
+        @scope_with_columns ||= order_column ? order_column.ordered.scope : scope_without_columns
+      end
+    end
+ 
+    def paginate *args 
+      scope.paginate *args
+    end
+ 
+    def header_rows
+      @all_header_rows ||= begin
+        rows = @header_rows || []
+        max = columns.map{|col|col.headers.size}.max
+	columns_headers = columns.map{|col| Array.new(max){|i| col.headers[i] || Header.blank }}
+	rows += columns_headers.transpose
+      end
+    end
+ 
+    def rows_for model
+      cols = columns.map{|c| [c.cells(model)].flatten }
+      max = cols.map{|col|col.size}.max
+      cols.map do |col| 
+        nil_padded_cells = Array.new(max){|i| col[i]}
+	cells = []
+	nil_padded_cells.each_with_index do |c,i|
+           unless c.nil?
+             height = consecutive_count(nil_padded_cells.slice(i+1..-1), nil) + 1
+             cells << Cell.new(c, rowspan: height) 
+	   else  # required for transpose
+             cells << nil
+	   end
+	end
+	cells
+      end.transpose
+    end
+ 
+    def rows scope = nil
+      res = []
+      models(scope||self.scope).each{|model| res += rows_for(model)}
+      res
+    end
+
+    def models scope = self.scope
+      if respond_to? :transform
+        transform scope
+      else
+        scope
+      end
+    end
+ 
+    def columns
+      (@columns||={}).values
+    end
+
+    def order_column
+      @order_column ||= begin
+	if order = @params[:order]
+          @columns[:"#{order}"] or raise ArgumentError, "invalid order column #{order}"
+        else
+          raise ArgumentError, ':desc given but no :order' if @params[:desc] 
+          nil
+        end
+      end
+    end
+
+    def consecutive_count arr, what
+      count = 0
+      arr.each do |el|
+        if el == what
+          count +=1 
+	else
+          break
+	end
+      end
+      count
+    end
+
+   end
+ 
+end

data/lib/gitter/controller.rb

@@ -0,0 +1,19 @@
+require 'artdeco'
+
+module Gitter
+  module Controller
+    
+    def self.included base 
+      base.helper_method :render_grid, :decorate
+    end
+
+    def render_grid  grid_class, opts = {}
+      grid_class.new self, opts
+    end
+    
+    def decorate model, *decorator_classes
+      Artdeco::Decorator.new(self).decorate model, *decorator_classes
+    end
+    
+  end
+end

data/lib/gitter/csv.rb

@@ -0,0 +1,9 @@
+module Gitter
+  module CSV
+    
+    def to_csv(separator=',')
+      rows.map{|row|row.join separator}.join("\n")
+    end
+    
+  end
+end

data/lib/gitter/driver.rb

@@ -0,0 +1,26 @@
+module Gitter
+  module Driver
+  
+    def driver_class  driver_class = nil
+      if driver_class
+        @driver_class = driver_class
+      else
+        @driver_class || detect_driver_class or raise ConfigurationError, "no driver given"
+      end
+    end
+
+    def create_driver scope
+      driver_class.new scope
+    end
+
+    private
+    def detect_driver_class
+      case
+      when Module.const_defined?(:ActiveRecord)
+        require 'gitter/drivers/active_record_driver'
+        Gitter::ActiveRecordDriver
+      end
+    end
+
+  end
+end

data/lib/gitter/drivers/abstract_driver.rb

@@ -0,0 +1,36 @@
+module Gitter
+  
+  class AbstractDriver
+    include Enumerable
+    
+    attr_reader :scope
+    
+    def initialize scope
+      @scope = scope
+    end
+
+    # methods to be implemented
+
+    # unordered
+    
+    # order( attr, desc = nil)
+
+    # where( attr_values, opts = {} )
+    # where opts may be :exact, :ignore_case, :strip_blank, :find_format
+
+    # where_greater_or_equal( attr, value )
+
+    # where_less_or_equal( attr, value)
+
+    # each(&block)
+
+    # named_scope( name )
+
+    # distict_values( attr )
+
+    def new(scope)
+      self.class.new scope
+    end
+
+  end
+end

data/lib/gitter/drivers/active_record_driver.rb

@@ -0,0 +1,84 @@
+require 'gitter/drivers/abstract_driver'
+module Gitter
+  
+  class ActiveRecordDriver < AbstractDriver
+    
+    delegate :count, to: :scope
+    
+    def order attr, desc = nil
+      what = case desc
+        when true, 'true' then "#{attr} DESC"
+        when false, 'false' then attr
+        when String then desc
+        else attr 
+      end
+      new scope.except(:order).order(what.to_s)
+    end
+   
+    def unordered
+      new scope.except(:order)
+    end
+
+    def group arg
+      new scope.group(arg)
+    end
+
+    def where attr_values, opts = {}
+      exact = opts.fetch(:exact){true}
+      ignore_case = opts.fetch(:ignore_case){false}
+      find_format = opts.fetch(:find_format){nil}
+      strip_blank = opts.fetch(:strip_blank){false}
+
+      # has range?
+      return new scope.where(attr_values) if Range === attr_values.values.first
+
+      tokens = {}
+      token_i = 0
+
+      conditions = attr_values.map do |attr,value| 
+        raise ArgumentError, "invalid range #{value} for #{attr}" if Range === value
+        value = value.strip if strip_blank
+        text = exact ? value : "%#{value}%"
+        col, token = attr, ":q#{token_i}"
+        col, token = upper(col), upper(token) if ignore_case
+        col = find_format.call(col) if find_format
+        tokens[:"q#{token_i}"] = text 
+        token_i += 1
+        "#{col} #{exact ? '=' : 'LIKE'} #{token}"
+      end
+
+      new scope.where("( #{conditions * ') OR ('} )", tokens)
+    end
+
+    def greater_or_equal attr, value
+      new scope.where("#{attr} >= ?", value)
+    end
+
+    def less_or_equal attr, value
+      new scope.where("#{attr} <= ?", value)
+    end
+
+    def each &block
+      new scope.each(&block)
+    end
+    
+    def named_scope name
+      new scope.send(name)
+    end
+    
+    def distinct_values attr
+      attribute = attr.to_s.split(/\./).last || attr
+      scope.select(attr).uniq.map(&:"#{attribute}").uniq
+    end
+
+    def to_s
+      scope.to_sql
+    end
+
+    private 
+
+    def upper(text)
+      "upper(#{text})"
+    end
+  end
+end