effective_datatables 1.8.2 → 1.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1e69441faaaf97e4d7233349e3251117d31557d
-  data.tar.gz: e3fbf33bb81f9f037ba8bb8dfbf618f97a0b96c5
+  metadata.gz: 51442e1874c5619504602bba266af6ebdd589a2a
+  data.tar.gz: 51f2e7929b20e801d9b6b30b70fd4c0c028503d6
 SHA512:
-  metadata.gz: 0719337d5baaa89aecd3abf33c4f5f85f8e31d07abf1b15b486ff10d560efedeafd191464fd06949035a611b165659b9c8216bc7c160e57ae04b7dc0c6502a82
-  data.tar.gz: 2e2e94e71e14e63c0fa12ca3c10858e2c8d2b9d907ef5ee506fed6fd8c71b4218f3287ff519e0de8db37884d33d9c8a1574b61df1fba60e79dd94b70aa9ca17d
+  metadata.gz: 06f07d33e9eaf67ea873f21650b505338e1928a31ce5138264aa5eed6cb1715b8c84c0916a2ea2c7ba0d08443e22cbd0c6acbaf4a9bcfde8cfa1bc320b09d166
+  data.tar.gz: 055b33ce39c9b1745c74f73d105f4d16134e0bdea5c1e5e7587ccda73bbfa815826499c8166a3144b2f9acc548718df71117af048bac4b56f99a042162c42e90

data/README.md

@@ -201,12 +201,46 @@ def query_total
 end
 ```
 
+### Array Backed collection
+
+Don't want to use ActiveRecord? Not a problem.
+
+Define your collection as an Array of Arrays, declare only array_columns, and everything works as expected.
+
+```ruby
+module Effective
+  module Datatables
+    class ArrayBackedDataTable < Effective::Datatable
+      array_column :id
+      array_column :first_name
+      array_column :last_name
+      array_column :email
+
+      def collection
+        [
+          [1, 'Dana', 'Janssen', 'dana@agilestyle.com'],
+          [2, 'Ashley', 'Janssen', 'ashley@agilestyle.com'],
+          [3, 'Matthew', 'Riemer', 'matthew@agilestyle.com'],
+          [4, 'Stephen', 'Brown', 'stephen@agilestyle.com'],
+          [5, 'Warren', 'Uhrich', 'warren@agilestyle.com'],
+          [6, 'Dallas', 'Meidinger', 'dallas@agilestyle.com'],
+          [7, 'Nathan', 'Feaver', 'nathan@agilestyle.com']
+        ]
+      end
+
+    end
+  end
+end
+```
+
 ## table_column
 
 This is the main DSL method that you will interact with.
 
 table_column defines a 1:1 mapping between a SQL database table column and a frontend jQuery Datatables table column.  It creates a column.
 
+table_column performs searching and sorting on the raw database records, before any results are rendered.
+
 Options may be passed to specify the display, search, sort and filter behaviour for that column.
 
 When the given name of the table_column matches an ActiveRecord attribute, the options are set intelligently based on the underlying datatype.
@@ -239,7 +273,24 @@ table_column :user_id, :if => Proc.new { attributes[:user_id].blank? }, :filter
 end
 ```
 
-All table_columns are `:visible => true`, `:sortable => true` by default.
+All table_columns are `visible: true`, `sortable: true` by default.
+
+## array_column
+
+`array_column` accepts the same options as `table_column` and behaves identically on the frontend.
+
+The difference occurs with sorting and filtering:
+
+array_columns perform searching and sorting on the computed results after all columns have been rendered.
+
+With a `table_column`, the frontend sends some search terms to the server, the raw database table is searched & sorted using standard ActiveRecord .where(), the appropriate rows returned, and then each row is rendered as per the rendering options.
+
+With an `array_column`, the front end sends some search terms to the server, all rows are returned and rendered, and then the rendered output is searched & sorted.
+
+This allows the output of an `array_column` to be anything complex that cannot be easily computed from the database.
+
+When searching & sorting with a mix of table_columns and array_columns, all the table_columns are processed first so the most work is put on the database, the least on rails.
+
 
 ### General Options
 
@@ -351,7 +402,7 @@ The request object is available to the table_column, so you could just as easily
 request.referer.include?('/admin/')
 ```
 
-### Header Rendering
+### Column Header Rendering Options
 
 You can override the default rendering and define a partial to use for the header `<th>`:
 
@@ -376,21 +427,6 @@ Quickly create multiple table_columns all with default options:
 table_columns :id, :created_at, :updated_at, :category, :title
 ```
 
-## array_column
-
-`array_column` accepts the same options as `table_column` and behaves identically on the frontend.
-
-The difference occurs with sorting and filtering:
-
-With a `table_column`, the frontend sends some search terms to the server, the raw database table is searched & sorted using standard ActiveRecord .where(), the appropriate rows returned, and then each row is rendered as per the rendering options.
-
-With an `array_column`, the front end sends some search terms to the server, all rows are returned and rendered, and then the rendered output is searched & sorted.
-
-This allows the output of an `array_column` to be anything complex that cannot be easily computed from the database.
-
-When searching & sorting with a mix of table_columns and array_columns, all the table_columns are processed first so the most work is put on the database, the least on rails.
-
-
 ## default_order
 
 Sort the table by this field and direction on start up
@@ -414,43 +450,11 @@ Valid options are `10, 25, 50, 100, 250, 1000, :all`
 
 There are a few other ways to customize the behaviour of effective_datatables
 
-### Display of an Empty Datatable
-
-How an empty datatable (0 display records) is displayed depends on how `render_datatable` is called.
-
-To render the full datatable with the default 'No data available in table' message:
-
-```haml
-= render_datatable(@datatable)
-```
-
-To skip rendering the datatable and just output a custom message:
-
-```haml
-= render_datatable(@datatable, 'There are no posts.')
-```
-
-or
-
-```haml
-= render_datatable(@datatable, :empty => 'There are no posts.')
-```
-
-To skip rendering the datatable and instead render given content:
-
-```haml
-= render_datatable(@datatable) do
-  %p There are no posts.
-  %p
-    Have a picture of a cat instead
-    = image_tag('cat.png')
-```
-
 ### Checking for Empty collection
 
-While the 'what to render when empty' situation is handled by the above syntax, you may still check whether the datatable has records to display by calling `@datatable.empty?` and `@datatable.present?`.
+Check whether the datatable has records by calling `@datatable.empty?` and `@datatable.present?`.
 
-Keep in mind, these methods look at the collection's total records, rather than the display/filtered records.
+Keep in mind, these methods look at the collection's total records, not the currently displayed/filtered records.
 
 
 ### Customize Filter Behaviour
@@ -566,37 +570,28 @@ module Effective
 end
 ```
 
-## Array Backed collection
+## Working with other effective_gems
 
-Don't want to use ActiveRecord? Not a problem.
+### Effective Obfuscation
 
-Define your collection as an Array of Arrays, declare only array_columns, and everything works as expected.
+When working with an ActiveRecord collection that implements [effective_obfuscation](https://github.com/code-and-effect/effective_obfuscation) for the ID column,
+that column's filters and sorting will be automatically configured.
 
-```ruby
-module Effective
-  module Datatables
-    class ArrayBackedDataTable < Effective::Datatable
-      array_column :id
-      array_column :first_name
-      array_column :last_name
-      array_column :email
+Just define `table_column :id`.
 
-      def collection
-        [
-          [1, 'Dana', 'Janssen', 'dana@agilestyle.com'],
-          [2, 'Ashley', 'Janssen', 'ashley@agilestyle.com'],
-          [3, 'Matthew', 'Riemer', 'matthew@agilestyle.com'],
-          [4, 'Stephen', 'Brown', 'stephen@agilestyle.com'],
-          [5, 'Warren', 'Uhrich', 'warren@agilestyle.com'],
-          [6, 'Dallas', 'Meidinger', 'dallas@agilestyle.com'],
-          [7, 'Nathan', 'Feaver', 'nathan@agilestyle.com']
-        ]
-      end
+Unfortunately, due to the effective_obfuscation algorithm, sorting and filtering by partial values is not supported.
+
+So the column may not be sorted, and may only be filtered by typing the entire 10-digit number, with or without any formatting.
+
+### Effective Roles
+
+When working with an ActiveRecord collection that implements [effective_roles](https://github.com/code-and-effect/effective_roles),
+the filters and sorting will be automatically configured.
+
+Just define `table_column :roles`.
+
+The `EffectiveRoles.roles` collection will be used for the filter values, and sorting will be done by roles_mask.
 
-    end
-  end
-end
-```
 
 ## Get access to the raw results
 

data/app/models/effective/active_record_datatable_tool.rb

@@ -42,9 +42,9 @@ module Effective
       case table_column[:type]
       when :string, :text
         if table_column[:filter][:type] == :select && table_column[:filter][:fuzzy] != true
-          collection.where("#{column} = :term", :term => term)
+          collection.where("#{column} = :term", term: term)
         else
-          collection.where("#{column} ILIKE :term", :term => "%#{term}%")
+          collection.where("#{column} ILIKE :term", term: "%#{term}%")
         end
       when :datetime
         begin
@@ -68,22 +68,24 @@ module Effective
             end_at = start_at
           end
 
-          collection.where("#{column} >= :start_at AND #{column} <= :end_at", :start_at => start_at, :end_at => end_at)
+          collection.where("#{column} >= :start_at AND #{column} <= :end_at", start_at: start_at, end_at: end_at)
         rescue => e
           collection
         end
       when :obfuscated_id
         if (deobfuscated_id = collection.deobfuscate(term)) == term # We weren't able to deobfuscate it, so this is an Invalid ID
-          collection.where("#{column} = :term", :term => 0)
+          collection.where("#{column} = :term", term: 0)
         else
-          collection.where("#{column} = :term", :term => deobfuscated_id)
+          collection.where("#{column} = :term", term: deobfuscated_id)
         end
+      when :effective_roles
+        collection.with_role(term)
       when :integer
-        collection.where("#{column} = :term", :term => term.to_i)
+        collection.where("#{column} = :term", term: term.to_i)
       when :year
-        collection.where("EXTRACT(YEAR FROM #{column}) = :term", :term => term.to_i)
+        collection.where("EXTRACT(YEAR FROM #{column}) = :term", term: term.to_i)
       else
-        collection.where("#{column} = :term", :term => term)
+        collection.where("#{column} = :term", term: term)
       end
     end
 

data/app/models/effective/datatable.rb

@@ -355,6 +355,8 @@ module Effective
             val = (obj.send(name) rescue nil).to_s
           elsif opts[:type] == :obfuscated_id
             (obj.send(:to_param) rescue nil).to_s
+          elsif opts[:type] == :effective_roles
+            (obj.send(:roles) rescue []).join(', ')
           else
             val = (obj.send(name) rescue nil)
             val = (obj[opts[:array_index]] rescue nil) if val == nil
@@ -365,9 +367,7 @@ module Effective
           case value
           when Date
             value.strftime(EffectiveDatatables.date_format)
-          when Time
-            value.strftime(EffectiveDatatables.datetime_format)
-          when DateTime
+          when Time, DateTime
             value.strftime(EffectiveDatatables.datetime_format)
           else
             value.to_s
@@ -429,7 +429,7 @@ module Effective
       cols.each_with_index do |(name, _), index|
         # If this is a belongs_to, add an :if clause specifying a collection scope if
         if belong_tos.key?(name)
-          cols[name][:if] ||= Proc.new { attributes[belong_tos[name][:foreign_key]].blank? } # :if => Proc.new { attributes[:user_id].blank? }
+          cols[name][:if] ||= Proc.new { attributes[belong_tos[name][:foreign_key]].blank? }
         end
 
         sql_column = (collection.columns rescue []).find do |column|
@@ -443,14 +443,22 @@ module Effective
         cols[name][:column] ||= (sql_table && sql_column) ? "\"#{sql_table.name}\".\"#{sql_column.name}\"" : name
         cols[name][:width] ||= nil
         cols[name][:sortable] = true if cols[name][:sortable] == nil
-        cols[name][:type] ||= (belong_tos.key?(name) ? :belongs_to : (sql_column.try(:type).presence || :string))
+        cols[name][:type] ||= (belong_tos.key?(name) ? :belongs_to : sql_column.try(:type).presence) || :string
         cols[name][:class] = "col-#{cols[name][:type]} col-#{name} #{cols[name][:class]}".strip
 
-        if name == 'id' && collection.respond_to?(:deobfuscate)
+        # EffectiveObfuscation
+        if name == 'id' && defined?(EffectiveObfuscation) && collection.respond_to?(:deobfuscate)
           cols[name][:sortable] = false
           cols[name][:type] = :obfuscated_id
         end
 
+        # EffectiveRoles, if you do table_column :roles, everything just works
+        if name == 'roles' && defined?(EffectiveRoles) && collection.respond_to?(:with_role)
+          cols[name][:sortable] = true
+          cols[name][:column] = sql_table.present? ? "\"#{sql_table.name}\".\"roles_mask\"" : name
+          cols[name][:type] = :effective_roles
+        end
+
         if sql_table.present? && sql_column.blank? # This is a SELECT AS column
           cols[name][:sql_as_column] = true
         end
@@ -464,38 +472,29 @@ module Effective
     end
 
     def initialize_table_column_filter(filter, col_type, belongs_to)
-      return {:type => :null} if filter == false
-
-      if filter.kind_of?(Symbol)
-        filter = HashWithIndifferentAccess.new(:type => filter)
-      elsif filter.kind_of?(String)
-        filter = HashWithIndifferentAccess.new(:type => filter.to_sym)
-      elsif filter.kind_of?(Hash) == false
-        filter = HashWithIndifferentAccess.new()
-      end
+      return {type: :null} if filter == false
+
+      filter = {type: filter.to_sym} if filter.kind_of?(String)
+      filter = {} unless filter.kind_of?(Hash)
 
       # This is a fix for passing filter[:selected] == false, it needs to be 'false'
       filter[:selected] = filter[:selected].to_s unless filter[:selected].nil?
 
-      filter = case col_type
+      case col_type
       when :belongs_to
-        HashWithIndifferentAccess.new(
-          :type => :select,
-          :values => Proc.new { belongs_to[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[1] <=> y[1] } }
-        ).merge(filter)
+        {
+          type: :select,
+          values: Proc.new { belongs_to[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[1] <=> y[1] } }
+        }
+      when :effective_roles
+        {type: :select, values: EffectiveRoles.roles}
       when :integer
-        HashWithIndifferentAccess.new(:type => :number).merge(filter)
+        {type: :number}
       when :boolean
-        HashWithIndifferentAccess.new(:type => :boolean, :values => [true, false]).merge(filter)
+        {type: :boolean, values: [true, false]}
       else
-        HashWithIndifferentAccess.new(:type => :string).merge(filter)
-      end
-
-      if filter[:type] == :boolean
-        filter = HashWithIndifferentAccess.new(:values => [true, false]).merge(filter)
-      end
-
-      filter
+        {type: :string}
+      end.merge(filter.symbolize_keys)
     end
 
   end

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '1.8.2'.freeze
+  VERSION = '1.8.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 1.8.2
+  version: 1.8.3
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-30 00:00:00.000000000 Z
+date: 2015-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails