magic_grid 0.12.4 → 0.12.5

data/lib/magic_grid/html_grid.rb

@@ -1,128 +1,131 @@
 require 'magic_grid/definition'
+require 'magic_grid/order'
 
 module MagicGrid
   class HtmlGrid
+    attr_reader :view, :grid
+    private :view, :grid
 
     def initialize(grid_definition, view, controller = nil)
       @grid = grid_definition
+      @spinner_drawn = false
       @view ||= view
-      if controller
-        @current_url = controller.request.fullpath
-      else
-        @current_url = nil
-      end
+      @current_url = controller && controller.request.fullpath
     end
 
     def render(&row_renderer)
-      @spinner_drawn = false
-      grid_data = {
-        :searcher => @grid.searcher,
-        :current => @current_url,
-        :live_search => @grid.options[:live_search],
-        :listeners => @grid.options[:listeners],
-        :remote => @grid.options[:remote],
-        :default_ajax_handler => @grid.options[:default_ajax_handler],
-        :params => @grid.base_params,
-      }
+      @row_renderer = row_renderer || method(:grid_row)
       table_options = {
-        :class => (['magic_grid'] << @grid.options[:class]).join(' '),
-        :id => @grid.magic_id,
-        :data => grid_data.select {|_,v| v }
+        :class => "magic_grid #{grid.options[:class]}",
+        :id    => grid.magic_id,
+        :data  => {
+          :searcher             => grid.searcher,
+          :current              => @current_url,
+          :live_search          => grid.options[:live_search],
+          :listeners            => grid.options[:listeners],
+          :remote               => grid.options[:remote],
+          :default_ajax_handler => grid.options[:default_ajax_handler],
+          :params               => grid.base_params,
+        }.reject {|_,v| v.nil? }
       }
-      @view.content_tag('table', table_options) do
-        thead + tbody(&row_renderer) + tfoot
-      end
-    end
-
-    def thead
-      @view.content_tag('thead', :data => {:params => @grid.base_params}) do
-        magic_grid_head
-      end
-    end
-
-    def tbody(&row_renderer)
-      @view.content_tag('tbody', :class => "ui-widget-content") do
-        magic_rows &row_renderer
-      end
+      table(table_options)
     end
 
-    def tfoot
-      @view.content_tag('tfoot') do
-        magic_grid_foot
+    def table(options)
+      view.content_tag('table', options) do
+        view.content_tag('thead',
+                         :data => {:params => grid.base_params},
+                         &method(:magic_grid_head)) <<
+        view.content_tag('tbody',
+                         :class => "ui-widget-content",
+                         &method(:magic_rows)) <<
+        view.content_tag('tfoot',
+                         &method(:magic_grid_foot))
       end
     end
 
-    def spinner_generator
+    def render_spinner
       unless @spinner_drawn
         @spinner_drawn = true
-        @view.tag('span',
-                  :id => (@grid.magic_id.to_s + "_spinner"),
+        view.tag('span',
+                  :id => (grid.magic_id.to_s + "_spinner"),
                   :class => "magic_grid_spinner")
       end
     end
 
     def magic_grid_head
-      spinner = self.method(:spinner_generator)
       thead = []
-      if @grid.needs_searcher?
-        thead << searcher_block(&spinner)
+      if grid.has_title?
+        thead << render_title(grid.title)
       end
-      if @grid.options[:per_page] and @grid.options[:top_pager]
-        thead << magic_pager_block(&spinner)
+      if grid.needs_searcher?
+        thead << searcher_block
       end
-      if thead.empty? and not @grid.options[:collapse_emtpy_header]
-        thead << filler_block(&spinner)
+      if grid.options[:per_page] and grid.options[:top_pager]
+        thead << magic_pager_block(true)
+      end
+      if thead.empty? and not grid.options[:collapse_emtpy_header]
+        thead << filler_block(&method(:render_spinner))
       end
       thead << magic_column_headers
       thead.join.html_safe
     end
 
+    def render_title(title)
+      view.content_tag 'tr' do
+        view.content_tag('th', title,
+                          :class => 'full-width ui-widget-header',
+                          :colspan => grid.columns.count)
+      end
+    end
+
     def magic_grid_foot
-      if @grid.options[:per_page] and @grid.options[:bottom_pager]
+      if grid.options[:per_page] and grid.options[:bottom_pager]
         magic_pager_block
-      elsif not @grid.options[:collapse_emtpy_footer]
+      elsif not grid.options[:collapse_emtpy_footer]
         filler_block
       end
     end
 
-    def filler_block(content = nil, &block)
-      @view.content_tag 'tr' do
-        @view.content_tag('td', content,
+    def filler_block(&block)
+      view.content_tag 'tr' do
+        view.content_tag('td', nil,
                           :class => 'full-width ui-widget-header',
-                          :colspan => @grid.columns.count,
+                          :colspan => grid.columns.count,
                           &block)
       end
     end
 
     def magic_column_headers
-      @view.content_tag 'tr' do
-        @grid.columns.reduce(''.html_safe) do |acc, col|
+      view.content_tag 'tr' do
+        grid.columns.reduce(''.html_safe) do |acc, col|
           classes = ['ui-state-default'] << col.html_classes
           acc <<
           if col.sortable?
             sortable_header(col)
           else
-            @view.content_tag 'th', col.label.html_safe, :class => classes.join(' ')
+            view.content_tag 'th', col.label.html_safe, :class => classes.join(' ')
           end
         end
       end
     end
 
-    def magic_rows(&row_renderer)
-      rows = @grid.collection.map { |row| grid_row(row, &row_renderer) }
+    def magic_rows
+      rows = grid.collection.map(&@row_renderer)
       if rows.empty?
-        rows << render_empty_collection(@grid.options[:if_empty])
+        render_empty_collection(grid.options[:if_empty]).html_safe
+      else
+        rows.join.html_safe
       end
-      rows.join.html_safe
     end
 
     def render_empty_collection(fallback)
       if fallback
-        @view.content_tag 'tr' do
-          @view.content_tag('td', :colspan => @grid.columns.count,
+        view.content_tag 'tr' do
+          view.content_tag('td', :colspan => grid.columns.count,
                             :class => 'if-empty') do
             if fallback.respond_to? :call
-              fallback.call(@grid).to_s
+              fallback.call(grid).to_s
             else
               fallback
             end
@@ -131,18 +134,14 @@ module MagicGrid
       end
     end
 
-    def grid_row(record, &row_renderer)
-      if row_renderer
-        @view.capture(record, &row_renderer)
-      else
-        @view.content_tag 'tr', :class => @view.cycle('odd', 'even') do
-          @grid.columns.map { |c| grid_cell(c, record) }.join.html_safe
-        end
+    def grid_row(record)
+      view.content_tag 'tr', :class => view.cycle('odd', 'even') do
+        grid.columns.map { |c| grid_cell(c, record) }.join.html_safe
       end
     end
 
     def grid_cell(column, record)
-      @view.content_tag('td', :class => column.html_classes) do
+      view.content_tag('td', :class => column.html_classes) do
         method = column.reader
         if method.respond_to? :call
           method.call(record).to_s
@@ -154,114 +153,86 @@ module MagicGrid
       end
     end
 
-    def unordered
-      -1
-    end
-
-    def reverse_order(order)
-      order.to_i == 0 ? 1 : 0
-    end
-
-    def order_icon(order = -1)
-      @view.content_tag 'span', '', :class => "ui-icon #{order_icon_class(order)}"
+    def order_icon(order = Order::Unordered)
+      view.content_tag 'span', '', :class => "ui-icon #{order.icon_class}"
     end
 
-    def order_icon_class(order = -1)
-      case order.to_i
-      when 0 then 'ui-icon-triangle-1-n'
-      when 1 then 'ui-icon-triangle-1-s'
-      else 'ui-icon-carat-2-n-s'
-      end
-    end
-
-    def order_class(order = -1)
-      case order.to_i
-      when 0 then 'sort-asc'
-      when 1 then 'sort-desc'
-      else 'sort-none'
+    def column_link_params(col)
+      id = col.id
+      my_params = grid.base_params.merge(grid.param_key(:col) => id)
+      params = HashWithIndifferentAccess.new(my_params)
+      if id.to_s == grid.current_sort_col.to_s
+        params[grid.param_key(:order)] = grid.current_order.reverse.to_param
+      else
+        params.delete(grid.param_key(:order))
       end
+      params
     end
 
     def sortable_header(col)
       id = col.id
       label = col.label || id.titleize
-      default_sort_order = @grid.order(@grid.default_order)
-      my_params = @grid.base_params.merge({
-        @grid.param_key(:col) => id,
-      })
-      column_link_params = HashWithIndifferentAccess.new(my_params)
-      order = unordered
-      classes = ['sorter ui-state-default'] << col.html_classes
-      if id.to_s == @grid.current_sort_col.to_s
-        order = @grid.current_order
-        classes << "sort-current" << order_class(order)
-        column_link_params[@grid.param_key(:order)] = reverse_order(order)
-      else
-        column_link_params.delete @grid.param_key(:order)
-      end
-      if column_link_params[@grid.param_key(:order)].to_i == default_sort_order.to_i
-        column_link_params.delete(@grid.param_key(:order))
-      end
-      @view.content_tag 'th', :class => classes.join(' ') do
-        @view.link_to column_link_params, :remote => @grid.options[:remote] do
-          label.html_safe << order_icon(order)
+      params = column_link_params(col)
+      classes = %w{sorter ui-state-default} << col.html_classes
+      classes << 'sort-current' if col.order.sorted?
+      view.content_tag 'th', :class => classes.join(' ') do
+        view.link_to params, :remote => grid.options[:remote] do
+          label.html_safe << order_icon(col.order)
         end
       end
     end
 
-    def searcher_block(&spinner)
-      @view.content_tag('tr') do
-        @view.content_tag('td', :class => 'searcher full-width ui-widget-header',
-                    :colspan => @grid.columns.count) do
-          searcher_input(&spinner)
+    def searcher_block
+      view.content_tag('tr') do
+        view.content_tag('td', :class => 'searcher full-width ui-widget-header',
+                         :colspan => grid.columns.count) do
+          searcher_input
         end
       end
     end
 
-    def searcher_input(&spinner)
+    def searcher_input
       searcher_data = {
-        :min_length => @grid.options[:min_search_length],
-        :current => @grid.current_search || "",
+        :min_length => grid.options[:min_search_length],
+        :current    => grid.current_search,
       }
-      searcher = @view.label_tag(@grid.searcher.to_sym,
-                           @grid.options[:searcher_label])
-      searcher << @view.search_field_tag(@grid.searcher.to_sym,
-        @grid.param(:q),
-        :placeholder => @grid.options[:searcher_tooltip],
-        :size => @grid.options[:searcher_size],
-        :data => searcher_data,
-        :form => "a form that doesn't exist")
-      if @grid.options[:search_button]
-        searcher << @view.button_tag(@grid.options[:searcher_button],
-          :class => 'magic-grid-search-button')
+      searcher = view.label_tag(grid.searcher.to_sym,
+                                grid.options[:searcher_label])
+      searcher << view.search_field_tag(grid.searcher.to_sym,
+                                        grid.param(:q),
+                                        :placeholder => grid.options[:searcher_tooltip],
+                                        :size        => grid.options[:searcher_size],
+                                        :data        => searcher_data,
+                                        :form        => "a form that doesn't exist")
+      if grid.options[:search_button]
+        searcher << view.button_tag(grid.options[:searcher_button],
+                                    :class => 'magic-grid-search-button')
       end
-      searcher << yield if block_given?
-      searcher
+      searcher << render_spinner
     end
 
     def magic_pager(collection, opts={})
-      if @view.respond_to? :will_paginate
+      if view.respond_to? :will_paginate
         # WillPaginate
-        @view.will_paginate collection.collection, opts
-      elsif @view.respond_to? :paginate
+        view.will_paginate collection.collection, opts
+      elsif view.respond_to? :paginate
         #Kaminari, or something else..
-        @view.paginate collection.collection, opts
+        view.paginate collection.collection, opts
       else
         ("<!-- page #{collection.current_page} of #{collection.total_pages} -->" +
          '<!-- INSTALL WillPaginate or Kaminari for a pager! -->').html_safe
       end
     end
 
-    def magic_pager_block(&spinner)
-      @view.content_tag('tr') do
-        @view.content_tag('td', :class => 'full-width ui-widget-header magic-pager',
-                    :colspan => @grid.columns.count) do
-          pager = magic_pager(@grid.magic_collection,
-                                :param_name => @grid.param_key(:page),
-                                :params => @grid.base_params
-                               )
+    def magic_pager_block(spinner = false)
+      view.content_tag('tr') do
+        view.content_tag('td', :class => 'full-width ui-widget-header magic-pager',
+                         :colspan => grid.columns.count) do
+          pager = magic_pager(grid.magic_collection,
+                              :param_name => grid.param_key(:page),
+                              :params => grid.base_params)
           if spinner
-            pager << @view.capture(&spinner)
+            pager << render_spinner
           end
           pager
         end

data/lib/magic_grid/order.rb

@@ -0,0 +1,69 @@
+module MagicGrid
+  module Order
+    class Unordered
+      def self.css_class
+        'sort-none'
+      end
+      def self.icon_class
+        'ui-icon-carat-2-n-s'
+      end
+      def self.to_sql
+        'ASC'
+      end
+      def self.to_param
+        0
+      end
+      def self.sorted?
+        false
+      end
+      def self.reverse
+        Descending
+      end
+    end
+    class Unsortable < Unordered; end
+    class Ascending < Unordered
+      def self.css_class
+        'sort-asc'
+      end
+      def self.icon_class
+        'ui-icon-triangle-1-n'
+      end
+      def self.sorted?
+        true
+      end
+      def self.reverse
+        Descending
+      end
+    end
+    class Descending < Unordered
+      def self.css_class
+        'sort-desc'
+      end
+      def self.icon_class
+        'ui-icon-triangle-1-s'
+      end
+      def self.to_sql
+        'DESC'
+      end
+      def self.to_param
+        1
+      end
+      def self.sorted?
+        true
+      end
+      def self.reverse
+        Ascending
+      end
+    end
+    def self.from_param(something)
+      case something
+      when 1, "1", :desc, :DESC, "desc", "DESC", Descending
+        Descending
+      #when 0, "0", :asc, :ASC, "asc", "ASC", Ascending
+      #  Ascending
+      else
+        Ascending
+      end
+    end
+  end
+end

data/lib/magic_grid/version.rb

@@ -1,3 +1,3 @@
 module MagicGrid
-  VERSION = "0.12.4"
+  VERSION = "0.12.5"
 end