magic_grid 0.9.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= MagicGrid
+
+Takes a collection and creates a paginated table of using a supplied column definition.
+
+== Basic Usage
+
+In your +Gemfile+:
+
+    gem 'magic_grid', :git => 'git://github.com/rmg/magic_grid.git'
+
+In your view:
+
+    <%= magic_grid(@posts, [:title, :author]) %>
+
+
+== Development
+
+To test, <code>(cd test/dummy && rake RAILS_ENV=test db:create db:migrate) && rake test</code>
+

data/Rakefile

@@ -0,0 +1,44 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MagicGrid'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:tests) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+task :test => [:spec, :tests]
+task :default => :test

data/lib/assets/javascripts/magic_grid.js

@@ -0,0 +1,154 @@
+// vim: ts=4 et sw=4 sts=4
+
+$(function () {
+    // Micro-plugin for positioning the cursor
+    $.fn.setCursor = $.fn.setCursor || function(pos) {
+        return this.each(function() {
+            if (this.setSelectionRange) {
+                this.focus();
+                this.setSelectionRange(pos, pos);
+            } else if (this.createTextRange) {
+                var range = this.createTextRange();
+                range.collapse(true);
+                range.moveEnd('character', pos);
+                range.moveStart('character', pos);
+                range.select();
+            }
+        });
+    };
+
+    // Micro-plugin for getting the position of the cursor
+    $.fn.getCursor = $.fn.getCursor || function () {
+        // IE doesn't have selectionStart, and I'm too lazy to implement
+        // the IE specific version of this, so we'll just assume
+        // the cursor is at the end of the input for this case.
+        if (typeof this[0].selectionStart === 'undefined') {
+            return this.value.length;
+        } else {
+            return this[0].selectionStart;
+        }
+    };
+
+    // Micro-plugin for collecting all the listener and search inputs
+    $.fn.getGridParams = $.fn.getGridParams || function (extras) {
+        var listeners = this.data("listeners"),
+            params = $.extend({}, {'magic_grid_id' : this.attr('id')}, extras || {}),
+            $input, param_key, listened_id;
+        for (listened_id in listeners) {
+            param_key = listeners[listened_id];
+            $input = $("#" + listened_id);
+            if ($input.is(":checkbox")) {
+                params[param_key] = $input.is(":checked");
+            } else if ($input.is("select")) {
+                params[param_key] = $input.find("option:selected").val();
+            } else {
+                params[param_key] = $input.val();
+            }
+        }
+        if (this.is("[data-searcher]")) {
+            params[this.attr('id') + '_q'] = $("#" + this.data("searcher")).val();
+        }
+        return $.extend({}, params);
+    }
+
+    // Default handler for ajax events that displays 'Loading...' in
+    // the head of the table.
+    $(".magic_grid[data-default-ajax-handler=true]").on("magic_grid:loading", function (e) {
+        $(".magic_grid_spinner", this).
+            addClass("ui-icon-spinner").
+                html("<em>Loading...</em>");
+    });
+
+    $(".magic_grid[data-remote=true]").on( "click", ".pagination a, .sorter a", function (e) {
+        var $grid = $(e.delegateTarget),
+            url = this.href;
+        $grid.trigger("magic_grid:loading");
+        $grid.load(url + ' #' + $grid.attr('id') + " > *", function () {
+            $grid.trigger("magic_grid:loaded");
+        });
+        return false;
+    });
+
+    $(".magic_grid[data-searcher]").each( function () {
+        var $grid = $(this),
+            grid_id = this.id,
+            input_id = "#" + $grid.data("searcher"),
+            live = $grid.data("live-search"),
+            // keydown seems to be the only reliable and portable way to capture
+            // things like backspace and delete
+            events = (live ? "keydown change search" : "change search"),
+            timer = null,
+            internal = ($grid.has(input_id).length > 0),
+            listener = (internal ? $grid : $(input_id).parent()),
+            minLength = $(input_id).data("min-length") || 3;
+        listener.on(events, input_id, function (e) {
+            var is_manual = (e.type == 'search' ||
+                             e.type == 'change' ||
+                             (e.type == 'keydown' && e.which == '13')),
+                base_url = $grid.data("current") || "",
+                //40 wpm typists == 280ms/keystroke
+                //90 wpm typists == 120ms/keystroke
+                delay = is_manual ? 1 : (parseInt(live) || 500);
+            clearTimeout(timer);
+            timer = setTimeout(function () {
+                var $input = $(input_id),
+                    current = $input.data("current"),
+                    value = $input.val(),
+                    length = value.length,
+                    url = base_url + "?",
+                    relevant = is_manual || (value != current && (length >= minLength || length == 0)),
+                    pos = $input.getCursor();
+                clearTimeout(timer);
+                url += $.param($grid.getGridParams());
+                if (relevant) {
+                    $grid.trigger("magic_grid:loading");
+                    if ($grid.data("remote")) {
+                        if (internal && live && !is_manual) {
+                            $(input_id).prop('disabled', true);
+                        }
+                        $grid.load(url + ' #' + grid_id + ' > *', function () {
+                            // Move the cursor back to where it was,
+                            // less surprising that way.
+                            // EXCEPT FOR IE, that is
+                            $grid.trigger("magic_grid:loaded");
+                            if (internal) {
+                                $(input_id).setCursor(pos);
+                            }
+                        });
+                    } else {
+                        window.location = url;
+                    }
+                }
+            }, delay);
+        });
+    });
+
+    $(".magic_grid[data-listeners]").each( function () {
+        var $grid = $(this),
+            listeners = $grid.data("listeners"),
+            grid_id = this.id
+            base_url = $grid.data("current"),
+            handler = function (change) {
+                var url = base_url + "?" + $.param($grid.getGridParams());
+                $grid.trigger("magic_grid:loading");
+                if ($grid.data("remote")) {
+                    $grid.load(url + ' #' + grid_id + " > *", function () {
+                        $grid.trigger("magic_grid:loaded");
+                    });
+                } else {
+                    window.location = url;
+                }
+            };
+        for (var k in listeners) {
+            if ($("#" + k).hasClass("ready")) {
+                $("#" + k).on("change", {"field": listeners[k]}, handler);
+            } else {
+                $("#" + k).on("ready", {"field": listeners[k]}, function (ready) {
+                    $(this).on("change", ready.data, handler);
+                });
+            }
+        }
+    });
+
+    $(".magic_grid").trigger("magic_grid:loaded");
+});

data/lib/locales/en.yml

@@ -0,0 +1,7 @@
+en:
+  magic_grid:
+    no_results: no results found
+    search:
+      label: search
+      tooltip: search... <enter>
+      button: Search

data/lib/magic_grid.rb

@@ -0,0 +1,7 @@
+module MagicGrid
+  if ::Rails.version < "3.1"
+    require 'magic_grid/railtie'
+  else
+    require 'magic_grid/engine'
+  end
+end

data/lib/magic_grid/definition.rb

@@ -0,0 +1,212 @@
+require 'will_paginate/view_helpers/action_view'
+
+module MagicGrid
+  class Definition
+    include WillPaginate::ActionView
+    attr_accessor :columns, :collection, :magic_id, :options, :params, :accepted,
+      :current_sort_col, :current_order, :default_order
+
+    DEFAULTS = {
+      :class => [],
+      :top_pager => false,
+      :bottom_pager => true,
+      :remote => false,
+      :per_page => 30,
+      :searchable => false,
+      :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,
+    }
+
+    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"
+      )
+    end
+
+    def initialize(cols_or_opts, collection = nil, controller = nil, 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, [])
+      elsif cols_or_opts.is_a? Array
+        @options = self.class.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"
+      end
+      @default_order = @options[:default_order]
+      @params = controller.try(:params) || {}
+      @collection = collection
+      begin
+        #if @collection.respond_to? :table
+        table_name = @collection.quoted_table_name
+        table_columns = @collection.table.columns.map {|c| c.name}
+      rescue
+        Rails.logger.debug "Given collection doesn't respond to :table well"
+        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.connection.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.respond_to?(:order) 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 = @collection.order("#{sort_col} #{sort_dir}")
+      else
+        Rails.logger.debug "#{self.class.name}: Ignoring sorting on non-AR collection"
+      end
+
+      @options[:searchable] = [] if @options[:searchable] and not @options[:searchable].kind_of? Array
+
+      @accepted = [:action, :controller, param_key(:page)]
+      @accepted << param_key(:q) if @options[:searchable]
+      @accepted += @options[:listeners].values
+
+      if @collection.respond_to?(:where) or @options[:listener_handler].respond_to?(:call)
+        if @options[:listener_handler].respond_to? :call
+          @collection = @options[:listener_handler].call(@collection)
+        else
+          @options[:listeners].each_pair do |key, value|
+            if @params[value] and not @params[value].to_s.empty?
+              @collection = @collection.where(key => @params[value])
+            end
+          end
+        end
+      else
+        unless @options[:listeners].empty?
+          Rails.logger.warn "#{self.class.name}: Ignoring listener on dumb collection"
+          @options[:listeners] = {}
+        end
+      end
+      @options[:current_search] ||= param(:q)
+      if (@collection.respond_to?(:where) or
+          (@options[:search_method] and @collection.respond_to?(@options[:search_method])))
+        if param(:q) and not param(:q).empty? and @options[:searchable]
+          orig_collection = @collection
+          begin
+            @collection = @collection.__send__(@options[:search_method], param(:q))
+          rescue
+            Rails.logger.debug "Given collection doesn't respond to #{@options[:search_method]} well"
+            @collection = orig_collection
+            search_cols = @options[:searchable].map do |searchable|
+              case searchable
+              when Symbol
+                known = @columns.find {|col| col[:col] == searchable}
+                if known and known.key?(:sql)
+                  known[:sql]
+                else
+                  "#{table_name}.#{@collection.connection.quote_column_name(searchable.to_s)}"
+                end
+              when Integer
+                @columns[searchable][:sql]
+              when String
+                searchable
+              else
+                raise "Searchable must be identifiable"
+              end
+            end
+            unless search_cols.empty?
+              begin
+                clauses = search_cols.map {|c| c << " LIKE :search" }.join(" OR ")
+                @collection = @collection.where(clauses, {:search => "%#{param(:q)}%"})
+              rescue
+                Rails.logger.debug "Given collection doesn't respond to :where well"
+                @collection = orig_collection
+              end
+            end
+          end
+        end
+      else
+        if @options[:searchable] or param(:q)
+          Rails.logger.warn "#{self.class.name}: Ignoring searchable fields on non-AR collection"
+        end
+        @options[:searchable] = false
+      end
+      if not @options[:searcher] and @options[:searchable]
+        @options[:needs_searcher] = true
+        @options[:searcher] = param_key(:searcher)
+      end
+      # Do collection filter first, may convert from AR to Array
+      if @options[:collection_post_filter?] and @collection.respond_to?(:post_filter)
+        @collection = @collection.post_filter(controller)
+      end
+      if @options[:post_filter] and @options[:post_filter].respond_to?(:call)
+        @collection = @options[:post_filter].call(@collection)
+      end
+      # Paginate at the very end, after all sorting, filtering, etc..
+      if @options[:per_page]
+        @collection = @collection.paginate(:page => param(:page, 1),
+                                           :per_page => @options[:per_page])
+      end
+    end
+
+    def param_key(key)
+      "#{@magic_id}_#{key}".to_sym
+    end
+
+    def param(key, default=nil)
+      @params.fetch(param_key(key), default)
+    end
+
+    def base_params
+      @params.select { |k,_| accepted.include? k.to_sym }.merge :magic_grid_id => @magic_id
+    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