gitter 1.1.3

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+.svn
+pkg/*

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode
+

data/Gemfile

@@ -0,0 +1,14 @@
+source 'http://rubygems.org'
+
+group :development, :test do
+  gem 'rake'
+  gem 'bundler'
+end
+
+group :test do
+  gem 'sqlite3'
+  gem 'rspec'
+  gem 'guard-rspec'
+end
+
+gemspec

data/Guardfile

@@ -0,0 +1,21 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+/)*(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('spec/spec_helper.rb')                        { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+end
+

data/License

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Thomas Sonntag
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task default: [:test]
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/*.rb"
+end

data/Readme.markdown

@@ -0,0 +1,159 @@
+# gitter
+
+Ruby library for Rails which enables you to create
+data grids, i.e table like data with customizable
+
+  * Filters
+  * Sortables columns
+  * Faceted search
+  * Localization
+
+## Data Grids
+
+In order to define a grid you need to provide:
+
+* a scope which returns the objects for the grid's rows
+* filters that will be used to filter the rows
+* columns to be displayed
+
+Example:
+
+```ruby
+class ArticleGrid << Gitter::Grid
+   
+  ### First define the source for your data
+  # helpers are accessible by #h
+  scope do
+    Article.where(:owner => h.current_user)
+  end
+     
+  ### Then you may define filters
+
+  # filter by attribute
+  filter :name
+  
+  # filter by multiple columns: filters by :name OR :description
+  filter :search, :columns => [:name, :description]
+
+  # filter by named scope
+  filter :topsellers, :scope => :topsellers
+
+  # customized filter 
+  filter :on_stock, do |scope|
+    scope.where('stock > 0')
+  end
+
+  filter :out_of_stock do |scope|
+    scope.where(:stock => 0)
+  end
+  
+  # select from given filters
+  filter :availability, :select => [:on_stock, :out_of_stock]
+    
+  # add to facets
+  filter :category, :facet => true              
+  
+  # select among named scopes
+  filter :price_range, :scopes => [:niceprice, :regular] 
+
+  # you can provide 'search' like attributes
+  filter :search, :ignore_case => true, :exact => false
+  
+  # The former can be abbreviated by
+  search :search
+
+  ### Define your data grid
+
+  # show an attribute
+  column :article_no
+  
+  # provide a hardcoded header (i18n support also available)
+  column :description, :header => 'Details'
+
+  # make the column sortable
+  column :name, :sort => true     
+
+  # customize your data cell
+  column :price, :sort => true do
+    "#{price/100.floor},#{price%100} USD"
+  end
+  
+  # helpers are accessible via #h
+  column :details, :header => false do
+    h.link_to 'details', h.edit_article_path(self)
+  end
+  
+end
+```
+
+[More about filters](https://github.com/tracksun/gitter/wiki/Filters)
+
+[More about columns](https://github.com/tracksun/gitter/wiki/Columns)
+
+
+#Rendering your grid
+
+For the most common use case -- your controller -- you simply do:
+
+```ruby
+def index
+  @grid = ArticleGrid.new(self)
+end
+```
+
+Render you grid:
+
+```haml
+%table
+  %tr
+    - @grid.headers.each do |header|
+    %th = header
+
+  - @grid.rows.each do |row|
+    %tr
+      - row.each do |cell|
+      %th = cell 
+```
+[More about grids](https://github.com/tracksun/gitter/wiki/Grids)
+
+# Facets
+
+Render your facets:
+
+```haml
+%ul
+  - @grid.facets do |facet|
+    %li
+      = facet.label
+      %ul
+        - facet.data.each do |data|
+          = data.value
+          = link_to "(#{data.count})", data.link
+
+```
+[More about facets](https://github.com/tracksun/gitter/wiki/Facets)
+
+# Breadcrumbs
+
+Render your breadcrumbs:
+
+```haml
+@grid.render_breadcrumbs
+```
+
+[More about inputs](https://github.com/tracksun/gitter/wiki/Inputs)
+
+
+# ORM Support
+
+* ActiveRecord
+* others: Help or suggestions are welcome
+
+
+# Credits
+
+API inspired by [datagrid](https://github.com/bogdan/datagrid)
+
+# License
+
+Gitter is released under the MIT license

data/gitter.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gitter/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gitter"
+  s.version     = Gitter::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Thomas Sommtag"]
+  s.email       = ["git@sonntagsbox.de"]
+  s.homepage    = "http://github.com/tracksun/gitter"
+  s.summary     = %q{Ruby gem to define searches, facets and data grids for Rails applications}
+  s.description     = <<-EOS
+    To be used within Rails applications.
+    Helps you to define searches with filters and facets 
+    and data tables with sortable columns and filters.
+  EOS
+
+  s.rubyforge_project = "gitter"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w(lib assets) 
+  s.add_dependency 'activesupport', '>=3.2'
+  s.add_dependency 'activerecord', '>=3.2'
+  s.add_dependency 'artdeco',      '>=1.2'
+end

data/lib/gitter.rb

@@ -0,0 +1,13 @@
+module Gitter
+  
+  autoload :Version,     'gitter/version'
+  autoload :Grid,        'gitter/grid'
+  autoload :PivotGrid,   'gitter/pivot_grid'
+  autoload :Helper,      'gitter/helper'
+  autoload :Controller,  'gitter/controller'
+  autoload :Table,       'gitter/table'
+
+  class ConfigurationError < StandardError
+  end
+
+end

data/lib/gitter/axis.rb

@@ -0,0 +1,48 @@
+module Gitter
+
+  class Axis
+
+    attr_reader :grid, :name, :attr
+
+    def initialize grid, name, opts = {}
+      @grid, @name = grid, name
+      @attr = opts.delete(:column){name}
+      only = opts.delete(:only){nil}
+      case only
+      when Hash
+        @only_data, @titles= only.keys, only
+      else
+        @only_data, @titles = only, nil
+      end
+      @except = opts.delete(:except){[]}
+    end
+
+
+    def data
+      data = case attr
+      when Symbol,String
+        grid.scope.select(attr).uniq.map(&:"#{attr}").sort
+      else
+        attr
+      end
+
+      data = ((data + @only_data) & @only_data).uniq if @only_data
+      data = data - @except
+    end
+
+    def titles
+      if @titles
+        data.map{|d|@titles[d]}
+      else
+        data
+      end
+    end
+
+    def data_titles
+      res = {}	   
+      data.each{|d| res[d] = @titles ? @titles[d] : d}
+      res
+    end
+
+  end
+end

data/lib/gitter/base.rb

@@ -0,0 +1,149 @@
+require 'active_support/concern'
+require 'artdeco'
+require 'gitter/filters.rb'
+require 'gitter/facet.rb'
+  
+module Gitter
+
+  module Base
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def grid &grid
+        if grid
+          @grid = grid
+        else
+          @grid or raise ArgumentError, 'undefined grid'
+        end
+      end
+    end
+  
+    attr_reader :params, :decorator, :options, :values
+
+    def initialize *args
+      opts = args.extract_options!
+      @decorator = Artdeco::Decorator.new *args, opts
+
+      @params = @decorator.params.fetch(key){{}}.symbolize_keys
+
+      @filters, @values, @facets = {}, {}, {} 
+      scope = opts.delete(:scope){nil}
+      @options = opts.dup
+
+      instance_eval &self.class.grid
+
+      @scope = scope || @scope
+
+      @params.each do |name, value|
+        if filter = @filters[name] 
+          @values[name] = value
+        end
+      end
+    end
+    
+    def filter_value filter_name
+      @values[filter_name] 
+    end
+
+    def filters
+      @filters.values 
+    end
+
+    def filter_for name
+      @filters[name]     
+    end
+
+    def label name
+      filter_for(name).label
+    end
+
+    def driver
+      @driver ||= begin
+        scope = Proc === @scope ? instance_eval(&@scope) : @scope
+        create_driver scope
+      end
+    end
+
+    def filtered_driver
+      @filter_driver ||= begin
+        d = driver
+        @values.each do |name, value| 
+          d = @filters[name].apply d, value
+        end
+        d
+      end
+    end
+    
+    def scope &scope
+      if scope
+        @scope = scope
+       else
+        filtered_driver.scope
+      end 
+    end
+
+    def filter *args, &block
+      opts = args.extract_options!
+      raise ConfigurationError, 'only zero or one argument allowed' if args.size > 1
+      name = args.first
+
+      filter = case
+      when opts.delete(:range)
+        raise ConfigurationError, "no block allowed for range filter #{name}" if block
+        return range_filter name, opts # return is required
+      when block 
+        BlockFilter.new self, name, opts, &block
+      when select = opts.delete(:select)
+        if opts[:facet] && opts[:facet] != true
+          opts.merge! values: opts[:facet]
+        end
+        filters = [select].flatten.map{|name| @filters[name] || scope_filter(name)}
+        SelectFilter.new self, name, filters, opts
+      when s = opts.delete(:scope)
+        scope_filter( s == true ? name : s, opts )
+      else 
+        if opts[:facet] && opts[:facet] != true
+          opts.merge! values: opts[:facet]
+        end
+        ColumnFilter.new self, name, opts
+      end
+
+      @facets[name] = Facet.new(filter) if opts[:facet]
+      @filters[name] = filter 
+    end
+
+    # shortcut for filter name, { exact: false, ignore_case: true, strip_blank: true }.merge(options)
+    def search name, opts = {} 
+      filter name, { exact: false, ignore_case: true, strip_blank: true }.merge(opts)
+    end
+
+    def facets
+      @_facets_ ||= @facets.values
+    end
+
+    def facet name
+      @facets[name]
+    end
+
+    private
+
+    def range_filter name, opts
+      column = opts.delete(:column){name}
+
+      filter opts.delete(:from){:"from_#{name}"}, opts do |scope, value|
+        create_driver(scope).greater_or_equal(column, value).scope
+      end
+
+      filter opts.delete(:to){:"to_#{name}"}, opts do |scope, value|
+        create_driver(scope).less_or_equal(column, value).scope
+      end
+
+      filter name, :column => column
+    end
+
+    def scope_filter name, opts = {}
+      BlockFilter.new(self,name, opts){|scope| create_driver(scope).named_scope(name).scope}
+    end
+
+  end
+end