magic_grid 0.12.4 → 0.12.5

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2012 Ryan Graham, Dennis Taylor
+Copyright 2012-2013 Ryan Graham, Dennis Taylor
 Copyright 2011 Ryan Graham
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.md

@@ -1,11 +1,14 @@
 MagicGrid
 =========
+© 2011-2013 Ryan Graham, Dennis Taylor
 
-[![Build Status](https://secure.travis-ci.org/rmg/magic_grid.png?branch=master)](http://travis-ci.org/rmg/magic_grid)
+[![Build Status](https://travis-ci.org/rmg/magic_grid.png?branch=master)](https://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.
 
+[MagicGrid Live Demo](http://magic-grid.herokuapp.com/) (it's not very pretty. [Help?](https://github.com/rmg/magic_grid-demo))
+
 Displays a collection (ActiveRelation or Array) wrapped in an html table with server
 side column sorting, filtering hooks, and search bar. Large collections can be
 paginated with either the will_paginate gem or kaminari gem if you use them, or a naive
@@ -21,11 +24,18 @@ In your `Gemfile`:
 
     gem 'magic_grid'
 
+In your controller:
+
+    @posts = Post.where(:published => true)
+
 In your view:
 
     <%= magic_grid(@posts, [:title, :author]) %>
 
-Or a more realistic example:
+What you'll get is an table with 2 sortable columns. You'll also get pagination if
+you have eitehr Keminari or WillPaginate loaded.
+
+You can also do your own row rendering by passing a block:
 
 ```rhtml
 <%= magic_grid(@posts, [:title, :author, "Actions"]) do |post| %>
@@ -41,6 +51,19 @@ Or a more realistic example:
 <% end %>
 ```
 
+Advanced Options
+----------------
+
+There are a bunch of extra options that can be passed to the `magic_grid` helper:
+
+### :searchable
+An array of columns to try to generate a search query for. Providing this
+list tells magic_grid to render a search box in the header of the html table
+it generates. Make sure to include `magic_grid.js` in your view or application wide via your application.js or search won't work.
+
+### :per_page
+Sets the number of rows per page in the paginator.
+
 Development
 -----------
 
@@ -49,3 +72,7 @@ bunch of random page renderings. I've since added some RSpec goodness.
 
 To run all the tests, just run `rake`.
 
+License
+-------
+
+Distributed under the MIT license. See [MIT-LICENSE](MIT-LICENSE) for detail.

data/Rakefile

@@ -34,4 +34,4 @@ end
 desc "Run TestUnit and RSpec tests"
 task :tests => [:spec, :test]
 
-task :default => :tests
+task :default => :spec

data/lib/magic_grid/collection.rb

@@ -5,20 +5,19 @@ module MagicGrid
   class Collection
 
     DEFAULTS = {
-      :per_page => 30,
-      :searchable => [],
-      :search_method => :search,
-      :listener_handler => nil,
-      :default_col => 0,
-      :default_order => :asc,
-      :post_filter => false,
+      :per_page               => 30,
+      :searchable             => [],
+      :search_method          => :search,
+      :listener_handler       => nil,
+      :default_col            => 0,
+      :post_filter            => false,
       :collection_post_filter => true,
-      :count => nil,
+      :count                  => nil,
     }
 
     def initialize(collection, opts = {})
       @collection = collection || []
-      self.options = opts
+      @options = opts
       @current_page = 1
       @sorts = []
       @filter_callbacks = []
@@ -34,15 +33,17 @@ module MagicGrid
     delegate :quoted_table_name, :map, :count, :to => :collection
 
     attr_accessor :searchable_columns
-    attr_reader :current_page, :original_count, :total_pages, :per_page, :searches
+    attr_reader :current_page, :original_count, :total_pages, :per_page,
+                :searches
+    attr_writer :options
     cattr_accessor :kaminari_class
 
-    def options=(opts)
-      @options = DEFAULTS.merge(opts || {})
+    def options
+      DEFAULTS.merge(@options || {})
     end
 
     def count_options
-      @options[:count]
+      options[:count]
     end
 
     def self.create_or_reuse(collection, opts = {})
@@ -73,12 +74,12 @@ module MagicGrid
       if @collection.respond_to? :to_sql
         @collection.to_sql.hash.abs.to_s(36)
       else
-        @options.hash.abs.to_s(36)
+        options.hash.abs.to_s(36)
       end
     end
 
     def search_using_builtin(collection, q)
-      collection.__send__(@options[:search_method], q)
+      collection.__send__(options[:search_method], q)
     end
 
     def search_using_where(collection, q)
@@ -104,12 +105,12 @@ module MagicGrid
         @reduced_collection = nil
         @sorts << "#{col.custom_sql} #{dir}"
       end
-      self
     end
 
     def searchable?
       (filterable? and not searchable_columns.empty?) or
-        (@options[:search_method] and @collection.respond_to? @options[:search_method])
+        (options[:search_method] and
+         @collection.respond_to? options[:search_method])
     end
 
     def apply_search(q)
@@ -121,13 +122,12 @@ module MagicGrid
           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 #{@options[:search_method]} well"
+      MagicGrid.logger.debug "Given collection doesn't respond to #{options[:search_method]} well"
       search_using_where(collection, q)
     end
 
@@ -140,7 +140,6 @@ module MagicGrid
         @reduced_collection = nil
         @filters << filters
       end
-      self
     end
 
     def apply_filter_callback(callback)
@@ -148,7 +147,6 @@ module MagicGrid
         @reduced_collection = nil
         @filter_callbacks << callback
       end
-      self
     end
 
     def add_post_filter_callback(callback)
@@ -156,7 +154,6 @@ module MagicGrid
         @reduced_collection = nil
         @post_filter_callbacks << callback
       end
-      self
     end
 
     def has_post_filter?
@@ -192,7 +189,6 @@ module MagicGrid
     def apply_pagination(current_page)
       @current_page = current_page
       @reduced_collection = nil
-      self
     end
 
     def default_paginate(collection, page, per_page)
@@ -221,7 +217,8 @@ module MagicGrid
       elsif collection.respond_to? :page
         collection.page(@current_page).per(@per_page)
       elsif collection.is_a?(Array) and @@kaminari_class
-         @@kaminari_class.paginate_array(collection).page(@current_page).per(@per_page)
+         @@kaminari_class.paginate_array(collection).
+                          page(@current_page).per(@per_page)
       else
          default_paginate(collection, @current_page, @per_page)
       end

data/lib/magic_grid/column.rb

@@ -1,5 +1,8 @@
+require 'magic_grid/order'
+
 module MagicGrid
   class Column
+    attr_accessor :order
 
     def self.columns_for_collection(collection, columns, searchables)
       columns.each_with_index.map { |c, i|
@@ -56,7 +59,8 @@ module MagicGrid
     end
 
     def html_classes
-      Array(@col[:class]).join ' '
+      @html_classes ||= (Array(@col[:class]) << order.css_class)
+      @html_classes.join(' ')
     end
 
     def reader
@@ -66,7 +70,7 @@ module MagicGrid
     private
     def initialize(collection, c, i)
       @collection = collection
-      @col = case c
+      @col =  case c
               when Symbol
                 {:col => c}
               when String
@@ -86,6 +90,7 @@ module MagicGrid
   class FilterOnlyColumn < Column
     attr_reader :name, :custom_sql
     def initialize(name, collection = nil)
+      @order = Order::Unordered
       @name = name
       if collection
         @custom_sql = collection.quote_column_name(name)

data/lib/magic_grid/definition.rb

@@ -1,12 +1,12 @@
 require 'magic_grid/logger'
 require 'magic_grid/collection'
 require 'magic_grid/column'
+require 'magic_grid/order'
 require 'active_support/core_ext'
 
 module MagicGrid
   class Definition
-    attr_reader :columns, :options, :params,
-      :current_sort_col, :current_order, :default_order
+    attr_reader :columns, :options, :params
 
     def magic_collection
       @collection
@@ -17,38 +17,41 @@ module MagicGrid
     end
 
     DEFAULTS = {
-      :class => [],
-      :top_pager => false,
-      :bottom_pager => true,
-      :remote => false,
-      :min_search_length => 3,
-      :id => false,
-      :searcher => false,
-      :needs_searcher => false,
-      :live_search => false,
-      :listeners => {},
+      :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,
+      :default_ajax_handler  => true,
+      :default_order         => :asc,
+      :search_button         => false,
+      :searcher_size         => nil,
+      :title                 => nil,
     }
 
     def self.runtime_defaults
       # run these lazily to catch any late I18n path changes
       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: "
+        :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"
+        :searcher_button  => I18n.t("magic_grid.search.button").capitalize # "Search"
       )
     end
 
     def self.normalize_columns_options(cols_or_opts, opts)
-      if cols_or_opts.is_a? Hash
+      case cols_or_opts
+      when Hash
         options = runtime_defaults.merge(cols_or_opts.reject {|k| k == :cols})
         columns = cols_or_opts.fetch(:cols, [])
-      elsif cols_or_opts.is_a? Array
+      when Array
         options = runtime_defaults.merge opts
         columns = cols_or_opts
       else
@@ -59,87 +62,113 @@ module MagicGrid
 
     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 || {}
 
-      @collection = Collection.create_or_reuse collection, @options
+      @collection = Collection.create_or_reuse collection, options
+
+      @columns = Column.columns_for_collection(magic_collection,
+                                               columns,
+                                               options[:searchable])
+      columns.each do |col|
+        if col.sortable?
+          if col.id == current_sort_col
+            col.order = current_order
+          else
+            col.order = Order::Unordered
+          end
+        else
+          col.order = Order::Unsortable
+        end
+      end
+
+      apply_collection_params
+    end
 
-      @columns = Column.columns_for_collection(@collection,
-                                               @columns,
-                                               @options[:searchable])
+    def apply_collection_params
+      magic_collection.apply_sort(columns[current_sort_col], current_order.to_sql)
+
+      magic_collection.apply_filter filters
+      magic_collection.apply_pagination(current_page)
+      magic_collection.apply_search current_search
+
+      magic_collection.per_page = options[:per_page]
+      magic_collection.apply_filter_callback options[:listener_handler]
+      magic_collection.enable_post_filter options[:collection_post_filter]
+      magic_collection.add_post_filter_callback options[:post_filter]
+    end
 
-      @current_sort_col = param(:col, @options[:default_col]).to_i
-      unless (0...@columns.count).cover? @current_sort_col
-        @current_sort_col = @options[:default_col]
+    def filters
+      @filters ||= begin
+        filter_keys = options[:listeners].values
+        params.slice(*filter_keys).reject {|k,v| v.to_s.empty? }
       end
-      @current_order = order(param(:order, @default_order))
-      @collection.apply_sort(@columns[@current_sort_col], order_sql(@current_order))
+    end
 
-      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
+    def current_sort_col
+      @current_sort_col ||= begin
+        given = param(:col, -1)
+        if given >= 0 and given <= columns.count
+          given
+        else
+          options[:default_col].to_i
+        end
+      end
+    end
+
+    def default_order
+      @default_order ||= Order.from_param(options[:default_order])
+    end
 
-      @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]
+    def current_order
+      @current_order ||= Order.from_param(param(:order, default_order.to_param))
     end
 
     def current_search
-      param(:q)
+      param(:q, "")
     end
 
     def magic_id
-      @options[:id] || (Column.hash_string(@columns) + @collection.hash_string)
+      options[:id] || (Column.hash_string(columns) + magic_collection.hash_string)
     end
 
     def searchable?
-      @collection.searchable?
+      magic_collection.searchable?
     end
 
     def needs_searcher?
-      @options[:needs_searcher] or (searchable? and not @options[:searcher])
+      options[:needs_searcher] or (searchable? and not options[:searcher])
     end
 
     def searcher
       if needs_searcher?
         param_key(:searcher)
       else
-        @options[:searcher]
+        options[:searcher]
       end
     end
 
+    def has_title?
+      options[:title] || false
+    end
+
+    def title
+      options[:title]
+    end
+
     def param_key(key)
       "#{magic_id}_#{key}".to_sym
     end
 
     def param(key, default=nil)
-      @params.fetch(param_key(key), default)
+      params.fetch(param_key(key), default)
     end
 
     def base_params
-      @params.merge :magic_grid_id => magic_id
+      params.merge :magic_grid_id => magic_id
     end
 
     def current_page
       [param(:page, 1).to_i, 1].max
     end
-
-    def order(something)
-      case something
-      when 1, "1", :desc, :DESC, "desc", "DESC"
-        1
-      #when 0, "0", :asc, :ASC, "asc", "ASC"
-      #  0
-      else
-        0
-      end
-    end
-
-    def order_sql(something)
-      ["ASC", "DESC"][order(something)]
-    end
   end
 end