datagrid 0.0.3

data/lib/datagrid/filters/boolean_filter.rb

@@ -0,0 +1,7 @@
+class Datagrid::Filters::BooleanFilter < Datagrid::Filters::BaseFilter
+
+  def format(value)
+    [true, 1, "1", "true", "yes", "on"].include?(value)
+  end
+
+end

data/lib/datagrid/filters/composite_filters.rb

@@ -0,0 +1,41 @@
+module Datagrid
+  module Filters
+    module CompositeFilters
+
+      def self.included(base)
+        base.extend         ClassMethods
+        base.class_eval do
+
+        end
+        base.send :include, InstanceMethods
+      end # self.included
+
+      module ClassMethods
+
+
+        def date_range_filters(field, from_name = :"from_#{field}", to_name = :"to_#{field}")
+          filter(from_name, :date) do |date|
+            self.from_date(date, field)
+          end
+          filter(to_name, :date) do |date|
+            self.to_date(date, field)
+          end
+        end
+
+        def integer_range_filters(field, from_name = :"from_#{field}", to_name = :"to_#{field}")
+          filter(from_name, :integer) do |value|
+            self.scoped(:conditions => "#{field} >= #{value}")
+          end
+          filter(to_name, :integer) do |value|
+            self.scoped(:conditions => "#{field} <= #{value}")
+          end
+        end
+      end # ClassMethods
+
+      module InstanceMethods
+
+      end # InstanceMethods
+
+    end
+  end
+end

data/lib/datagrid/filters/date_filter.rb

@@ -0,0 +1,10 @@
+class Datagrid::Filters::DateFilter < Datagrid::Filters::BaseFilter
+  #TODO: more smart date normalizer
+  def format(value)
+    return value unless value.is_a?(String)
+    value.blank? ? nil : Date.parse(value)
+  rescue ArgumentError
+    nil
+  end
+end
+

data/lib/datagrid/filters/default_filter.rb

@@ -0,0 +1,5 @@
+class Datagrid::Filters::DefaultFilter < Datagrid::Filters::BaseFilter
+  def format(value)
+    value
+  end
+end

data/lib/datagrid/filters/enum_filter.rb

@@ -0,0 +1,32 @@
+class Datagrid::Filters::EnumFilter < Datagrid::Filters::BaseFilter
+
+  def initialize(*args)
+    super(*args)
+    raise Datagrid::ConfigurationError, ":select option not specified" unless select
+  end
+  def format(value)
+    values = Array.new([*value])
+    values.reject do |value|
+      #TODO: really impelement #strict option
+      self.strict && !select.include?(value)
+    end
+    self.multiple ? values : values.first
+  end
+
+  def select
+    self.options[:select]
+  end
+
+
+  def include_blank
+    self.options.has_key?(:include_blank) ? options[:include_blank] : true
+  end
+
+  def strict
+    self.options[:strict]
+  end
+
+  def multiple
+    self.options[:multiple]
+  end
+end

data/lib/datagrid/filters/filter_eval.rb

@@ -0,0 +1,25 @@
+# ActiveRecord is a little brain fuck.
+# We can not call instance_eval on ActiveRecord::Relation class
+# because it will automatically convert it to an array because #instance_eval
+# is not included in the method list that do not cause force result loading
+# That is why we need thi helper class
+class Datagrid::Filters::FilterEval
+
+  def initialize(filter, scope, value)
+    @filter = filter
+    @scope = scope
+    @value = value
+  end
+
+  def run
+    instance_exec @value, &(@filter.block)
+  end
+
+  def method_missing(meth, *args, &blk)
+    if @scope.respond_to?(meth)
+      @scope.send(meth, *args, &blk)
+    else
+      super(meth, *args, &blk)
+    end
+  end
+end

data/lib/datagrid/filters/integer_filter.rb

@@ -0,0 +1,7 @@
+class Datagrid::Filters::IntegerFilter < Datagrid::Filters::BaseFilter
+  def format(value)
+    return nil if value.blank?
+    value.to_i
+  end
+end
+

data/lib/datagrid/form_builder.rb

@@ -0,0 +1,56 @@
+require "action_view"
+
+module Datagrid
+  module FormBuilder
+
+    def datagrid_filter(filter_or_attribute, options = {})
+      filter = get_filter(filter_or_attribute)
+      options[:class] ||= ""
+      options[:class] += " " unless options[:class].blank?
+      options[:class] += "#{filter.name} #{datagrid_filter_class(filter.class)}"
+      self.send(:"datagrid_#{filter.class.to_s.underscore.split('/').last}", filter, options)
+    end
+
+    protected
+    def datagrid_boolean_enum_filter(attribute_or_filter, options = {})
+      datagrid_enum_filter(attribute_or_filter, options)
+    end
+
+    def datagrid_boolean_filter(attribute_or_filter, options = {})
+      check_box(get_attribute(attribute_or_filter), options)
+    end
+
+    def datagrid_date_filter(attribute_or_filter, options = {})
+      attribute = get_attribute(attribute_or_filter)
+      text_field(attribute, options)
+    end
+
+    def datagrid_default_filter(attribute_or_filter, options = {})
+      text_field get_attribute(attribute_or_filter), options
+    end
+
+    def datagrid_enum_filter(attribute_or_filter, options = {})
+      filter = get_filter(attribute_or_filter)
+      select filter.name, filter.select || [], {:include_blank => filter.include_blank}, {:multiple => filter.multiple}.merge(options)
+    end
+
+    def datagrid_integer_filter(attribute_or_filter, options = {})
+      text_field get_attribute(attribute_or_filter), options
+    end
+
+    def get_attribute(attribute_or_filter)
+      attribute_or_filter.is_a?(Symbol) ?  attribute_or_filter : attribute_or_filter.name 
+    end
+
+    def get_filter(attribute_or_filter)
+      attribute_or_filter.is_a?(Symbol) ? object.class.filter_by_name(attribute_or_filter) : attribute_or_filter
+    end
+
+    def datagrid_filter_class(klass)
+      klass.to_s.split("::").last.underscore
+    end
+  end
+end
+
+ActionView::Helpers::FormBuilder.send(:include, Datagrid::FormBuilder)
+

data/lib/datagrid/helper.rb

@@ -0,0 +1,80 @@
+require "action_view"
+
+module Datagrid
+  module Helper
+
+    def datagrid_format_value(column, asset)
+      value = column.value(asset)
+      if column.options[:url]
+        link_to(value, column.options[:url].call(asset))
+      else
+        case column.format
+        when :url
+          link_to(column.label  ? asset.send(column.label) : I18n.t("datagrid.table.url_label", :default => "URL"), value)
+        else
+          value
+        end
+      end
+    end
+
+    def datagrid_table(report, *args)
+      options = args.extract_options!
+      html = options[:html] || {}
+      html[:class] ||= "datagrid"
+      paginate = options[:paginate] || {}
+      paginate[:page] ||= params[:page]
+      assets = report.assets.paginate(paginate)
+      content_tag(:table, html) do
+        table = content_tag(:tr, datagrid_header(report, options))
+        table << datagrid_rows(report.columns, assets, options)
+        table
+      end
+    end
+
+    protected
+
+    def datagrid_header(grid, options)
+      header = empty_string
+      grid.columns.each do |column|
+        data = column.header.html_safe
+        if column.order
+          data << datagrid_order_for(grid, column)
+        end
+        header << content_tag(:th, data)
+      end
+      header
+    end
+
+    def datagrid_rows(columns, assets, options)
+      rows = empty_string
+      assets.each do |asset|
+        rows << content_tag(:tr, :class => cycle("odd", "even")) do
+          html = empty_string
+          columns.each do |column|
+            html << content_tag(:td, datagrid_format_value(column, asset))
+          end
+          html
+        end
+
+      end
+      rows
+    end
+
+    def datagrid_order_for(grid, column)
+      content_tag(:div, :class => "order") do
+        link_to(
+          I18n.t("datagrid.table.order.asc", :default => "ASC"), url_for(grid.param_name => grid.attributes.merge(:order => column.name))
+        ) + " " +
+          link_to(I18n.t("datagrid.table.order.desc", :default => "DESC"), url_for(grid.param_name => grid.attributes.merge(:order => column.name, :reverse => true )))
+      end
+    end
+
+    def empty_string
+      res = ""
+      res.respond_to?(:html_safe) ? res.html_safe : res
+    end
+  end
+
+  ::ActionView::Base.send(:include, ::Datagrid::Helper)
+
+end

data/lib/datagrid/rspec.rb

@@ -0,0 +1,68 @@
+shared_examples_for "Datagrid" do
+  describe "as Datagrid" do
+
+    it "should have at least one entry if assets" do
+      subject.assets.should_not be_empty
+    end
+
+    its(:data) {should_not be_empty}
+
+    described_class.columns.each do |column|
+      describe "column ##{column.name}" do
+
+        it "should has value in #data_hash" do
+          subject.data_hash.first.should have_key(column.name)
+        end
+
+        it "should support order" do
+          subject.order = column.name
+          subject.assets.first.should_not be_nil
+        end
+
+        it "should support reverse order" do
+          subject.reverse = true
+          subject.assets.first.should_not be_nil
+        end
+      end
+
+    end
+
+    described_class.filters.each do |filter|
+      describe "filter ##{filter.name}" do
+
+        let(:filter_value) do
+          
+          case Datagrid::Filters::FILTER_TYPES.invert[filter.class]
+          when :default, :string
+            "text"
+          when :date
+            1.day.ago
+          when :eboolean
+            Datagrid::Filters::BooleanEnumFilter::YES
+          when :boolean
+            true
+          when :integer
+            1
+          when :enum
+            select = filter.select
+            select = select.call(subject)  if select.respond_to?(:call)
+            select.first.try(:last)
+          else
+            raise "unknown filter type: #{filter.class}"
+          end.to_s
+        end
+
+        before(:each) do
+          subject.attributes = {filter.name => filter_value}
+          subject.send(filter.name).should_not be_nil
+        end
+
+        it "should be supported" do
+          subject.assets.should_not be_nil 
+          #TODO: better matcher.
+        end
+      end
+    end
+
+  end
+end

data/spec/datagrid/form_builder_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+
+class MyFormBuilder
+  include Datagrid::FormBuilder
+end
+
+class MyTemplate
+  include ActionView::Helpers::FormHelper
+end
+
+
+describe Datagrid::FormBuilder do
+
+  let(:template) { ActionView::Base.new}
+  let(:grid) { SimpleReport.new }
+  let(:view) { ActionView::Helpers::FormBuilder.new(:report, grid, template, {}, Proc.new {|f| })}
+  subject { view }
+
+
+  describe ".datagrid_filter" do
+
+    subject { view.datagrid_filter(_filter)}
+    context "with default filter type" do
+      let(:_filter) { :name }
+      it { should equal_to_dom(
+        '<input class="name default_filter" id="report_name" name="report[name]" size="30" type="text"/>'
+      )}
+    end
+    context "with integer filter type" do
+      let(:_filter) { :group_id }
+      it { should equal_to_dom(
+        '<input class="group_id integer_filter" id="report_group_id" name="report[group_id]" size="30" type="text"/>'
+      )}
+    end
+    context "with enum filter type" do
+      let(:_filter) { :category }
+      it { should equal_to_dom(
+        '<select class="category enum_filter" id="report_category" name="report[category][]"><option value=""></option>
+       <option value="first">first</option>
+       <option value="second">second</option></select>'
+      )}
+      context "when first option is selected" do
+        before(:each) do
+          grid.category = "first"
+        end
+        it { should equal_to_dom(
+          '<select class="category enum_filter" id="report_category" name="report[category][]"><option value=""></option>
+       <option value="first" selected="true">first</option>
+       <option value="second">second</option></select>'
+        )}
+      end
+    end
+
+    context "with eboolean filter type" do
+      let(:_filter) { :disabled }
+      it { should equal_to_dom(
+        '<select class="disabled boolean_enum_filter" id="report_disabled" name="report[disabled][]"><option value=""></option>
+       <option value="NO">NO</option>
+       <option value="YES">YES</option></select>'
+      )}
+    end
+  end
+end
+
+
+
+

data/spec/datagrid/helper_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require "will_paginate"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/object"
+
+describe Datagrid::Helper do
+  subject {ActionView::Base.new}
+
+  before(:each) do
+    subject.stub!(:params).and_return({})
+    subject.stub(:url_for) do |options|
+      options.to_param
+    end
+    
+  end
+
+  let(:group) { Group.create!(:name => "Pop") }
+  let!(:entry) {  Entry.create!(
+    :group => group, :name => "Star", :disabled => false, :confirmed => false, :category => "first"
+  ) }
+  let(:grid) { SimpleReport.new }
+
+  describe ".report_table" do
+    before(:each) do
+      subject.stub!(:datagrid_order_for).and_return(subject.content_tag(:div, "", :class => "order"))
+    end
+    it "should return data table html" do
+      subject.datagrid_table(grid).should equal_to_dom(
+'<table class="datagrid">
+<tr>
+<th>Group<div class="order"></div>
+</th>
+<th>Name<div class="order"></div>
+</th>
+</tr>
+
+<tr class="odd">
+<td>Pop</td>
+<td>Star</td>
+</tr>
+</table>')
+    end
+  end
+  
+
+end