datagrid 1.4.4 → 1.5.0

data/lib/datagrid/drivers/sequel.rb

@@ -90,6 +90,15 @@ module Datagrid
         end
       end
 
+      def default_preload(scope, value)
+        scope.eager(value)
+      end
+
+      def can_preload?(scope, association)
+        !! scope.model.association_reflection(association)
+      end
+
+
       protected
 
       def prefix_table_name(scope, field)

data/lib/datagrid/filters.rb

@@ -31,14 +31,17 @@ module Datagrid
       :dynamic => Filters::DynamicFilter
     }
 
+    class DefaultFilterScope
+    end
+
     def self.included(base) #:nodoc:
       base.extend         ClassMethods
       base.class_eval do
 
         include Datagrid::Core
         include Datagrid::Filters::CompositeFilters
-        class_attribute :filters
-        self.filters = []
+        class_attribute :filters_array
+        self.filters_array = []
 
       end
       base.send :include, InstanceMethods
@@ -80,6 +83,10 @@ module Datagrid
       #   by adding it after the filter passed here (when using datagrid_form_for helper)
       # * <tt>:dummy</tt> - if true, this filter will not be applied automatically
       #   and will be just displayed in form. In case you may want to apply it manually.
+      # * <tt>:if</tt> - specify the condition when the filter can be dislayed and used.
+      #   Accepts a block or a symbol with an instance method name
+      # * <tt>:unless</tt> - specify the reverse condition when the filter can be dislayed and used.
+      #   Accepts a block or a symbol with an instance method name
       #
       # See: https://github.com/bogdan/datagrid/wiki/Filters for examples
       def filter(name, type = :default, options = {}, &block)
@@ -91,9 +98,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)
+        position = Datagrid::Utils.extract_position_from_options(filters_array, options)
         filter = klass.new(self, name, options, &block)
-        self.filters.insert(position, filter)
+        filters_array.insert(position, filter)
 
         datagrid_attribute(name) do |value|
           filter.parse_values(value)
@@ -101,20 +108,38 @@ module Datagrid
 
       end
 
+      def default_filter
+        DefaultFilterScope.new
+      end
+
+      def inspect
+        "#{super}(#{filters_inspection})"
+      end
+
+      def filters
+        filters_array
+      end
+
       protected
 
       def inherited(child_class)
         super(child_class)
-        child_class.filters = self.filters.clone
+        child_class.filters_array = self.filters_array.clone
       end
 
+      def filters_inspection
+        return "no filters" if filters.empty?
+        filters.map do |filter|
+          "#{filter.name}: #{filter.type}"
+        end.join(", ")
+      end
     end # ClassMethods
 
     module InstanceMethods
 
       def initialize(*args, &block) # :nodoc:
-        self.filters = self.class.filters.clone
-        self.filters.each do |filter|
+        self.filters_array = self.class.filters_array.clone
+        filters.each do |filter|
           self[filter.name] = filter.default(self)
         end
         super(*args, &block)
@@ -133,7 +158,7 @@ module Datagrid
       def filter_value_as_string(name)
         filter = filter_by_name(name)
         value = filter_value(filter)
-        if value.is_a?(Array) 
+        if value.is_a?(Array)
           value.map {|v| filter.format(v) }.join(filter.separator)
         else
           filter.format(value)
@@ -161,6 +186,17 @@ module Datagrid
         filter.select(self)
       end
 
+      def default_filter
+        self.class.default_filter
+      end
+
+      # Returns all currently enabled filters
+      def filters
+        self.class.filters.select do |filter|
+          filter.enabled?(self)
+        end
+      end
+
       protected
 
       def apply_filters(current_scope, filters)

data/lib/datagrid/filters/base_filter.rb

@@ -24,10 +24,15 @@ class Datagrid::Filters::BaseFilter #:nodoc:
     return scope if unapplicable_value?(value)
 
     result = execute(value, scope, grid_object)
+
     return scope unless result
+    if result.is_a?(Datagrid::Filters::DefaultFilterScope)
+      result = default_filter(value, scope, grid_object)
+    end
     unless grid_object.driver.match?(result)
       raise Datagrid::FilteringError, "Can not apply #{name.inspect} filter: result #{result.inspect} no longer match #{grid_object.driver.class}."
     end
+
     result
   end
 
@@ -49,7 +54,7 @@ class Datagrid::Filters::BaseFilter #:nodoc:
   end
 
   def header
-    if header = options[:header] 
+    if header = options[:header]
       callable(header)
     else
       Datagrid::Utils.translate_from_namespace(:filters, grid_class, name)
@@ -68,7 +73,7 @@ class Datagrid::Filters::BaseFilter #:nodoc:
         Datagrid::Utils.warn_once(":default as a Symbol is now treated as a method name. Use String instead or -> { default } if you really want default value to be a Symbol but not a String.")
         default
       end
-    elsif default.respond_to?(:call) 
+    elsif default.respond_to?(:call)
       Datagrid::Utils.apply_args(object, &default)
     else
       default
@@ -128,6 +133,10 @@ class Datagrid::Filters::BaseFilter #:nodoc:
     raise "wtf is #{inspect}"
   end
 
+  def enabled?(grid)
+    ::Datagrid::Utils.process_availability(grid, options[:if], options[:unless])
+  end
+
   protected
 
   def default_filter_where(scope, value)

data/lib/datagrid/filters/ranged_filter.rb

@@ -1,5 +1,5 @@
 module Datagrid::Filters::RangedFilter
-  
+
 
   def initialize(grid, name, options, &block)
     super(grid, name, options, &block)
@@ -23,6 +23,8 @@ module Datagrid::Filters::RangedFilter
       if result.first && result.last && result.first > result.last
         # If wrong range is given - reverse it to be always valid
         result.reverse
+      elsif !result.first && !result.last
+        nil
       else
         result
       end
@@ -46,7 +48,7 @@ module Datagrid::Filters::RangedFilter
         scope = driver.less_equal(scope, name, right)
       end
       scope
-    else 
+    else
       super(scope, value)
     end
   end

data/lib/datagrid/helper.rb

@@ -55,7 +55,8 @@ module Datagrid
     end
 
 
-    # Renders HTML table rows using given grid definition using columns defined in it
+    # Renders HTML table rows using given grid definition using columns defined in it.
+    # Allows to provide a custom layout for each for in place with a block
     #
     # Supported options:
     #
@@ -64,8 +65,15 @@ module Datagrid
     #   and needs different columns. Default: all defined columns.
     # * <tt>:partials</tt> - Path for partials lookup.
     #   Default: 'datagrid'.
-    def datagrid_rows(grid, assets, options = {})
-      datagrid_renderer.rows(grid, assets, options)
+    #
+    #   = datagrid_rows(grid) # Generic table rows Layout
+    #
+    #   = datagrid_rows(grid) do |row| # Custom Layout
+    #     %tr
+    #       %td= row.project_name
+    #       %td.project-status{class: row.status}= row.status
+    def datagrid_rows(grid, assets = grid.assets, **options, &block)
+      datagrid_renderer.rows(grid, assets, options, &block)
     end
 
     # Renders ordering controls for the given column name
@@ -116,6 +124,8 @@ module Datagrid
     #   row.asset      # => User object
     class HtmlRow
 
+      include Enumerable
+
       attr_reader :grid, :asset
 
       def initialize(context, grid, asset) # :nodoc:
@@ -124,9 +134,22 @@ module Datagrid
         @asset = asset
       end
 
+      # Return a column value for given column name
+      def get(column)
+        @context.datagrid_value(@grid, column, @asset)
+      end
+
+      # Iterates over all column values that are available in the row
+      def each
+        @grid.columns.each do |column|
+          yield(get(column))
+        end
+      end
+
+      protected
       def method_missing(method, *args, &blk)
         if column = @grid.column_by_name(method)
-          @context.datagrid_value(@grid, column, @asset)
+          get(column)
         else
           super
         end

data/lib/datagrid/ordering.rb

@@ -44,7 +44,7 @@ module Datagrid
       end
 
       # Returns a column definition that is currently used to order assets
-      # 
+      #
       #   class MyGrid
       #     scope { Model }
       #     column(:id)
@@ -87,11 +87,11 @@ module Datagrid
       def check_order_valid!
         return unless order
         column = column_by_name(order)
-        unless column 
+        unless column
           self.class.order_unsupported(order, "no column #{order} in #{self.class}")
         end
         unless column.supports_order?
-          self.class.order_unsupported(column.name, "column don't support order" ) 
+          self.class.order_unsupported(column.name, "column don't support order" )
         end
       end
 
@@ -99,7 +99,7 @@ module Datagrid
         if order.respond_to?(:call)
           apply_block_order(assets, order)
         else
-          driver.asc(assets, order) 
+          driver.asc(assets, order)
         end
       end
 
@@ -118,7 +118,7 @@ module Datagrid
       end
 
       def apply_block_order(assets, order)
-        case order.arity 
+        case order.arity
         when -1, 0
           assets.instance_eval(&order)
         when 1

data/lib/datagrid/renderer.rb

@@ -55,15 +55,19 @@ module Datagrid
                       { :grid => grid, :options => options })
     end
 
-    def rows(grid, assets, options = {})
+    def rows(grid, assets = grid.assets, **options, &block)
       result = assets.map do |asset|
-        _render_partial(
-          'row', options[:partials],
-          {
+        if block_given?
+          @template.capture do
+            yield(Datagrid::Helper::HtmlRow.new(@template, grid, asset))
+          end
+        else
+          _render_partial( 'row', options[:partials], {
             :grid => grid,
             :options => options,
             :asset => asset
           })
+        end
       end.to_a.join
 
       _safe(result)

data/lib/datagrid/utils.rb

@@ -127,6 +127,24 @@ module Datagrid
         end
       end
 
+      def process_availability(grid, if_option, unless_option)
+        property_availability(grid, if_option, true) &&
+          !property_availability(grid, unless_option, false)
+      end
+
+      protected
+      def property_availability(grid, option, default)
+        case option
+        when nil
+          default
+        when Proc
+          option.call(grid)
+        when Symbol, String
+          grid.send(option.to_sym)
+        else
+          raise Datagrid::ConfigurationError, "Incorrect column availability option: #{option.insepct}"
+        end
+      end
     end
   end
 end

data/spec/datagrid/columns_spec.rb

@@ -562,4 +562,49 @@ describe Datagrid::Columns do
       expect(grid.rows).to eq([['Hello']])
     end
   end
+
+  describe "column scope" do
+    it "appends preload as non block" do
+      grid = test_report do
+        scope { Entry }
+        column(:id, preload: [:group])
+      end
+      expect(grid.assets.preload_values).to_not be_blank
+    end
+
+    it "appends preload with no args" do
+      grid = test_report do
+        scope { Entry }
+        column(:id, preload: -> { order(:id) })
+      end
+      expect(grid.assets.order_values).to_not be_blank
+    end
+
+    it "appends preload with arg" do
+      grid = test_report do
+        scope { Entry }
+        column(:id, preload: ->(a) { a.order(:id) })
+      end
+      expect(grid.assets.order_values).to_not be_blank
+    end
+
+    it "appends preload as true value" do
+      grid = test_report do
+        scope { Entry }
+        column(:group, preload: true)
+      end
+      expect(grid.assets.preload_values).to eq([:group])
+    end
+
+    it "doesn't append preload when column is invisible" do
+      grid = test_report do
+        scope { Entry }
+        column(:id1, preload: ->(a) { a.order(:id) })
+        column(:id2, preload: ->(a) { a.order(:id) }, if: ->(a) { false })
+        column(:name)
+      end
+      grid.column_names = [:name]
+      expect(grid.assets.order_values).to be_blank
+    end
+  end
 end

data/spec/datagrid/core_spec.rb

@@ -6,9 +6,11 @@ describe Datagrid::Core do
     before { 2.times { Entry.create } }
 
     let(:report_class) do
-      test_report_class do
+      class ScopeTestReport
+        include Datagrid
         scope { Entry.order("id desc") }
       end
+      ScopeTestReport
     end
 
     describe '#scope' do
@@ -16,6 +18,22 @@ describe Datagrid::Core do
         let(:report) { report_class.new }
 
         it { expect(report.scope.to_a.size).to eq(2) }
+        it { expect(report).to_not be_redefined_scope }
+
+        context "when redefined" do
+          it "should accept previous scope" do
+            module Ns83827
+              class TestGrid < ScopeTestReport
+                scope do |previous|
+                  previous.reorder("id asc")
+                end
+              end
+            end
+
+            expect(Ns83827::TestGrid.new.assets.order_values).to eq(["id asc"])
+          end
+        end
+
       end
 
       context 'changes scope on the fly' do
@@ -26,11 +44,13 @@ describe Datagrid::Core do
         end
 
         it { expect(report.scope.to_a.size).to eq(1) }
+        it { expect(report).to be_redefined_scope }
       end
 
       context 'overriding scope by initializer' do
         let(:report) { report_class.new { Entry.limit(1) } }
 
+        it { expect(report).to be_redefined_scope }
         it { expect(report.scope.to_a.size).to eq(1) }
 
         context "reset scope to default" do
@@ -38,6 +58,7 @@ describe Datagrid::Core do
             report.reset_scope
           end
           it { expect(report.scope.to_a.size).to eq(2) }
+          it { expect(report).to_not be_redefined_scope }
         end
       end
 
@@ -45,6 +66,7 @@ describe Datagrid::Core do
         let(:report) { report_class.new {|scope| scope.limit(1)} }
         it { expect(report.scope.to_a.size).to eq(1) }
         it { expect(report.scope.order_values.size).to eq(1) }
+        it { expect(report).to be_redefined_scope }
       end
     end
   end