datagrid 0.9.0 → 0.9.2

data/Readme.markdown

@@ -13,6 +13,7 @@ Ruby library that helps you to build and represent table-like data with:
 * ActiveRecord
 * Mongoid
 * MongoMapper
+* Array (slow but possible)
 
 [Create an issue](https://github.com/bogdan/datagrid/issues/new) if you want more.
 
@@ -40,8 +41,8 @@ class SimpleReport
   filter(:disabled, :eboolean)
   filter(:confirmed, :boolean)
   filter(:group_id, :integer, :multiple => true)
-  filter(:logins_count, :integer, :range => true)
-  filter(:group_name, :string, :header => "Group") do |value|
+  filter(:logins_count, :integer, :range => true, :before => :group_id)
+  filter(:group_name, :string, :header => "Group", :after => :category_id) do |value|
     self.joins(:group).where(:groups => {:name => value})
   end
 
@@ -129,7 +130,7 @@ Datagrid supports different type of filters including:
 Each column is represented by name and code block to calculate the value.
 
 ``` ruby
-column(:activated, :header => "Active", :order => "activated") do
+column(:activated, :header => "Active", :order => "activated", :after => :name) do
   self.activated?
 end
 ```

data/VERSION

@@ -1 +1 @@
-0.9.0
+0.9.2

data/app/views/datagrid/_head.html.erb

@@ -1,5 +1,5 @@
 <tr>
-  <% grid.columns(*options[:columns]).each do |column| %>
+  <% grid.html_columns(*options[:columns]).each do |column| %>
     <th class="<%= datagrid_column_classes(grid, column) %>">
       <%= column.header %>
       <%= datagrid_order_for(grid, column) if column.order && options[:order]%>

data/app/views/datagrid/_row.html.erb

@@ -1,5 +1,5 @@
 <tr class="<%= options[:cycle] && cycle(*options[:cycle]) %>">
-  <% grid.columns(*options[:columns]).each do |column| %>
+  <% grid.html_columns(*options[:columns]).each do |column| %>
     <td class="<%= datagrid_column_classes(grid, column) %>"><%= datagrid_format_value(grid, column, asset) %></td>
   <% end %>
 </tr>

data/datagrid.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "datagrid"
-  s.version = "0.9.0"
+  s.version = "0.9.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bogdan Gusiev"]
-  s.date = "2013-06-06"
+  s.date = "2013-08-23"
   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 = [

data/lib/datagrid/column_names_attribute.rb

@@ -17,6 +17,7 @@ module Datagrid
     end
 
     module ClassMethods
+      # Adds a filter that acts like a column selection
       def column_names_filter
         filter(:column_names, :enum, :select => proc { |grid| grid.class.columns.map {|c| [c.header, c.name] }}, :multiple => true ) do |value|
           scoped
@@ -24,7 +25,7 @@ module Datagrid
       end
     end
 
-    def columns(*args)
+    def columns(*args) #:nodoc:
       options = args.extract_options!
       column_names = selected_column_names(*args)
       column_names << options

data/lib/datagrid/columns.rb

@@ -32,17 +32,36 @@ module Datagrid
         args.compact!
         args.map!(&:to_sym)
         columns_array.select do |column|
-          (!options[:data] || column.data?) && (args.empty? || args.include?(column.name))
+          (!options[:data] || column.data?) && (!options[:html] || column.html?)&& (args.empty? || args.include?(column.name))
         end
       end
 
       # Defines new datagrid column
+      # 
+      # Arguments:
+      #
+      #   * <tt>name</tt> - column name
+      #   * <tt>options</tt> - hash of options
+      #   * <tt>block</tt> - proc to calculate a column value
+      #
+      # Available options:
+      #   
+      #   * <tt>:html</tt> - determines if current column should be present in html table and how is it formatted
+      #   * <tt>:order</tt> - determines if this column could be sortable and how
+      #   * <tt>:order_desc</tt> - determines a descending order for given column (only in case when <tt>:order</tt> can not be easily inverted
+      #   * <tt>:url</tt> - a proc with one argument, pass this option to easily convert the value into an URL
+      #   * <tt>:before</tt> - determines the position of this column, by adding it before the column passed here
+      #   * <tt>:after</tt> - determines the position of this column, by adding it after the column passed here
+      #
+      # See: https://github.com/bogdan/datagrid/wiki/Columns for examples
       def column(name, options = {}, &block)
         check_scope_defined!("Scope should be defined before columns")
         block ||= lambda do |model|
           model.send(name)
         end
-        columns_array << Datagrid::Columns::Column.new(self, name, options, &block)
+        position = Datagrid::Utils.extract_position_from_options(columns_array, options)
+        column = Datagrid::Columns::Column.new(self, name, options, &block)
+        columns_array.insert(position, column)
       end
 
       # Returns column definition with given name
@@ -52,6 +71,30 @@ module Datagrid
         end
       end
 
+      # Returns an array of all defined column names
+      def column_names
+        columns.map(&:name)
+      end
+
+      def respond_to(&block) #:nodoc:
+        Datagrid::Columns::Column::ResponseFormat.new(&block)
+      end
+
+      def format(value, &block)
+        if block_given?
+          respond_to do |f|
+            f.data { value }
+            f.html do
+              instance_exec(value, &block)
+            end
+          end
+        else
+          # Ruby Object#format exists. 
+          # We don't want to change the behaviour and overwrite it.
+          super
+        end
+      end
+
       def inherited(child_class) #:nodoc:
         super(child_class)
         child_class.columns_array = self.columns_array.clone
@@ -62,14 +105,22 @@ module Datagrid
     module InstanceMethods
 
       # Returns <tt>Array</tt> of human readable column names. See also "Localization" section
+      #
+      # Arguments:
+      #
+      #   * <tt>column_names</tt> - list of column names if you want to limit data only to specified columns
       def header(*column_names)
         data_columns(*column_names).map(&:header)
       end
 
       # Returns <tt>Array</tt> column values for given asset
+      #
+      # Arguments:
+      #
+      #   * <tt>column_names</tt> - list of column names if you want to limit data only to specified columns
       def row_for(asset, *column_names)
         data_columns(*column_names).map do |column|
-          column.value(asset, self)
+          column.data_value(asset, self)
         end
       end
 
@@ -77,12 +128,16 @@ module Datagrid
       def hash_for(asset)
         result = {}
         self.data_columns.each do |column|
-          result[column.name] = column.value(asset, self)
+          result[column.name] = column.data_value(asset, self)
         end
         result
       end
 
       # Returns Array of Arrays with data for each row in datagrid assets without header.
+      #
+      # Arguments:
+      #
+      #   * <tt>column_names</tt> - list of column names if you want to limit data only to specified columns
       def rows(*column_names)
         #TODO: find in batches
         self.assets.map do |asset|
@@ -91,12 +146,30 @@ module Datagrid
       end
 
       # Returns Array of Arrays with data for each row in datagrid assets with header.
-      def data
-        self.rows.unshift(self.header)
+      #
+      # Arguments:
+      #
+      #   * <tt>column_names</tt> - list of column names if you want to limit data only to specified columns
+      def data(*column_names)
+        self.rows(*column_names).unshift(self.header(*column_names))
       end
 
       # Return Array of Hashes where keys are column names and values are column values 
       # for each row in datagrid <tt>#assets</tt>
+      #
+      # Example:
+      #
+      #     class MyGrid
+      #       scope { Model }
+      #       column(:id)
+      #       column(:name)
+      #     end
+      #
+      #     Model.create!(:name => "One")
+      #     Model.create!(:name => "Two")
+      #
+      #     MyGrid.new.data_hash # => [{:name => "One"}, {:name => "Two"}]
+      #
       def data_hash
         self.assets.map do |asset|
           hash_for(asset)
@@ -139,12 +212,13 @@ module Datagrid
       # 
       #   MyGrid.new.columns # => all defined columns
       #   grid = MyGrid.new(:column_names => [:id, :name])
-      #   grid.columns # => id and name columsn
+      #   grid.columns # => id and name columns
       #   grid.columns(:id, :category) # => id and category column
       def columns(*args)
         self.class.columns(*args)
       end
 
+      # Returns all columns that can be represented in plain data(non-html) way
       def data_columns(*names)
         options = names.extract_options!
         options[:data] = true
@@ -152,9 +226,28 @@ module Datagrid
         self.columns(*names)
       end
 
+      # Returns all columns that can be represented in HTML table
+      def html_columns(*names)
+        options = names.extract_options!
+        options[:html] = true
+        names << options
+        self.columns(*names)
+      end
+
+      # Finds a column by name
       def column_by_name(name)
         self.class.column_by_name(name)
       end
+
+
+      def format(value, &block)
+        if block_given?
+          self.class.format(value, &block)
+        else
+          super
+        end
+      end
+
     end # InstanceMethods
 
   end

data/lib/datagrid/columns/column.rb

@@ -1,41 +1,52 @@
 class Datagrid::Columns::Column
 
-  attr_accessor :grid, :options, :block, :name, :html_block
+  class ResponseFormat # :nodoc:
 
-  def initialize(grid, name, options = {}, &block)
-    self.grid = grid
+    attr_accessor :data_block, :html_block
+
+    def initialize
+      yield(self)
+    end
+
+    def data(&block)
+      self.data_block = block
+    end
+
+    def html(&block)
+      self.html_block = block
+    end
+
+    def data_value
+      data_block.call
+    end
+
+    def html_value(context)
+      context.instance_eval(&html_block)
+    end
+  end
+
+  attr_accessor :grid_class, :options, :data_block, :name, :html_block
+
+  def initialize(grid_class, name, options = {}, &block)
+    self.grid_class = grid_class
     self.name = name.to_sym
     self.options = options
     if options[:html] == true
       self.html_block = block
     else
+      self.data_block = block
+
       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
   end
 
-  def value(model, grid)
-    value_for(model, grid)
+  def data_value(model, grid)
+    result = generic_value(model,grid)
+    result.is_a?(ResponseFormat) ? result.data_value : result
   end
 
-  def value_for(model, grid)
-    if self.block.arity == 1
-      self.block.call(model)
-    elsif self.block.arity == 2
-      self.block.call(model, grid)
-    else
-      model.instance_eval(&self.block)
-    end
-  end
-
-  def format
-    self.options[:format]
-  end
 
   def label
     self.options[:label]
@@ -43,14 +54,14 @@ class Datagrid::Columns::Column
 
   def header
     self.options[:header] || 
-      I18n.translate(self.name, :scope => "datagrid.#{self.grid.param_name}.columns", :default => self.name.to_s.humanize )
+      I18n.translate(self.name, :scope => "datagrid.#{self.grid_class.param_name}.columns", :default => self.name.to_s.humanize )
   end
 
   def order
     if options.has_key?(:order)
       self.options[:order]
     else
-      grid.driver.default_order(grid.scope, name)
+      grid_class.driver.default_order(grid_class.scope, name)
     end
   end
 
@@ -60,11 +71,50 @@ class Datagrid::Columns::Column
   end
 
   def html?
-    self.html_block != nil
+    options[:html] != false
   end
   
   def data?
-    self.block != nil
+    self.data_block != nil
+  end
+
+  def html_value(context, asset, grid)
+    if html? && html_block
+      value_from_html_block(context, asset, grid)
+    else
+      result = generic_value(asset,grid)
+      result.is_a?(ResponseFormat) ? result.html_value(context) : result
+    end
+  end
+
+  def value_from_html_block(context, asset, grid)
+    args = []
+    remaining_arity = html_block.arity
+
+    if data?
+      args << data_value(asset,grid)
+      remaining_arity -= 1
+    end
+
+    args << asset if remaining_arity > 0
+    args << grid if remaining_arity > 1
+
+    return context.instance_exec(*args, &html_block)
+  end
+
+  def block
+    Datagrid::Utils.warn_once("Datagrid::Columns::Column#block is deprecated. Use #html_block or #data_block instead")
+    data_block
+  end
+
+  def generic_value(model, grid)
+    if self.data_block.arity == 1
+      self.data_block.call(model)
+    elsif self.data_block.arity == 2
+      self.data_block.call(model, grid)
+    else
+      model.instance_eval(&self.data_block)
+    end
   end
 
 end

data/lib/datagrid/core.rb

@@ -16,7 +16,7 @@ module Datagrid
 
     module ClassMethods
 
-      def datagrid_attribute(name, &block)
+      def datagrid_attribute(name, &block) #:nodoc:
         unless datagrid_attributes.include?(name)
           block ||= lambda do |value|
             value
@@ -32,6 +32,7 @@ module Datagrid
         end
       end
 
+      # Defines a scope at class level
       def scope(&block)
         if block
           self.scope_value = block
@@ -41,7 +42,7 @@ module Datagrid
         end
       end
 
-      def driver
+      def driver #:nodoc:
         @driver ||= Drivers::AbstractDriver.guess_driver(scope).new
       end
 
@@ -60,12 +61,16 @@ module Datagrid
 
     module InstanceMethods
 
-      def initialize(attributes = nil)
+      def initialize(attributes = nil, &block)
         super()
 
         if attributes
           self.attributes = attributes
         end
+
+        if block_given?
+          self.scope_value = block
+        end
       end
 
       def attributes
@@ -88,11 +93,14 @@ module Datagrid
         driver.to_scope(scope)
       end
 
-      def attributes=(attributes)
+
+      def assign_attributes(attributes)
         attributes.each do |name, value|
           self[name] = value
         end
+        self
       end
+      alias attributes= assign_attributes
 
       def as_query
         attributes = self.attributes.clone
@@ -111,17 +119,19 @@ module Datagrid
         if block_given?
           self.scope_value = block
           self
+        elsif scope_value
+          scope_value.call
         else
           check_scope_defined!
           scope_value.call
         end
       end
 
-      def driver
+      def driver #:nodoc:
         self.class.driver
       end
 
-      def check_scope_defined!(message = nil)
+      def check_scope_defined!(message = nil) #:nodoc:
         self.class.send :check_scope_defined!, message
       end
 

data/lib/datagrid/filters.rb

@@ -46,6 +46,25 @@ module Datagrid
         end
       end
 
+      # Defines new datagrid filter
+      # 
+      # Arguments:
+      #
+      #   * <tt>name</tt> - filter name
+      #   * <tt>options</tt> - hash of options
+      #   * <tt>block</tt> - proc to apply the filter
+      #
+      # Available options:
+      #   
+      #   * <tt>:header</tt> - determines the header of the filter
+      #   * <tt>:default</tt> - the default filter value
+      #   * <tt>:multiple</tt> - determines if more than one option can be selected
+      #   * <tt>:allow_nil</tt> - determines if the value can be nil
+      #   * <tt>:allow_blank</tt> - determines if the value can be blank
+      #   * <tt>:before</tt> - determines the position of this filter, by adding it before the filter passed here (when using datagrid_form_for helper)
+      #   * <tt>:after</tt> - determines the position of this filter, by adding it after the filter passed here (when using datagrid_form_for helper)
+      #
+      # See: https://github.com/bogdan/datagrid/wiki/Columns for examples
       def filter(attribute, *args, &block)
         options = args.extract_options!
         type = args.shift || :default
@@ -53,9 +72,9 @@ module Datagrid
         klass = type.is_a?(Class) ? type : FILTER_TYPES[type]
         raise ConfigurationError, "filter class #{type.inspect} not found" unless klass
 
-
+        position = Datagrid::Utils.extract_position_from_options(self.filters, options)
         filter = klass.new(self, attribute, options, &block)
-        self.filters << filter
+        self.filters.insert(position, filter)
 
         datagrid_attribute(attribute) do |value|
           filter.parse_values(value)
@@ -97,6 +116,11 @@ module Datagrid
         self[filter.name]
       end
 
+      # Returns filter object with the given name
+      def filter_by_name(name)
+        self.class.filter_by_name(name)
+      end
+
     end # InstanceMethods
 
   end

data/lib/datagrid/filters/base_filter.rb

@@ -3,10 +3,10 @@ end
 
 class Datagrid::Filters::BaseFilter
 
-  attr_accessor :grid, :options, :block, :name
+  attr_accessor :grid_class, :options, :block, :name
 
   def initialize(grid_class, name, options = {}, &block)
-    self.grid = grid_class
+    self.grid_class = grid_class
     self.name = name
     self.options = options
     self.block = block || default_filter_block
@@ -33,7 +33,7 @@ class Datagrid::Filters::BaseFilter
 
   def parse_values(value)
     if !self.multiple && value.is_a?(Array)
-      raise Datagrid::ArgumentError, "#{grid}##{name} filter can not accept Array argument. Use :multiple option."
+      raise Datagrid::ArgumentError, "#{grid_class}##{name} filter can not accept Array argument. Use :multiple option."
     end
     values = Array.wrap(value)
     values.map! do |v|
@@ -44,7 +44,7 @@ class Datagrid::Filters::BaseFilter
 
   def header
     options[:header] ||
-      I18n.translate(self.name, :scope => "datagrid.#{grid.param_name}.filters", :default => self.name.to_s.humanize)
+      I18n.translate(self.name, :scope => "datagrid.#{grid_class.param_name}.filters", :default => self.name.to_s.humanize)
   end
 
   def default

data/lib/datagrid/filters/date_filter.rb

@@ -34,7 +34,7 @@ class Datagrid::Filters::DateFilter < Datagrid::Filters::BaseFilter
   end
 
   def format(value)
-    if formats.any?
+    if formats.any? && value
       value.strftime(formats.first)
     else
       super

data/lib/datagrid/filters/enum_filter.rb

@@ -11,11 +11,13 @@ class Datagrid::Filters::EnumFilter < Datagrid::Filters::BaseFilter
   end
 
   def select(object = nil)
-    option = self.options[:select]
-    if option.respond_to?(:call)
-      option.arity == 1 ? option.call(object) : option.call
+    select = self.options[:select]
+    if select.is_a?(Symbol)
+      object.send(select)
+    elsif select.respond_to?(:call)
+      select.arity == 1 ? select.call(object) : select.call
     else
-      option
+      select
     end
   end
 

data/lib/datagrid/form_builder.rb

@@ -94,13 +94,13 @@ module Datagrid
     end
 
     def datagrid_get_attribute(attribute_or_filter)
-      attribute_or_filter.is_a?(Symbol) ?  attribute_or_filter : attribute_or_filter.name
+      Utils.string_like?(attribute_or_filter) ?  attribute_or_filter : attribute_or_filter.name
     end
 
     def datagrid_get_filter(attribute_or_filter)
-      if attribute_or_filter.is_a?(Symbol)
+      if Utils.string_like?(attribute_or_filter)
         object.class.filter_by_name(attribute_or_filter) ||
-          raise(Error, "filter #{attribute_or_filter} not found")
+          raise(Error, "Datagrid filter #{attribute_or_filter} not found")
       else
         attribute_or_filter
       end

data/lib/datagrid/helper.rb

@@ -21,8 +21,6 @@ module Datagrid
     # * <tt>:html</tt> - hash of attributes for <table> tag
     # * <tt>:order</tt> - If false do not generate ordering controlls. 
     #   Default: true.
-    # * <tt>:cycle</tt> - Used as arguments for cycle for each row. 
-    #   Default: false. Example: <tt>["odd", "even"]</tt>.
     # * <tt>:columns</tt> - Array of column names to display. 
     #   Used in case when same grid class is used in different places 
     #   and needs different columns. Default: all defined columns.
@@ -57,7 +55,7 @@ module Datagrid
       datagrid_renderer.form_for(grid, options)
     end
 
-    # Provides access to datagrid column data.
+    # Provides access to datagrid columns data.
     #
     #   <%= datagrid_row(grid, user) do |row| %>
     #     <tr>
@@ -66,7 +64,7 @@ module Datagrid
     #     </tr>
     #   <% end %>
     #
-    # Used in case you want to build datagrid table completelly manually
+    # Used in case you want to build html table completelly manually
     def datagrid_row(grid, asset, &block)
       HtmlRow.new(self, grid, asset).tap do |row|
         if block_given?

data/lib/datagrid/renderer.rb

@@ -1,7 +1,7 @@
 require "action_view"
 
 module Datagrid
-  class Renderer
+  class Renderer #:nodoc:
 
     def self.for(template)
       new(template)
@@ -16,33 +16,13 @@ module Datagrid
         column = grid.column_by_name(column)
       end
 
-      value = if column.html?
-        args = []
-        remaining_arity = column.html_block.arity
-
-        if column.data?
-          args << column.value(asset,grid)
-          remaining_arity -= 1
-        end
-
-        args << asset if remaining_arity > 0
-        args << grid if remaining_arity > 1
-
-        @template.instance_exec(*args, &column.html_block)
-      else
-        column.value(asset,grid)
-      end
+      value = column.html_value(@template, asset, grid)
 
       url = column.options[:url] && column.options[:url].call(asset)
       if url
         @template.link_to(value, url)
       else
-        case column.format
-        when :url
-          @template.link_to(column.label  ? asset.send(column.label) : I18n.t("datagrid.table.url_label", :default => "URL"), value)
-        else
-          _safe(value)
-        end
+        _safe(value)
       end
     end
 
@@ -57,10 +37,13 @@ module Datagrid
       options = args.extract_options!
       options[:html] ||= {}
       options[:html][:class] ||= "datagrid #{html_class(grid)}"
+      if options[:cycle]
+        ::Datagrid::Utils.warn_once("datagrid_table cycle option is deprecated. Use css to stylee odd/even rows instead.")
+      end
       assets = args.any? ? args.shift : grid.assets
       paginate = options[:paginate]
       if paginate
-        ::Datagrid::Utils.warn_once(":paginate option is deprecated. Looks to https://github.com/bogdan/datagrid/wiki/Frontend.")
+        ::Datagrid::Utils.warn_once(":paginate option is deprecated. Look to https://github.com/bogdan/datagrid/wiki/Frontend.")
         assets = assets.paginate(paginate)
       end
 

data/lib/datagrid/utils.rb

@@ -32,7 +32,20 @@ module Datagrid
         options
       end
 
+      def string_like?(value)
+        value.is_a?(Symbol) || value.is_a?(String)
+      end
 
+      def extract_position_from_options(array, options)
+        position = options.extract!(:before, :after)
+        if position[:before]
+          array.index {|c| c.name.to_sym == position[:before].to_sym }
+        elsif position[:after]
+          array.index {|c| c.name.to_sym == position[:after].to_sym } + 1
+        else
+          -1
+        end
+      end
     end
   end
 end

data/spec/datagrid/columns_spec.rb

@@ -17,17 +17,40 @@ describe Datagrid::Columns do
       :confirmed => false,
       :category => "first",
       :access_level => 'admin',
-      :pet => 'rottweiler'
+      :pet => 'rottweiler',
+      :shipping_date => Date.new(2013, 8, 1)
     ) }
+    let(:date) { Date.new(2013, 8, 1) }
 
     it "should have data columns without html columns" do
       subject.data_columns.size.should == subject.columns.size - 1
     end
     it "should build rows of data" do
-      subject.rows.should == [["Pop", "Star", "admin", "ROTTWEILER"]]
+      subject.rows.should == [[date, "Pop", "Star", "admin", "ROTTWEILER"]]
     end
     it  "should generate header" do
-      subject.header.should == ["Group", "Name", "Access level", "Pet"]
+      subject.header.should == ["Shipping date", "Group", "Name", "Access level", "Pet"]
+    end
+    
+    it "should return html_columns" do
+      report = test_report do
+        scope {Entry}
+        column(:id)
+        column(:name, :html => false)
+      end
+      report.html_columns.map(&:name).should == [:id]
+    end
+
+    it "should return html_columns when column definition has 2 arguments" do
+      report = test_report(:name => "Hello") do
+        scope {Entry}
+        filter(:name)
+        column(:id)
+        column(:name, :html => false) do |model, grid|
+          "'#{model.name}' filtered by '#{grid.name}'"
+        end
+      end
+      report.row_for(Entry.create!(:name => "Hello World")).should == [8, "'Hello World' filtered by 'Hello'"]
     end
 
     it "should generate table data" do
@@ -42,12 +65,13 @@ describe Datagrid::Columns do
         :group => "Pop",
         :name => "Star",
         :access_level => 'admin',
-        :pet => 'ROTTWEILER'
+        :pet => 'ROTTWEILER',
+        :shipping_date => date
       }
     end
 
     it "should support csv export" do
-      subject.to_csv.should == "Group,Name,Access level,Pet\nPop,Star,admin,ROTTWEILER\n"
+      subject.to_csv.should == "Shipping date,Group,Name,Access level,Pet\n#{date},Pop,Star,admin,ROTTWEILER\n"
     end
 
     it "should support csv export of particular columns" do
@@ -55,7 +79,7 @@ describe Datagrid::Columns do
     end
 
     it "should support csv export options" do
-      subject.to_csv(:col_sep => ";").should == "Group;Name;Access level;Pet\nPop;Star;admin;ROTTWEILER\n"
+      subject.to_csv(:col_sep => ";").should == "Shipping date;Group;Name;Access level;Pet\n#{date};Pop;Star;admin;ROTTWEILER\n"
     end
   end
 
@@ -121,4 +145,19 @@ describe Datagrid::Columns do
 
   end
 
+
+  context "when grid has formatted column" do
+    it "should output correct data" do
+      report = test_report do
+        scope {Entry}
+        column(:name) do |entry|
+          format(entry.name) do |value|
+            "<strong>#{value}</strong"
+          end
+        end
+      end
+      Entry.create!(:name => "Hello World")
+      report.rows.should == [["Hello World"]]
+    end
+  end
 end

data/spec/datagrid/core_spec.rb

@@ -1,15 +1,39 @@
 require 'spec_helper'
 
 describe Datagrid::Core do
-  
-  it "should support change scope on the fly" do
-    report = test_report do
-      scope { Entry }
+
+  context 'with 2 persisted entries' do
+    before { 2.times { Entry.create } }
+
+    let(:limit) { Entry.limit(1) }
+    let(:report_class) do
+      test_report_class do
+        scope { Entry }
+      end
     end
-    report.scope do
-      Entry.limit(1)
+
+    describe '#scope' do
+      context 'in the class' do
+        let(:report) { report_class.new }
+
+        it { expect(report.scope).to have(2).item }
+      end
+
+      context 'changes scope on the fly' do
+        let(:report) do
+          report_class.new.tap do |r|
+            r.scope { limit }
+          end
+        end
+
+        it { expect(report.scope).to have(1).item }
+      end
+
+      context 'changes scope by initializer' do
+        let(:report) { report_class.new { limit } }
+
+        it { expect(report.scope).to have(1).item }
+      end
     end
-    2.times { Entry.create }
-    report.assets.to_a.size.should == 1
   end
 end

data/spec/datagrid/filters/enum_filter_spec.rb

@@ -33,4 +33,17 @@ describe Datagrid::Filters::EnumFilter do
     end
   end
 
+
+  it "should support select given as symbol" do
+    report = test_report do 
+      scope {Entry}
+      filter(:group_id, :enum, :select => :selectable_group_ids)
+      def selectable_group_ids
+        [1,3,5]
+      end
+    end
+
+    report.filter_by_name(:group_id).select(report).should == [1,3,5]
+  end
+
 end

data/spec/datagrid/filters_spec.rb

@@ -127,6 +127,29 @@ describe Datagrid::Filters do
       end
       grid.assets.should_not be_empty
     end
-    
+
+  end
+
+  describe "positioning filter before another" do
+    it "should insert the filter before the specified element" do
+      grid = test_report do
+        scope {Entry}
+        filter(:limit)
+        filter(:name, :before => :limit)
+      end
+      grid.filters.index {|f| f.name == :name}.should == 0
+    end
+  end
+
+  describe "positioning filter after another" do
+    it "should insert the filter before the specified element" do
+      grid = test_report do
+        scope {Entry}
+        filter(:limit)
+        filter(:name)
+        filter(:group_id, :after => :limit)
+      end
+      grid.filters.index {|f| f.name == :group_id}.should == 1
+    end
   end
 end

data/spec/datagrid/form_builder_spec.rb

@@ -163,6 +163,19 @@ describe Datagrid::FormBuilder do
           '<input class="created_at date_filter to" multiple name="report[created_at][]" size="30" type="text" value="2012-01-01"/>'
         )}
       end
+      context "with blank range value" do
+        around(:each) do |example|
+          with_date_format do
+            example.run
+          end
+        end
+        let(:_range) { [nil, nil] }
+        it { should equal_to_dom(
+          '<input class="created_at date_filter from" multiple name="report[created_at][]" size="30" type="text"/>' +
+          '<span class="separator date"> - </span>' +
+          '<input class="created_at date_filter to" multiple name="report[created_at][]" size="30" type="text"/>'
+        )}
+      end
     end
     context "with enum filter type" do
       let(:_filter) { :category }
@@ -271,11 +284,21 @@ describe Datagrid::FormBuilder do
         end
       end
       let(:_filter) { :group_id }
-      it { should equal_to_dom(<<HTML) }
+      let(:expected_html) do
+        if ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR < 2
+          <<-HTML
+<select class="group_id enum_filter" id="report_group_id" multiple name="report[group_id][]">
+<option value="hello">hello</option></select>
+          HTML
+        else
+          <<-HTML
 <input name="report[group_id][]" type="hidden" value=""><select class="group_id enum_filter" id="report_group_id" multiple name="report[group_id][]">
 <option value="hello">hello</option></select>
-HTML
+          HTML
+        end
+      end
 
+      it { should equal_to_dom(expected_html) }
     end
 
     context "with column names filter" do
@@ -291,11 +314,23 @@ HTML
         end       
       end
       let(:_filter) { :column_names }
-      it { should equal_to_dom(<<HTML)}
+      let(:expected_html) do
+        if ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR < 2
+          <<-HTML
+<select class="column_names enum_filter" id="report_column_names" multiple name="report[column_names][]"><option value="id" selected>Id</option>
+<option value="name" selected>Name</option>
+<option value="category">Category</option></select>
+          HTML
+        else
+          <<-HTML
 <input name="report[column_names][]" type="hidden" value=""><select class="column_names enum_filter" id="report_column_names" multiple name="report[column_names][]"><option value="id" selected>Id</option>
 <option value="name" selected>Name</option>
 <option value="category">Category</option></select>
-HTML
+          HTML
+        end
+      end
+
+      it { should equal_to_dom(expected_html) }
     end
   end
 
@@ -318,7 +353,3 @@ HTML
     end
   end
 end
-
-
-
-

data/spec/datagrid/helper_spec.rb

@@ -7,13 +7,14 @@ require 'datagrid/renderer'
 describe Datagrid::Helper do
   subject do
     template = ActionView::Base.new
+    template.stub(:protect_against_forgery?).and_return(false)
     template.view_paths << File.expand_path("../../../app/views", __FILE__)
     template.view_paths << File.expand_path("../../support/test_partials", __FILE__)
     template
   end
 
   before(:each) do
-    subject.stub!(:params).and_return({})
+    subject.stub(:params).and_return({})
     subject.stub(:url_for) do |options|
       options.to_param
     end
@@ -95,6 +96,7 @@ describe Datagrid::Helper do
         "table.datagrid td.group" => 0
       )
     end
+
     context "with column_names attribute" do
       let(:grid) do
         test_report(:column_names => "name") do
@@ -279,6 +281,22 @@ describe Datagrid::Helper do
         )
       end
 
+      context "when grid has complicated columns" do
+        let(:grid) do
+          test_report(:name => 'Hello') do
+            scope {Entry}
+            filter(:name)
+            column(:name) do |model, grid|
+              "'#{model.name}' filtered by '#{grid.name}'"
+            end
+          end
+        end
+        it "should ignore them" do
+          subject.datagrid_rows(grid, [entry]).should match_css_pattern(
+            "td.name" => 1
+          )
+        end
+    end
     end
 
     describe ".datagrid_order_for" do
@@ -361,5 +379,16 @@ describe Datagrid::Helper do
       end
       subject.datagrid_format_value(report, :name, entry).should == "<b>Star</b>"
     end
+    it "should support format in column" do
+      report = test_report do
+        scope {Entry}
+        column(:name) do |e|
+          format(e.name) do |value|
+             link_to value, "/profile" 
+          end
+        end
+      end
+      subject.datagrid_format_value(report, :name, entry).should == "<a href=\"/profile\">Star</a>"
+    end
   end
 end

data/spec/support/simple_report.rb

@@ -1,16 +1,21 @@
 
 
 def test_report(attributes = {}, &block)
-  klass = Class.new
-  klass.class_eval do
-    include Datagrid
-  end
-  if block
-    klass.class_eval(&block)
-  end
+  klass = test_report_class(&block)
   klass.new(attributes)
 end
 
+def test_report_class(&block)
+  Class.new.tap do |klass|
+    klass.class_eval do
+      include Datagrid
+    end
+    if block
+      klass.class_eval(&block)
+    end
+  end
+end
+
 class SimpleReport
 
   include Datagrid
@@ -40,12 +45,14 @@ class SimpleReport
     render :partial => "actions", :locals => {:model => model}
   end
 
-  column(:access_level, :html => lambda {|data| content_tag :h1, data})
-
   column(:pet, :html => lambda {|data| content_tag :em, data}) do
     self.pet.try(:upcase)
   end
 
+  column(:shipping_date, :before => :group)
+
+  column(:access_level, :html => lambda {|data| content_tag :h1, data}, :after => :actions)
+
   def param_name
     :report
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datagrid
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-06 00:00:00.000000000 Z
+date: 2013-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -337,7 +337,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1228935778461264019
+      hash: 3747985271557157131
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: