datagrid 0.6.4 → 0.7.0

data/Gemfile

@@ -13,7 +13,6 @@ group :development do
   gem "debugger", :platform => "ruby_19"
 
   gem "rspec"
-  gem "accept_values_for"
   gem "nokogiri" # used to test html output
 
   gem "sqlite3-ruby"

data/Readme.markdown

@@ -21,6 +21,8 @@ Ruby library that helps you to build and represent table-like data with:
 [Datagrid DEMO application](http://datagrid.heroku.com) is available live!
 [Demo source code](https://github.com/bogdan/datagrid-demo).
 
+<img src="http://datagrid.heroku.com/datagrid_demo_screenshot.png" style="margin: 7px; border: 1px solid black">
+
 ### Example
 
 In order to create a grid:
@@ -38,7 +40,7 @@ class SimpleReport
   filter(:disabled, :eboolean)
   filter(:confirmed, :boolean)
   filter(:group_id, :integer, :multiple => true)
-  integer_range_filter(:logins_count, :integer)
+  filter(:logins_count, :integer, :range => true)
   filter(:group_name, :string, :header => "Group") do |value|
     self.joins(:group).where(:groups => {:name => value})
   end
@@ -67,11 +69,11 @@ report = SimpleReport.new(
 report.assets # => Array of User instances: 
               # SELECT * FROM users WHERE users.group_id in (1,2) AND users.logins_count >= 1 AND users.category = 'first' ORDER BY groups.name DESC
 
-report.header # => ["Group", "Name", "Activated"]
+report.header # => ["Name", "Group", "Activated"]
 report.rows   # => [
-              #      ["Steve", "Spammers", true],
-              #      [ "John", "Spoilers", true],
-              #      ["Berry", "Good people", false]
+              #      ["Steve", "Spammers", false],
+              #      [ "John", "Spoilers", false],
+              #      ["Berry", "Good people", true]
               #    ]
 report.data   # => [ header, *rows]
 

data/VERSION

@@ -1 +1 @@
-0.6.4
+0.7.0

data/datagrid.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "datagrid"
-  s.version = "0.6.4"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bogdan Gusiev"]
-  s.date = "2012-09-17"
+  s.date = "2012-12-15"
   s.description = "This allows you to easily build datagrid aka data tables with sortable columns and filters"
   s.email = "agresso@gmail.com"
   s.extra_rdoc_files = [
@@ -48,6 +48,7 @@ Gem::Specification.new do |s|
     "lib/datagrid/filters/enum_filter.rb",
     "lib/datagrid/filters/float_filter.rb",
     "lib/datagrid/filters/integer_filter.rb",
+    "lib/datagrid/filters/ranged_filter.rb",
     "lib/datagrid/filters/string_filter.rb",
     "lib/datagrid/form_builder.rb",
     "lib/datagrid/helper.rb",
@@ -64,8 +65,10 @@ Gem::Specification.new do |s|
     "spec/datagrid/drivers/mongoid_spec.rb",
     "spec/datagrid/filters/boolean_enum_filter_spec.rb",
     "spec/datagrid/filters/composite_filters_spec.rb",
+    "spec/datagrid/filters/date_filter_spec.rb",
     "spec/datagrid/filters/enum_filter_spec.rb",
     "spec/datagrid/filters/float_filter_spec.rb",
+    "spec/datagrid/filters/integer_filter_spec.rb",
     "spec/datagrid/filters_spec.rb",
     "spec/datagrid/form_builder_spec.rb",
     "spec/datagrid/helper_spec.rb",
@@ -96,7 +99,6 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<jeweler>, [">= 0"])
       s.add_development_dependency(%q<debugger>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
-      s.add_development_dependency(%q<accept_values_for>, [">= 0"])
       s.add_development_dependency(%q<nokogiri>, [">= 0"])
       s.add_development_dependency(%q<sqlite3-ruby>, [">= 0"])
       s.add_development_dependency(%q<mongoid>, ["= 2.2.2"])
@@ -111,7 +113,6 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<jeweler>, [">= 0"])
       s.add_dependency(%q<debugger>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 0"])
-      s.add_dependency(%q<accept_values_for>, [">= 0"])
       s.add_dependency(%q<nokogiri>, [">= 0"])
       s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
       s.add_dependency(%q<mongoid>, ["= 2.2.2"])
@@ -127,7 +128,6 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<jeweler>, [">= 0"])
     s.add_dependency(%q<debugger>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 0"])
-    s.add_dependency(%q<accept_values_for>, [">= 0"])
     s.add_dependency(%q<nokogiri>, [">= 0"])
     s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
     s.add_dependency(%q<mongoid>, ["= 2.2.2"])

data/lib/datagrid/columns.rb

@@ -20,6 +20,13 @@ module Datagrid
 
     module ClassMethods
 
+      # Returns a list of columns defined.
+      # You can limit the output with only columns you need like:
+      #
+      #   grid.columns(:id, :name)
+      #
+      # Supported options:
+      # * :data - if true returns only non-html columns. Default: false.
       def columns(*args)
         options = args.extract_options!
         args.compact!
@@ -29,6 +36,7 @@ module Datagrid
         end
       end
 
+      # Defines new datagrid column
       def column(name, options = {}, &block)
         check_scope_defined!("Scope should be defined before columns")
         block ||= lambda do |model|
@@ -53,13 +61,13 @@ module Datagrid
     module InstanceMethods
 
       # Returns <tt>Array</tt> of human readable column names. See also "Localization" section
-      def header
-        self.data_columns.map(&:header)
+      def header(*column_names)
+        data_columns(*column_names).map(&:header)
       end
 
       # Returns <tt>Array</tt> column values for given asset
-      def row_for(asset)
-        self.data_columns.map do |column|
+      def row_for(asset, *column_names)
+        data_columns(*column_names).map do |column|
           column.value(asset, self)
         end
       end
@@ -74,9 +82,10 @@ module Datagrid
       end
 
       # Returns Array of Arrays with data for each row in datagrid assets without header.
-      def rows
+      def rows(*column_names)
+        #TODO: find in batches
         self.assets.map do |asset|
-          self.row_for(asset)
+          self.row_for(asset, *column_names)
         end
       end
 
@@ -92,7 +101,8 @@ module Datagrid
         end
       end
 
-      def to_csv(options = {})
+      def to_csv(*column_names)
+        options = columns.extract_options!
         klass = if RUBY_VERSION >= "1.9"
                   require 'csv'
                   CSV
@@ -101,9 +111,9 @@ module Datagrid
                   FasterCSV
                 end
         klass.generate(
-          {:headers => self.header, :write_headers => true}.merge(options)
+          {:headers => self.header(*column_names), :write_headers => true}.merge(options)
         ) do |csv|
-          self.rows.each do |row|
+          self.rows(*column_names).each do |row|
             csv << row
           end
         end
@@ -113,8 +123,9 @@ module Datagrid
         self.class.columns(*args)
       end
 
-      def data_columns
-        self.columns(:data => true)
+      def data_columns(*names)
+        names << {:data => true}
+        self.columns(*names)
       end
 
       def column_by_name(name)

data/lib/datagrid/columns/column.rb

@@ -1,12 +1,19 @@
 class Datagrid::Columns::Column
 
-  attr_accessor :grid, :options, :block, :name
+  attr_accessor :grid, :options, :block, :name, :html_block
 
   def initialize(grid, name, options = {}, &block)
     self.grid = grid
     self.name = name.to_sym
     self.options = options
-    self.block = block
+    if options[:html] == true
+      self.html_block = block
+    else
+      if options[:html].is_a? Proc
+        self.html_block = options[:html]
+      end
+      self.block = block
+    end
     if format
       ::Datagrid::Utils.warn_once(":format column option is deprecated. Use :url or :html option instead.")
     end
@@ -53,11 +60,11 @@ class Datagrid::Columns::Column
   end
 
   def html?
-    !! self.options[:html]
+    self.html_block != nil
   end
   
   def data?
-    !html?
+    self.block != nil
   end
 
 end

data/lib/datagrid/core.rb

@@ -47,7 +47,7 @@ module Datagrid
 
       protected
       def check_scope_defined!(message = nil)
-        message ||= "Scope not defined"
+        message ||= "#{self}.scope is not defined"
         raise(Datagrid::ConfigurationError, message) unless scope_value
       end
 

data/lib/datagrid/drivers/abstract_driver.rb

@@ -52,6 +52,10 @@ module Datagrid
       def has_column?(scope, column_name)
         raise NotImplementedError
       end
+
+      def reverse_order(scope)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/datagrid/drivers/active_record.rb

@@ -34,11 +34,11 @@ module Datagrid
       end
 
       def greater_equal(scope, field, value)
-        scope.where(["#{field} >= ?", value])
+        scope.where(["#{scope.table_name}.#{field} >= ?", value])
       end
 
       def less_equal(scope, field, value)
-        scope.where(["#{field} <= ?", value])
+        scope.where(["#{scope.table_name}.#{field} <= ?", value])
       end
 
       def has_column?(scope, column_name)

data/lib/datagrid/filters.rb

@@ -53,7 +53,6 @@ module Datagrid
         klass = type.is_a?(Class) ? type : FILTER_TYPES[type]
         raise ConfigurationError, "filter class #{type.inspect} not found" unless klass
 
-        block ||= default_filter(attribute)
 
         filter = klass.new(self, attribute, options, &block)
         self.filters << filter
@@ -65,18 +64,6 @@ module Datagrid
       end
 
       protected
-      def default_filter(attribute)
-        check_scope_defined!("Scope should be defined before filters")
-        if !driver.has_column?(scope, attribute) && driver.to_scope(scope).respond_to?(attribute)
-          lambda do |value, scope, grid|
-            grid.driver.to_scope(scope).send(attribute, value)
-          end
-        else
-          lambda do |value, scope, grid|
-            grid.driver.where(scope, attribute => value)
-          end
-        end
-      end
 
       def inherited(child_class)
         super(child_class)

data/lib/datagrid/filters/base_filter.rb

@@ -3,11 +3,11 @@ class Datagrid::Filters::BaseFilter
 
   attr_accessor :grid, :options, :block, :name
 
-  def initialize(grid, name, options = {}, &block)
-    self.grid = grid
+  def initialize(grid_class, name, options = {}, &block)
+    self.grid = grid_class
     self.name = name
     self.options = options
-    self.block = block
+    self.block = block || default_filter_block 
   end
 
   def format(value)
@@ -32,11 +32,11 @@ class Datagrid::Filters::BaseFilter
 
   def format_values(value)
     if !self.multiple && value.is_a?(Array) 
-      raise Datagrid::ArgumentError, "#{grid.class}.#{name} filter can not accept Array argument. Use :multiple option." 
+      raise Datagrid::ArgumentError, "#{grid}##{name} filter can not accept Array argument. Use :multiple option." 
     end
     values = Array.wrap(value)
-    values.map! do |value|
-      self.format(value)
+    values.map! do |v|
+      self.format(v)
     end
     self.multiple ? values : values.first
   end
@@ -71,5 +71,25 @@ class Datagrid::Filters::BaseFilter
     :"datagrid_#{self.to_s.demodulize.underscore}"
   end
 
+  def default_filter_block
+    filter = self
+    lambda do |value, scope, grid| 
+      filter.default_filter(value, scope, grid)
+    end                                         
+  end
+
+  def default_filter(value, scope, grid)
+    driver = grid.driver
+    if !driver.has_column?(scope, name) && driver.to_scope(scope).respond_to?(name)
+      driver.to_scope(scope).send(name, value)
+    else
+      default_filter_where(driver, scope, value)
+    end
+  end
+
+  def default_filter_where(driver, scope, value)
+    driver.where(scope, name => value)
+  end
+
 end
 

data/lib/datagrid/filters/date_filter.rb

@@ -1,12 +1,26 @@
+require "datagrid/filters/ranged_filter"
+
 class Datagrid::Filters::DateFilter < Datagrid::Filters::BaseFilter
-  #TODO: more smart date normalizer
+
+  include RangedFilter
+
+  def apply(grid_object, scope, value)
+    if value.is_a?(Range)
+      value = value.first.beginning_of_day..value.last.end_of_day
+    end
+    super(grid_object, scope, value)
+  end
+
   def format(value)
     return nil if value.blank?
+    return value if value.is_a?(Range)
     return value.to_date if value.respond_to?(:to_date)
     return value unless value.is_a?(String)
+    #TODO: more smart date normalizer
     Date.parse(value)
   rescue ArgumentError
     nil
   end
+
 end
 

data/lib/datagrid/filters/integer_filter.rb

@@ -1,6 +1,12 @@
+require "datagrid/filters/ranged_filter"
+
 class Datagrid::Filters::IntegerFilter < Datagrid::Filters::BaseFilter
+
+  include RangedFilter
+
   def format(value)
     return nil if value.blank?
+    return value if value.is_a?(Range)
     value.to_i
   end
 end

data/lib/datagrid/filters/ranged_filter.rb

@@ -0,0 +1,55 @@
+module RangedFilter
+  
+
+  def initialize(grid, name, options, &block)
+    super(grid, name, options, &block)
+    if range?
+      options[:multiple] = true
+    end
+  end
+
+  def format_values(value)
+    result = super(value)
+    if range? 
+      if result.is_a?(Array)
+        case result.size
+        when 0
+          nil
+        when 1
+          result.first
+        when 2
+          result
+        else
+          raise ArgumentError, "Can not create a date range from array of more than two: #{result.inspect}"
+        end
+      else
+        # Simulate single point range
+        result..result
+      end
+
+    else
+      result
+    end
+  end
+
+  def range?
+    options[:range]
+  end
+
+  def default_filter_where(driver, scope, value)
+    if range? && value.is_a?(Array)
+      left, right = value
+      if left
+        scope = driver.greater_equal(scope, name, left)
+      end
+      if right
+        scope = driver.less_equal(scope, name, right)
+      end
+      scope
+    else 
+      super(driver, scope, value)
+    end
+  end
+
+
+end

data/lib/datagrid/form_builder.rb

@@ -4,15 +4,13 @@ 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_html_class(filter)}"
+      filter = datagrid_get_filter(filter_or_attribute)
+      options = Datagrid::Utils.add_html_classes(options, filter.name, datagrid_filter_html_class(filter))
       self.send(filter.form_builder_helper_name, filter, options)
     end
 
     def datagrid_label(filter_or_attribute, options = {})
-      filter = get_filter(filter_or_attribute)
+      filter = datagrid_get_filter(filter_or_attribute)
       self.label(filter.name, filter.header, options)
     end
 
@@ -22,20 +20,19 @@ module Datagrid
     end
 
     def datagrid_boolean_filter(attribute_or_filter, options = {})
-      check_box(get_attribute(attribute_or_filter), options)
+      check_box(datagrid_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)
+      datagrid_range_filter(:date, attribute_or_filter, options)
     end
 
     def datagrid_default_filter(attribute_or_filter, options = {})
-      text_field get_attribute(attribute_or_filter), options
+      text_field datagrid_get_attribute(attribute_or_filter), options
     end
 
     def datagrid_enum_filter(attribute_or_filter, options = {})
-      filter = get_filter(attribute_or_filter)
+      filter = datagrid_get_filter(attribute_or_filter)
       if !options.has_key?(:multiple) && filter.multiple
         options[:multiple] = true
       end
@@ -43,11 +40,32 @@ module Datagrid
     end
 
     def datagrid_integer_filter(attribute_or_filter, options = {})
-      filter = get_filter(attribute_or_filter)
+      filter = datagrid_get_filter(attribute_or_filter)
       if filter.multiple && self.object[filter.name].blank?
         options[:value] = ""
       end
-      text_field filter.name, options
+      datagrid_range_filter(:integer, filter, options)
+    end
+
+    def datagrid_range_filter(type, attribute_or_filter, options = {})
+      filter = datagrid_get_filter(attribute_or_filter)
+      if filter.range?
+        options = options.merge(:multiple => true)
+
+        from_options = Datagrid::Utils.add_html_classes(options, "from")
+        from_value = object[filter.name].try(:first)
+
+        to_options = Datagrid::Utils.add_html_classes(options, "to")
+        to_value = object[filter.name].try(:last)
+        # 2 inputs: "from date" and "to date" to specify a range
+        [
+          text_field(filter.name, from_options.merge!(:value => from_value)),
+          I18n.t("datagrid.misc.#{type}_range_separator", :default => "<span class=\"separator #{type}\"> - </span>"),
+          text_field(filter.name, to_options.merge!(:value => to_value))
+        ].join.html_safe
+      else
+        text_field(filter.name, options)
+      end
     end
 
     def datagrid_string_filter(attribute_or_filter, options = {})
@@ -58,11 +76,11 @@ module Datagrid
       datagrid_default_filter(attribute_or_filter, options)
     end
 
-    def get_attribute(attribute_or_filter)
+    def datagrid_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)
+    def datagrid_get_filter(attribute_or_filter)
       if attribute_or_filter.is_a?(Symbol)
         object.class.filter_by_name(attribute_or_filter) ||
           raise(Error, "filter #{attribute_or_filter} not found")