magic_grid 0.9.2

data/lib/magic_grid/engine.rb

@@ -0,0 +1,14 @@
+module MagicGrid
+  class Engine < ::Rails::Engine
+    # Once in production, on every page view in development
+    config.to_prepare do |app|
+      # no caching based on path like require does
+      load 'magic_grid/helpers.rb'
+    end
+
+    initializer "magic_grid" do |app|
+      # Provide some fallback translations that users can override
+      app.config.i18n.load_path += Dir.glob(File.expand_path('../../locales/*.{rb,yml}', __FILE__))
+    end
+  end
+end

data/lib/magic_grid/helpers.rb

@@ -0,0 +1,243 @@
+require 'magic_grid/definition'
+require 'will_paginate/array'
+
+module MagicGrid
+  module Helpers
+    def normalize_magic(collection, columns = [], options = {})
+      if collection.is_a? MagicGrid::Definition
+        collection
+      elsif columns.is_a? MagicGrid::Definition
+        columns
+      elsif options.is_a? MagicGrid::Definition
+        options
+      else
+        MagicGrid::Definition.new(columns, collection, controller, options)
+      end
+    end
+
+    def magic_collection(collection, cols, opts = {})
+      normalize_magic(collection, cols, opts).collection
+    end
+
+    def magic_grid(collection = nil, cols = nil, opts = {}, &block)
+      grid = normalize_magic(collection, cols, opts)
+      base_params = grid.base_params
+      data = {
+        :searcher => grid.options[:searcher],
+        :current => url_for,
+        :live_search => grid.options[:live_search],
+        :listeners => (grid.options[:listeners] unless grid.options[:listeners].empty?),
+        :remote => grid.options[:remote],
+        :default_ajax_handler => grid.options[:default_ajax_handler],
+        :params => base_params,
+      }
+      classes = ['magic_grid'] << grid.options[:class]
+      content_tag('table',
+                  :class => classes.join(' '),
+                  :id => grid.magic_id,
+                  :data => data.select {|_,v| v }
+                  ) do
+        table = content_tag('thead', :data => {:params => base_params}
+                           ) do
+          thead = ''.html_safe
+          has_spinner = false
+          spinner = tag('span',
+                        :id => (grid.magic_id.to_s + "_spinner"),
+                        :class => "magic_grid_spinner"
+                       )
+          if grid.options[:needs_searcher]
+            thead << content_tag('tr') do
+              content_tag('td', :class => 'searcher full-width ui-widget-header',
+                          :colspan => grid.columns.count) do
+                searcher_data = {
+                  :min_length => grid.options[:min_search_length],
+                  :current => grid.options[:current_search] || "",
+                }
+                searcher = label_tag(grid.options[:searcher].to_sym,
+                                     grid.options[:searcher_label])
+                searcher << search_field_tag(grid.options[: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 << button_tag(grid.options[:searcher_button],
+                                         :class => 'magic-grid-search-button')
+                end
+                unless has_spinner
+                  has_spinner = true
+                  searcher << spinner
+                end
+                searcher
+              end
+            end
+          end
+          if grid.options[:per_page] and grid.options[:top_pager]
+            thead << content_tag('tr') do
+              content_tag('td', :class => 'full-width ui-widget-header',
+                          :colspan => grid.columns.count) do
+                pager = will_paginate(grid.collection,
+                                      :param_name => grid.param_key(:page),
+                                      :params => base_params
+                                     )
+                unless has_spinner
+                  has_spinner = true
+                  pager << spinner
+                end
+                pager
+              end
+            end
+          end
+          if thead.empty? and not grid.options[:empty_header]
+            thead = content_tag 'tr' do
+              content_tag('td', :class => 'full-width ui-widget-header',
+                          :colspan => grid.columns.count) do
+                unless has_spinner
+                  has_spnner = true
+                  spinner
+                end
+              end
+            end
+          end
+          thead << magic_headers(grid)
+        end
+        table << content_tag('tbody', :class => "ui-widget-content") do
+          magic_rows(grid, &block)
+        end
+        table << content_tag('tfoot') do
+          tfoot = ''.html_safe
+          if grid.options[:per_page] and grid.options[:bottom_pager]
+            tfoot << content_tag('tr') do
+              content_tag('td', :class => 'full-width ui-widget-header',
+                          :colspan => grid.columns.count) do
+                will_paginate(grid.collection,
+                              :param_name => grid.param_key(:page),
+                              :params => base_params
+                             )
+              end
+            end
+          end
+          if tfoot.empty? and not grid.options[:empty_footer]
+            tfoot = content_tag 'tr' do
+              content_tag('td', nil, :class => 'full-width ui-widget-header',
+                          :colspan => grid.columns.count)
+            end
+          end
+          tfoot
+        end
+      end
+    end
+
+    def magic_headers(cols, collection = nil, opts = {})
+      grid = normalize_magic(collection, cols, opts)
+      content_tag 'tr' do
+        grid.columns.reduce(''.html_safe) do |acc, col|
+          classes = ['ui-state-default'] << col[:class]
+          acc <<
+          if col.is_a? String
+            content_tag 'th', col.html_safe, :class => classes.join(' ')
+          elsif not col.key? :sql
+            content_tag 'th', col[:label].html_safe, :class => classes.join(' ')
+          else
+            sortable_header(grid, col, opts)
+          end
+        end
+      end
+    end
+
+    def magic_rows(cols, collection = nil, &block)
+      grid = normalize_magic(collection, cols)
+      if_empty = grid.options[:if_empty]
+      rows = grid.collection.map do |row|
+        if block_given?
+          "<!-- block: -->" << capture(row, &block)
+        else
+          "<!-- magic row: -->" << magic_row(row, grid)
+        end
+      end
+      if rows.empty? and if_empty
+        content_tag 'tr' do
+          content_tag('td', :colspan => grid.columns.count,
+                      :class => 'if-empty') do
+            if if_empty.respond_to? :call
+              if_empty.call(grid).to_s
+            else
+              if_empty
+            end
+          end
+        end
+      else
+        rows.join.html_safe
+      end
+    end
+
+    def magic_row(record, cols, collection = nil)
+      grid = normalize_magic(collection, cols)
+      content_tag 'tr', :class => cycle('odd', 'even') do
+        grid.columns.reduce(''.html_safe) do |acc, c|
+          acc << content_tag('td', :class => c[:class].try(:join, ' ')) do
+            method = c[:to_s] || c[:col]
+            if method.respond_to? :call
+              method.call(record)
+            elsif record.respond_to? method
+              record.send(method)
+            end.to_s
+          end
+        end
+      end
+    end
+
+    def reverse_order(order)
+      order.to_i == 0 ? 1 : 0
+    end
+
+    def order_icon(order = -1)
+      content_tag 'span', '', :class => "ui-icon #{order_icon_class(order)}"
+    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'
+      end
+    end
+
+    def sortable_header(grid, col, opts = {})
+      id = col[:id]
+      label = col[:label] || id.titleize
+      default_sort_order = opts.fetch(:default_order, grid.order(grid.default_order))
+      my_params = grid.base_params.merge({
+        grid.param_key(:col) => id,
+      })
+      my_params = HashWithIndifferentAccess.new(my_params)
+      order = nil
+      classes = ['sorter ui-state-default'] << col[:class]
+      current = id.to_s == grid.current_sort_col.to_s
+      if current
+        order = grid.current_order
+        classes << "sort-current" << order_class(order)
+        my_params[grid.param_key(:order)] = reverse_order(order)
+        label << order_icon(order)
+      else
+        my_params.delete grid.param_key(:order) if my_params[grid.param_key(:order)]
+        label << order_icon()
+      end
+      my_params.delete(grid.param_key(:order)) if my_params[grid.param_key(:order)].to_i == default_sort_order.to_i
+      content_tag 'th', :class => classes.join(' ') do
+        link_to label.html_safe, my_params, :remote => grid.options[:remote]
+      end
+    end
+
+    ::ActionView::Base.send :include, self
+  end
+end

data/lib/magic_grid/railtie.rb

@@ -0,0 +1,9 @@
+module MagicGrid
+  class Railtie < Rails::Railtie
+    # Once in production, on every page view in development
+    config.to_prepare do
+      # no caching based on path like require does
+      load 'magic_grid/helpers.rb'
+    end
+  end
+end

data/lib/magic_grid/version.rb

@@ -0,0 +1,3 @@
+module MagicGrid
+  VERSION = "0.9.2"
+end

data/lib/tasks/magic_grid_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :magic_grid do
+#   # Task goes here
+# end

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,9 @@
+// This is a manifest file that'll be compiled into including all the files listed below.
+// Add new JavaScript/Coffee code in separate files in this directory and they'll automatically
+// be included in the compiled file accessible from http://example.com/assets/application.js
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/test/dummy/app/assets/javascripts/posts.js

@@ -0,0 +1,8 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.
+$(function () {
+    $("#user_id").addClass("ready");
+    $(".magic_grid").on("magic_grid:loaded", function () {
+        console.log("Loaded a grid: ", this);
+    });
+});

data/test/dummy/app/assets/javascripts/users.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,7 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+ *= require_self
+ *= require_tree . 
+*/

data/test/dummy/app/assets/stylesheets/posts.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/test/dummy/app/assets/stylesheets/scaffold.css

@@ -0,0 +1,56 @@
+body { background-color: #fff; color: #333; }
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+div.field, div.actions {
+  margin-bottom: 10px;
+}
+
+#notice {
+  color: green;
+}
+
+.field_with_errors {
+  padding: 2px;
+  background-color: red;
+  display: table;
+}
+
+#error_explanation {
+  width: 450px;
+  border: 2px solid red;
+  padding: 7px;
+  padding-bottom: 0;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
+}
+
+#error_explanation h2 {
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px;
+  margin-bottom: 0px;
+  background-color: #c00;
+  color: #fff;
+}
+
+#error_explanation ul li {
+  font-size: 12px;
+  list-style: square;
+}

data/test/dummy/app/assets/stylesheets/users.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/test/dummy/app/controllers/posts_controller.rb

@@ -0,0 +1,104 @@
+class PostsController < ApplicationController
+  # GET /posts
+  # GET /posts.json
+  def index
+    @posts = Post.includes(:user)
+    @some_array = []
+    def @some_array.search(q)
+      Rails.logger.debug "Searching for #{q}, really!"
+      self
+    end
+
+    if params.key? :user_id and not params[:user_id].empty?
+      @title = "Posts by: #{User.find(params[:user_id]).name}"
+      @posts = @posts.where(:user_id => params[:user_id])
+    end
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: @posts }
+    end
+  end
+
+  # GET /posts/by-user/1
+  # GET /posts/by-user/1.json
+  def by_user
+    @title = "Posts by: #{User.find(params[:user_id]).name}"
+    @posts = Post.includes(:user).where(:user_id => params[:user_id])
+    respond_to do |format|
+      format.html # by_user.html.erb
+      format.json { render json: @posts }
+    end
+  end
+
+  # GET /posts/1
+  # GET /posts/1.json
+  def show
+    @post = Post.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: @post }
+    end
+  end
+
+  # GET /posts/new
+  # GET /posts/new.json
+  def new
+    @post = Post.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @post }
+    end
+  end
+
+  # GET /posts/1/edit
+  def edit
+    @post = Post.find(params[:id])
+  end
+
+  # POST /posts
+  # POST /posts.json
+  def create
+    @post = Post.new(params[:post])
+
+    respond_to do |format|
+      if @post.save
+        format.html { redirect_to @post, notice: 'Post was successfully created.' }
+        format.json { render json: @post, status: :created, location: @post }
+      else
+        format.html { render action: "new" }
+        format.json { render json: @post.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /posts/1
+  # PUT /posts/1.json
+  def update
+    @post = Post.find(params[:id])
+
+    respond_to do |format|
+      if @post.update_attributes(params[:post])
+        format.html { redirect_to @post, notice: 'Post was successfully updated.' }
+        format.json { head :ok }
+      else
+        format.html { render action: "edit" }
+        format.json { render json: @post.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /posts/1
+  # DELETE /posts/1.json
+  def destroy
+    @post = Post.find(params[:id])
+    @post.destroy
+
+    respond_to do |format|
+      format.html { redirect_to posts_url }
+      format.json { head :ok }
+    end
+  end
+end