magic_grid 0.11.1 → 0.12.0

data/README.md

@@ -2,6 +2,7 @@ MagicGrid
 =========
 
 [![Build Status](https://secure.travis-ci.org/rmg/magic_grid.png?branch=master)](http://travis-ci.org/rmg/magic_grid)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/rmg/magic_grid)
 
 Easy collection display grid with column sorting and pagination.
 

data/Rakefile

@@ -32,6 +32,6 @@ RSpec::Core::RakeTask.new(:spec) do |t|
 end
 
 desc "Run TestUnit and RSpec tests"
-task :tests => [:spec, :test]
+task tests: [:spec, :test]
 
-task :default => :tests
+task default: :tests

data/lib/assets/javascripts/magic_grid.js

@@ -127,8 +127,11 @@ $(function () {
         var $grid = $(this),
             listeners = $grid.data("listeners"),
             grid_id = this.id,
-            handler = function (change) {
-                if (! $("#"+change.data.field).hasClass("ready")) {
+            mark_as_ready = function () {
+                $(this).addClass("ready");
+            },
+            request_grid_if_ready = function () {
+                if (! $(this).hasClass("ready")) {
                     return;
                 }
                 var base_url = $grid.data("current").split("?", 2)[0];
@@ -143,10 +146,8 @@ $(function () {
                 }
             };
         for (var k in listeners) {
-            $("#" + k).on("change", {"field": listeners[k]}, handler);
-            $("#" + k).on("ready", function (ready) {
-                $(this).addClass("ready");
-            });
+            $("#" + k).on("change", request_grid_if_ready);
+            $("#" + k).on("ready", mark_as_ready);
         }
     });
 

data/lib/magic_grid/collection.rb

@@ -4,9 +4,20 @@ require 'magic_grid/logger'
 module MagicGrid
   class Collection
 
-    def initialize(collection, grid)
-      @collection = collection
-      @grid = grid
+    DEFAULTS = {
+      per_page: 30,
+      searchable: [],
+      search_method: :search,
+      listener_handler: nil,
+      default_col: 0,
+      default_order: :asc,
+      post_filter: false,
+      collection_post_filter: true,
+    }
+
+    def initialize(collection, opts = {})
+      @collection = collection || []
+      self.options = opts
       @current_page = 1
       @sorts = []
       @filter_callbacks = []
@@ -15,58 +26,61 @@ module MagicGrid
       @post_filters = []
       @post_filter_callbacks = []
       @paginations = []
+      @searchable_columns = []
     end
 
-    delegate :quoted_table_name, :map, :count, :to => :collection
+    delegate :quoted_table_name, :map, :count, to: :collection
 
-    attr_accessor :grid
-    attr_reader :current_page, :original_count, :total_pages
+    attr_accessor :searchable_columns
+    attr_reader :current_page, :original_count, :total_pages, :per_page, :searches
 
-    def self.[](collection, grid)
+    def options=(opts)
+      @options = DEFAULTS.merge(opts || {})
+    end
+
+    def self.create_or_reuse(collection, opts = {})
       if collection.is_a?(self)
-        collection.grid = grid
+        collection.options = opts
         collection
       else
-        Collection.new(collection, grid)
+        Collection.new(collection, opts)
       end
     end
 
     def column_names
-      @collection.table.columns.map {|c| c.name}
+      @collection.table.columns.map{|c| c[:name]}
+    rescue
+      MagicGrid.logger.debug("Given collection doesn't respond to #table well: #{$!}")
+      []
     end
 
     def quote_column_name(col)
-      @collection.connection.quote_column_name(col.to_s)
+      if col.is_a? Symbol and @collection.respond_to? :quoted_table_name
+        "#{quoted_table_name}.#{@collection.connection.quote_column_name(col.to_s)}"
+      else
+        col.to_s
+      end
+    end
+
+    def hash_string
+      if @collection.respond_to? :to_sql
+        @collection.to_sql.hash.abs.to_s(36)
+      else
+        @options.hash.abs.to_s(36)
+      end
     end
 
     def search_using_builtin(collection, q)
-      collection.__send__(@grid.options[:search_method], q)
+      collection.__send__(@options[:search_method], q)
     end
 
     def search_using_where(collection, q)
       result = collection
-      search_cols = @grid.options[:searchable].map do |searchable|
-        case searchable
-        when Symbol
-          known = @grid.columns.find {|col| col[:col] == searchable}
-          if known and known.key?(:sql)
-            known[:sql]
-          else
-            "#{@collection.table_name}.#{quote_column_name(searchable)}"
-          end
-        when Integer
-          @grid.columns[searchable][:sql]
-        when String
-          searchable
-        else
-          raise "Searchable must be identifiable"
-        end
-      end
-
-      unless search_cols.empty?
+      unless searchable_columns.empty?
         begin
+          search_cols = searchable_columns.map {|c| c.custom_sql || c.name }
           clauses = search_cols.map {|c| c << " LIKE :search" }.join(" OR ")
-          result = collection.where(clauses, {:search => "%#{q}%"})
+          result = collection.where(clauses, {search: "%#{q}%"})
         rescue
           MagicGrid.logger.debug "Given collection doesn't respond to :where well"
         end
@@ -79,25 +93,34 @@ module MagicGrid
     end
 
     def apply_sort(col, dir)
-      @reduced_collection = nil
-      @sorts << "#{col} #{dir}"
+      if sortable? and col.sortable?
+        @reduced_collection = nil
+        @sorts << "#{col.custom_sql} #{dir}"
+      end
       self
     end
 
     def searchable?
-      filterable? or @collection.respond_to? @grid.options[:search_method]
+      (filterable? and not searchable_columns.empty?) or
+        (@options[:search_method] and @collection.respond_to? @options[:search_method])
     end
 
     def apply_search(q)
-      @reduced_collection = nil
-      @searches << q
+      if q and not q.empty?
+        if searchable?
+          @reduced_collection = nil
+          @searches << q
+        else
+          MagicGrid.logger.warn "#{self.class.name}: Ignoring searchable fields on collection"
+        end
+      end
       self
     end
 
     def perform_search(collection, q)
       search_using_builtin(collection, q)
     rescue
-      MagicGrid.logger.debug "Given collection doesn't respond to #{@grid.options[:search_method]} well"
+      MagicGrid.logger.debug "Given collection doesn't respond to #{@options[:search_method]} well"
       search_using_where(collection, q)
     end
 
@@ -106,7 +129,7 @@ module MagicGrid
     end
 
     def apply_filter(filters = {})
-      if @collection.respond_to? :where
+      if filterable? and not filters.empty?
         @reduced_collection = nil
         @filters << filters
       end
@@ -121,45 +144,73 @@ module MagicGrid
       self
     end
 
+    def add_post_filter_callback(callback)
+      if callback.respond_to? :call
+        @reduced_collection = nil
+        @post_filter_callbacks << callback
+      end
+      self
+    end
+
     def has_post_filter?
       @collection.respond_to? :post_filter
     end
 
-    def apply_post_filter
+    def enable_post_filter(yes = true)
       @reduced_collection = nil
-      @post_filters << :post_filter
+      if yes and has_post_filter?
+        @post_filters << :post_filter
+      end
       self
     end
 
-    def apply_pagination(current_page, per_page)
-      if per_page
-        @reduced_collection = nil
-        @paginations << {:current_page => current_page, :per_page => per_page}
+    def count(collection = nil)
+      count_or_hash = collection || @collection
+      while count_or_hash.respond_to? :count
+        count_or_hash = count_or_hash.count
+      end
+      count_or_hash
+    end
+
+    def per_page=(n)
+      @original_count = self.count @collection
+      @per_page = n
+      if @per_page
+        @total_pages = @original_count / @per_page
+      else
+        @total_pages = 1
       end
-      self
     end
 
-    def perform_pagination(collection, current_page, per_page)
-      @original_count = @collection.count
-      @total_pages = @original_count / per_page
+    def apply_pagination(current_page)
       @current_page = current_page
+      @reduced_collection = nil
+      self
+    end
+
+    def default_paginate(collection, page, per_page)
+      collection = collection.to_enum
+      collection = collection.each_slice(@per_page)
+      collection = collection.drop(@current_page - 1)
+      collection = collection.first.to_a
+      class << collection
+        attr_accessor :current_page, :total_pages, :original_count
+      end
+      collection
+    end
+
+    def perform_pagination(collection)
+      return collection unless @per_page
+
       if collection.respond_to? :paginate
-        collection = collection.paginate(:page => current_page,
-                                           :per_page => per_page)
+        collection.paginate(page: @current_page, per_page: @per_page)
       elsif collection.respond_to? :page
-        collection = collection.page(current_page).per(per_page)
+        collection.page(@current_page).per(@per_page)
       elsif collection.is_a?(Array) and Module.const_defined?(:Kaminari)
-        collection = Kaminari.paginate_array(collection).page(current_page).per(per_page)
+         Kaminari.paginate_array(collection).page(@current_page).per(@per_page)
       else
-        collection = collection.to_enum
-        collection = collection.each_slice(per_page)
-        collection = collection.drop(current_page - 1)
-        collection = collection.first.to_a
-        class << collection
-          attr_accessor :current_page, :total_pages, :original_count
-        end
+         default_paginate(collection, @current_page, @per_page)
       end
-      collection
     end
 
     def apply_all_operations(collection)
@@ -175,23 +226,20 @@ module MagicGrid
       @searches.each do |query|
         collection = perform_search(collection, query)
       end
+      # Do collection filter first, may convert from AR to Array
       @post_filters.each do |filter|
         collection = collection.__send__(filter)
       end
       @post_filter_callbacks.each do |callback|
         collection = callback.call(collection)
       end
-      @paginations.each do |params|
-        collection = perform_pagination(collection, params[:current_page], params[:per_page])
-      end
-      collection
+      # Paginate at the very end, after all sorting, filtering, etc..
+      perform_pagination(collection)
     end
 
     def collection
       @reduced_collection ||= apply_all_operations(@collection)
     end
 
-
-
   end
 end

data/lib/magic_grid/column.rb

@@ -0,0 +1,93 @@
+module MagicGrid
+  class Column
+
+    def self.columns_for_collection(collection, columns, searchables)
+      columns.map.each_with_index { |c, i|
+        MagicGrid::Column.new(collection, c, i)
+      }.tap do |cols|
+        search_disabled = false
+        collection.searchable_columns = Array(searchables).map { |searchable|
+          case searchable
+          when Symbol
+            cols.find {|col| col.name == searchable} || FilterOnlyColumn.new(searchable, collection)
+          when Integer
+            cols[searchable]
+          when String
+            FilterOnlyColumn.new(searchable)
+          when true
+            nil
+          when false
+            search_disabled = true
+            nil
+          else
+            raise "Searchable must be identifiable: #{searchable}"
+          end
+        }.compact
+        collection.searchable_columns = [] if search_disabled
+      end
+    end
+
+    def self.hash_string(column_or_columns)
+      Array(column_or_columns).map(&:label).join.hash.abs.to_s(36)
+    end
+
+    def label
+      @col[:label]
+    end
+
+    def sortable?
+      not custom_sql.blank?
+    end
+
+    def custom_sql
+      @col[:sql]
+    end
+
+    def id
+      @col[:id]
+    end
+
+    def name
+      @col[:col]
+    end
+
+    def html_classes
+      Array(@col[:class]).join ' '
+    end
+
+    def reader
+      @col[:to_s] || @col[:col]
+    end
+
+    private
+    def initialize(collection, c, i)
+      @collection = collection
+      @col = case c
+              when Symbol
+                {col: c}
+              when String
+                {label: c}
+              else
+                c
+              end
+      @col[:id] = i
+      if @collection.column_names.include?(@col[:col])
+        @col[:sql] ||= @collection.quote_column_name(name)
+      end
+      @col[:label] ||= @col[:col].to_s.titleize
+    end
+
+  end
+
+  class FilterOnlyColumn < Column
+    attr_reader :name, :custom_sql
+    def initialize(name, collection = nil)
+      @name = name
+      if collection
+        @custom_sql = collection.quote_column_name(name)
+      else
+        @custom_sql = name
+      end
+    end
+  end
+end

data/lib/magic_grid/definition.rb

@@ -1,10 +1,12 @@
 require 'magic_grid/logger'
 require 'magic_grid/collection'
+require 'magic_grid/column'
+require 'active_support/core_ext'
 
 module MagicGrid
   class Definition
-    attr_reader :columns, :magic_id, :options, :params,
-      :current_sort_col, :current_order, :default_order, :per_page
+    attr_reader :columns, :options, :params,
+      :current_sort_col, :current_order, :default_order
 
     def magic_collection
       @collection
@@ -15,142 +17,87 @@ module MagicGrid
     end
 
     DEFAULTS = {
-      :class => [],
-      :top_pager => false,
-      :bottom_pager => true,
-      :remote => false,
-      :per_page => 30,
-      :searchable => [],
-      :search_method => :search,
-      :min_search_length => 3,
-      :id => false,
-      :searcher => false,
-      :needs_searcher => false,
-      :live_search => false,
-      :current_search => nil,
-      :listeners => {},
-      :listener_handler => nil,
-      :default_col => 0,
-      :default_order => :asc,
-      :empty_header => false,
-      :empty_footer => false,
-      :post_filter => false,
-      :collection_post_filter? => true,
-      :default_ajax_handler => true,
-      :search_button => false,
-      :searcher_size => nil,
+      class: [],
+      top_pager: false,
+      bottom_pager: true,
+      remote: false,
+      min_search_length: 3,
+      id: false,
+      searcher: false,
+      needs_searcher: false,
+      live_search: false,
+      listeners: {},
+      collapse_empty_header: false,
+      collapse_empty_footer: false,
+      default_ajax_handler: true,
+      search_button: false,
+      searcher_size: nil,
     }
 
     def self.runtime_defaults
       # run these lazily to catch any late I18n path changes
-      DEFAULTS.merge(
-        :if_empty => I18n.t("magic_grid.no_results").capitalize, # "No results found."
-        :searcher_label => I18n.t("magic_grid.search.label").capitalize + ': ', # "Search: "
-        :searcher_tooltip =>I18n.t("magic_grid.search.tooltip"), # "type.. + <return>"
-        :searcher_button =>I18n.t("magic_grid.search.button").capitalize, # "Search"
+      DEFAULTS.merge(Collection::DEFAULTS)
+              .merge(
+        if_empty:         I18n.t("magic_grid.no_results").capitalize, # "No results found."
+        searcher_label:   I18n.t("magic_grid.search.label").capitalize + ': ', # "Search: "
+        searcher_tooltip: I18n.t("magic_grid.search.tooltip"), # "type.. + <return>"
+        searcher_button:  I18n.t("magic_grid.search.button").capitalize, # "Search"
       )
     end
 
-    def initialize(cols_or_opts, collection = nil, controller = nil, opts = {})
+    def self.normalize_columns_options(cols_or_opts, opts)
       if cols_or_opts.is_a? Hash
-        @options = self.class.runtime_defaults.merge(cols_or_opts.reject {|k| k == :cols})
-        @columns = cols_or_opts.fetch(:cols, [])
+        options = runtime_defaults.merge(cols_or_opts.reject {|k| k == :cols})
+        columns = cols_or_opts.fetch(:cols, [])
       elsif cols_or_opts.is_a? Array
-        @options = self.class.runtime_defaults.merge opts
-        @columns = cols_or_opts
+        options = runtime_defaults.merge opts
+        columns = cols_or_opts
       else
-        raise "I have no idea what that is, but it's not a Hash or an Array"
+        raise "I have no idea what that is, but it's not a columns list or options hash"
       end
+      [options, columns]
+    end
+
+    def initialize(cols_or_opts, collection = nil, controller = nil, opts = {})
+      @options, @columns = *self.class.normalize_columns_options(cols_or_opts, opts)
       @default_order = @options[:default_order]
       @params = controller && controller.params || {}
-      @per_page = @options[:per_page]
-      @collection = Collection[collection, self]
-      begin
-        #if @collection.respond_to? :table
-        table_name = @collection.quoted_table_name
-        table_columns = @collection.column_names
-      rescue
-        msg = "Given collection doesn't respond to :quoted_table_name or :table well: "
-        MagicGrid.logger.debug("#{msg} - #{$!}")
-        table_name = nil
-        table_columns = @columns.each_index.to_a
-      end
-      i = 0
-      hash = []
-      @columns.map! do |c|
-        if c.is_a? Symbol
-          c = {:col => c}
-        elsif c.is_a? String
-          c = {:label => c}
-        end
-        c[:id] = i
-        i += 1
-        if c.key?(:col) and c[:col].is_a?(Symbol) and table_columns.include?(c[:col])
-          c[:sql] = "#{table_name}.#{@collection.quote_column_name(c[:col].to_s)}" unless c.key?(:sql)
-        end
-        c[:label] = c[:col].to_s.titleize if not c.key? :label
-        hash << c[:label]
-        c
-      end
-      if @options[:id]
-        @magic_id = @options[:id]
-      else
-        @magic_id = hash.join.hash.abs.to_s(36)
-        @magic_id << @collection.to_sql.hash.abs.to_s(36) if @collection.respond_to? :to_sql
-      end
-      @current_sort_col = sort_col_i = param(:col, @options[:default_col]).to_i
-      if @collection.sortable? and @columns.count > sort_col_i and @columns[sort_col_i].has_key?(:sql)
-        sort_col = @columns[sort_col_i][:sql]
-        @current_order = order(param(:order, @default_order))
-        sort_dir = order_sql(@current_order)
-        @collection.apply_sort(sort_col, sort_dir)
-      else
-        MagicGrid.logger.debug "#{self.class.name}: Ignoring sorting on non-AR collection"
-      end
 
-      if @collection.filterable? or @options[:listener_handler].respond_to?(:call)
-        if @options[:listener_handler].respond_to? :call
-          @collection.apply_filter_callback @options[:listener_handler]
-        else
-          @options[:listeners].each_pair do |key, value|
-            if @params[value] and not @params[value].to_s.empty?
-              @collection.apply_filter(value => @params[value])
-            end
-          end
-        end
-      else
-        unless @options[:listeners].empty?
-          MagicGrid.logger.warn "#{self.class.name}: Ignoring listener on dumb collection"
-          @options[:listeners] = {}
-        end
-      end
+      @collection = Collection.create_or_reuse collection, @options
 
-      @options[:searchable] = Array(@options[:searchable])
-      @options[:current_search] ||= param(:q)
-      if @collection.searchable?
-        if param(:q) and not param(:q).empty? and not @options[:searchable].empty?
-          @collection.apply_search(param(:q))
-        end
-      else
-        if not @options[:searchable].empty? or param(:q)
-          MagicGrid.logger.warn "#{self.class.name}: Ignoring searchable fields on non-AR collection"
-        end
-        @options[:searchable] = []
-      end
+      @columns = Column.columns_for_collection(@collection,
+                                               @columns,
+                                               @options[:searchable])
 
-      # Do collection filter first, may convert from AR to Array
-      if @options[:collection_post_filter?] and @collection.has_post_filter?
-        @collection.apply_post_filter
-      end
-      if @options[:post_filter] and @options[:post_filter].respond_to?(:call)
-        @collection.apply_filter_callback @options[:post_filter]
+      @current_sort_col = param(:col, @options[:default_col]).to_i
+      unless (0...@columns.count).cover? @current_sort_col
+        @current_sort_col = @options[:default_col]
       end
-      # Paginate at the very end, after all sorting, filtering, etc..
-      @collection.apply_pagination(current_page, @per_page)
+      @current_order = order(param(:order, @default_order))
+      @collection.apply_sort(@columns[@current_sort_col], order_sql(@current_order))
+
+      filter_keys = @options[:listeners].values
+      filters = @params.slice(*filter_keys).reject {|k,v| v.to_s.empty? }
+      @collection.apply_filter filters
+      @collection.apply_pagination(current_page)
+      @collection.apply_search current_search
+
+      @collection.per_page = @options[:per_page]
+      @collection.apply_filter_callback @options[:listener_handler]
+      @collection.enable_post_filter @options[:collection_post_filter]
+      @collection.add_post_filter_callback @options[:post_filter]
+    end
+
+    def current_search
+      param(:q)
+    end
+
+    def magic_id
+      @options[:id] || (Column.hash_string(@columns) + @collection.hash_string)
     end
 
     def searchable?
-      @collection.searchable? and not @options[:searchable].empty?
+      @collection.searchable?
     end
 
     def needs_searcher?
@@ -166,7 +113,7 @@ module MagicGrid
     end
 
     def param_key(key)
-      "#{@magic_id}_#{key}".to_sym
+      "#{magic_id}_#{key}".to_sym
     end
 
     def param(key, default=nil)
@@ -174,7 +121,7 @@ module MagicGrid
     end
 
     def base_params
-      @params.merge :magic_grid_id => @magic_id
+      @params.merge magic_grid_id: magic_id
     end
 
     def current_page