footable-rails 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+FooTable-src
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in bootstrap-rails.gemspec
+gemspec

data/README.md

@@ -0,0 +1,20 @@
+FooTable-rails
+==============
+
+footable-rails integrates [FooTable](https://github.com/bradvin/FooTable) in Rails assets pipeline.
+
+
+```
+gem 'footable-rails'
+```
+
+application.css
+
+````sass
+*= require footable-rails
+```
+
+application.js
+```
+//= require footable-rails
+```

data/Rakefile.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env rake
+require File.expand_path('../lib/footable-rails/version', __FILE__)
+
+desc "Update assets"
+task :update do
+  system("rm -rf FooTable-src")
+  system("git clone git://github.com/bradvin/FooTable.git FooTable-src")
+  system("git status")
+end
+
+desc "Build"
+task "build" do
+  system("gem build footable-rails.gemspec")
+end
+
+desc "Build and publish the gem"
+task :publish => :build do
+  system("gem push footable-rails-#{FootableRails::Rails::VERSION}.gem")
+end

data/footable-rails.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/footable-rails/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Gonzalo Rodríguez-Baltanás Díaz"]
+  gem.email         = ["siotopo@gmail.com"]
+  gem.description   = %q{Plugin for unobstrusive tables }
+  gem.homepage      = "https://github.com/Nerian/FooTable-rails"
+  gem.summary       = gem.description
+
+  gem.name          = "footable-rails"
+  gem.require_paths = ["lib"]
+  gem.files         = `git ls-files`.split("\n")
+  gem.version       = FootableRails::Rails::VERSION
+
+  gem.add_dependency "railties", ">= 3.0"
+  gem.add_development_dependency "bundler", ">= 1.0"
+  gem.add_development_dependency "rake"
+end

data/lib/footable-rails.rb

@@ -0,0 +1,12 @@
+require "rails"
+require "footable-rails/version"
+
+module FootableRails
+  module Rails
+    if ::Rails.version < "3.1"
+      require "footable-rails/railtie"
+    else
+      require "footable-rails/engine"
+    end
+  end
+end

data/lib/footable-rails/engine.rb

@@ -0,0 +1,6 @@
+module FootableRails
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/footable-rails/railtie.rb

@@ -0,0 +1,5 @@
+module FootableRails
+  module Rails
+    class Railtie < ::Rails::Railtie; end
+  end
+end

data/lib/footable-rails/version.rb

@@ -0,0 +1,5 @@
+module FootableRails
+  module Rails
+    VERSION = "0.0.1"
+  end
+end

data/vendor/assets/javascripts/footable-rails/footable.js

@@ -0,0 +1,403 @@
+/*!
+ * FooTable - Awesome Responsive Tables
+ * http://themergency.com/footable
+ *
+ * Requires jQuery - http://jquery.com/
+ *
+ * Copyright 2012 Steven Usher & Brad Vincent
+ * Released under the MIT license
+ * You are free to use FooTable in commercial projects as long as this copyright header is left intact.
+ *
+ * Date: 18 Nov 2012
+ */
+(function ($, w, undefined) {
+  w.footable = {
+    options: {
+      delay: 100, // The number of millseconds to wait before triggering the react event
+      breakpoints: { // The different screen resolution breakpoints
+        phone: 480,
+        tablet: 1024
+      },
+      parsers: {  // The default parser to parse the value out of a cell (values are used in building up row detail)
+        alpha: function (cell) {
+          return $(cell).data('value') || $.trim($(cell).text());
+        }
+      },
+      toggleSelector: ' > tbody > tr:not(.footable-row-detail)', //the selector to show/hide the detail row
+      createDetail: function (element, data) {  //creates the contents of the detail row
+        for (var i = 0; i < data.length; i++) {
+          element.append('<div><strong>' + data[i].name + '</strong> : ' + data[i].display + '</div>');
+        }
+      },
+      classes: {
+        loading : 'footable-loading',
+        loaded : 'footable-loaded',
+        sorted : 'footable-sorted',
+        descending : 'footable-sorted-desc',
+        indicator : 'footable-sort-indicator'
+      },
+      debug: false // Whether or not to log information to the console.
+    },
+
+    version: {
+      major: 0, minor: 1,
+      toString: function () {
+        return w.footable.version.major + '.' + w.footable.version.minor;
+      },
+      parse: function (str) {
+        version = /(\d+)\.?(\d+)?\.?(\d+)?/.exec(str);
+        return {
+          major: parseInt(version[1]) || 0,
+          minor: parseInt(version[2]) || 0,
+          patch: parseInt(version[3]) || 0
+        };
+      }
+    },
+
+    plugins: {
+      _validate: function (plugin) {
+        ///<summary>Simple validation of the <paramref name="plugin"/> to make sure any members called by Foobox actually exist.</summary>
+        ///<param name="plugin">The object defining the plugin, this should implement a string property called "name" and a function called "init".</param>
+
+        if (typeof plugin['name'] !== 'string') {
+          if (w.footable.options.debug == true) console.error('Validation failed, plugin does not implement a string property called "name".', plugin);
+          return false;
+        }
+        if (!$.isFunction(plugin['init'])) {
+          if (w.footable.options.debug == true) console.error('Validation failed, plugin "' + plugin['name'] + '" does not implement a function called "init".', plugin);
+          return false;
+        }
+        if (w.footable.options.debug == true) console.log('Validation succeeded for plugin "' + plugin['name'] + '".', plugin);
+        return true;
+      },
+      registered: [], // An array containing all registered plugins.
+      register: function (plugin, options) {
+        ///<summary>Registers a <paramref name="plugin"/> and its default <paramref name="options"/> with Foobox.</summary>
+        ///<param name="plugin">The plugin that should implement a string property called "name" and a function called "init".</param>
+        ///<param name="options">The default options to merge with the Foobox's base options.</param>
+
+        if (w.footable.plugins._validate(plugin)) {
+          w.footable.plugins.registered.push(plugin);
+          if (options != undefined && typeof options === 'object') $.extend(true, w.footable.options, options);
+          if (w.footable.options.debug == true) console.log('Plugin "' + plugin['name'] + '" has been registered with the Foobox.', plugin);
+        }
+      },
+      init: function (instance) {
+        ///<summary>Loops through all registered plugins and calls the "init" method supplying the current <paramref name="instance"/> of the Foobox as the first parameter.</summary>
+        ///<param name="instance">The current instance of the Foobox that the plugin is being initialized for.</param>
+
+        for(var i = 0; i < w.footable.plugins.registered.length; i++){
+          try {
+            w.footable.plugins.registered[i]['init'](instance);
+          } catch(err) {
+            if (w.footable.options.debug == true) console.error(err);
+          }
+        }
+      }
+    }
+  };
+
+  var instanceCount = 0;
+
+  $.fn.footable = function(options) {
+    ///<summary>The main constructor call to initialize the plugin using the supplied <paramref name="options"/>.</summary>
+    ///<param name="options">
+    ///<para>A JSON object containing user defined options for the plugin to use. Any options not supplied will have a default value assigned.</para>
+    ///<para>Check the documentation or the default options object above for more information on available options.</para>
+    ///</param>
+
+    options=options||{};
+    var o=$.extend(true,{},w.footable.options,options); //merge user and default options
+    return this.each(function () {
+      instanceCount++;
+      this.footable = new Footable(this, o, instanceCount);
+    });
+  };
+
+  //helper for using timeouts
+  function Timer() {
+    ///<summary>Simple timer object created around a timeout.</summary>
+    var t=this;
+    t.id=null;
+    t.busy=false;
+    t.start=function (code,milliseconds) {
+      ///<summary>Starts the timer and waits the specified amount of <paramref name="milliseconds"/> before executing the supplied <paramref name="code"/>.</summary>
+      ///<param name="code">The code to execute once the timer runs out.</param>
+      ///<param name="milliseconds">The time in milliseconds to wait before executing the supplied <paramref name="code"/>.</param>
+
+      if (t.busy) {return;}
+      t.stop();
+      t.id=setTimeout(function () {
+        code();
+        t.id=null;
+        t.busy=false;
+      },milliseconds);
+      t.busy=true;
+    };
+    t.stop=function () {
+      ///<summary>Stops the timer if its runnning and resets it back to its starting state.</summary>
+
+      if(t.id!=null) {
+        clearTimeout(t.id);
+        t.id=null;
+        t.busy=false;
+      }
+    };
+  };
+
+  function Footable(t, o, id) {
+    ///<summary>Inits a new instance of the plugin.</summary>
+    ///<param name="t">The main table element to apply this plugin to.</param>
+    ///<param name="o">The options supplied to the plugin. Check the defaults object to see all available options.</param>
+    ///<param name="id">The id to assign to this instance of the plugin.</param>
+
+    var ft = this;
+    ft.id = id;
+    ft.table = t;
+    ft.options = o;
+    ft.breakpoints = [];
+    ft.breakpointNames = '';
+    ft.columns = { };
+
+    var opt = ft.options;
+    var cls = opt.classes;
+
+    // This object simply houses all the timers used in the footable.
+    ft.timers = {
+      resize: new Timer(),
+      register: function (name) {
+        ft.timers[name] = new Timer();
+        return ft.timers[name];
+      }
+    };
+
+    w.footable.plugins.init(ft);
+
+    ft.init = function() {
+      var $window = $(w), $table = $(ft.table);
+
+      if ($table.hasClass(cls.loaded)) {
+        //already loaded FooTable for the table, so don't init again
+        ft.raise('footable_already_initialized');
+        return;
+      }
+
+      $table.addClass(cls.loading);
+
+      // Get the column data once for the life time of the plugin
+      $table.find('> thead > tr > th, > thead > tr > td').each(function() {
+        var data = ft.getColumnData(this);
+        ft.columns[data.index] = data;
+
+        var count = data.index + 1;
+        //get all the cells in the column
+        var $column = $table.find('> tbody > tr > td:nth-child(' + count + ')');
+        //add the className to the cells specified by data-class="blah"
+        if (data.className != null) $column.not('.footable-cell-detail').addClass(data.className);
+      });
+
+      // Create a nice friendly array to work with out of the breakpoints object.
+      for(var name in opt.breakpoints) {
+        ft.breakpoints.push({ 'name': name, 'width': opt.breakpoints[name] });
+        ft.breakpointNames += (name + ' ');
+      }
+
+      // Sort the breakpoints so the smallest is checked first
+      ft.breakpoints.sort(function(a, b) { return a['width'] - b['width']; });
+
+      //bind the toggle selector click events
+      ft.bindToggleSelectors();
+
+      ft.raise('footable_initializing');
+
+      $table.bind('footable_initialized', function (e) {
+        //resize the footable onload
+        ft.resize();
+
+        //remove the loading class
+        $table.removeClass(cls.loading);
+
+        //hides all elements within the table that have the attribute data-hide="init"
+        $table.find('[data-init="hide"]').hide();
+        $table.find('[data-init="show"]').show();
+
+        //add the loaded class
+        $table.addClass(cls.loaded);
+      });
+
+      $window
+        .bind('resize.footable', function () {
+          ft.timers.resize.stop();
+          ft.timers.resize.start(function() {
+            ft.raise('footable_resizing');
+            ft.resize();
+            ft.raise('footable_resized');
+          }, opt.delay);
+        });
+
+      ft.raise('footable_initialized');
+    };
+    
+    //moved this out into it's own function so that it can be called from other add-ons
+    ft.bindToggleSelectors = function() {
+      var $table = $(ft.table);
+      $table.find(opt.toggleSelector).unbind('click.footable').bind('click.footable', function (e) {
+        if ($table.is('.breakpoint')) {
+          var $row = $(this).is('tr') ? $(this) : $(this).parents('tr:first');
+          ft.toggleDetail($row.get(0));
+        }
+      });      
+    };
+
+    ft.parse = function(cell, column) {
+      var parser = opt.parsers[column.type] || opt.parsers.alpha;
+      return parser(cell);
+    };
+
+    ft.getColumnData = function(th) {
+      var $th = $(th), hide = $th.data('hide');
+      hide = hide || '';
+      hide = hide.split(',');
+      var data = {
+        'index': $th.index(),
+        'hide': { },
+        'type': $th.data('type') || 'alpha',
+        'name': $th.data('name') || $.trim($th.text()),
+        'ignore': $th.data('ignore') || false,
+        'className': $th.data('class') || null
+      };
+      data.hide['default'] = ($th.data('hide')==="all") || ($.inArray('default', hide) >= 0);
+
+      for(var name in opt.breakpoints) {
+        data.hide[name] = ($th.data('hide')==="all") || ($.inArray(name, hide) >= 0);
+      }
+      var e = ft.raise('footable_column_data', { 'column': { 'data': data, 'th': th } });
+      return e.column.data;
+    };
+
+    ft.getViewportWidth = function() {
+      return window.innerWidth || (document.body ? document.body.offsetWidth : 0);
+    };
+
+    ft.getViewportHeight = function() {
+      return window.innerHeight || (document.body ? document.body.offsetHeight : 0);
+    };
+
+    ft.hasBreakpointColumn = function(breakpoint) {
+      for(var c in ft.columns) {
+        if (ft.columns[c].hide[breakpoint]) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    ft.resize = function() {
+      var $table = $(ft.table);
+      var info = {
+        'width': $table.width(),                  //the table width
+        'height': $table.height(),                //the table height
+        'viewportWidth': ft.getViewportWidth(),   //the width of the viewport
+        'viewportHeight': ft.getViewportHeight(), //the width of the viewport
+        'orientation': null
+      };
+      info.orientation = info.viewportWidth > info.viewportHeight ? 'landscape' : 'portrait';
+
+      if (info.viewportWidth < info.width) info.width = info.viewportWidth;
+      if (info.viewportHeight < info.height) info.height = info.viewportHeight;
+
+      var pinfo = $table.data('footable_info');
+      $table.data('footable_info', info);
+
+      // This (if) statement is here purely to make sure events aren't raised twice as mobile safari seems to do
+      if (!pinfo || ((pinfo && pinfo.width && pinfo.width != info.width) || (pinfo && pinfo.height && pinfo.height != info.height))) {
+        var current = null, breakpoint;
+        for (var i = 0; i < ft.breakpoints.length; i++) {
+          breakpoint = ft.breakpoints[i];
+          if (breakpoint && breakpoint.width && info.width <= breakpoint.width) {
+            current = breakpoint;
+            break;
+          }
+        }
+
+        var breakpointName = (current == null ? 'default' : current['name']);
+
+        var hasBreakpointFired = ft.hasBreakpointColumn(breakpointName);
+
+        $table
+          .removeClass('default breakpoint').removeClass(ft.breakpointNames)
+          .addClass(breakpointName + (hasBreakpointFired ? ' breakpoint' : ''))
+          .find('> thead > tr > th').each(function() {
+            var data = ft.columns[$(this).index()];
+            var count = data.index + 1;
+            //get all the cells in the column
+            var $column = $table.find('> tbody > tr > td:nth-child(' + count + '), > tfoot > tr > td:nth-child(' + count + '), > colgroup > col:nth-child(' + count + ')').add(this);
+
+            if (data.hide[breakpointName] == false) $column.show();
+            else $column.hide();
+          })
+          .end()
+          .find('> tbody > tr.footable-detail-show').each(function() {
+            ft.createOrUpdateDetailRow(this);
+          });
+
+        $table.find('> tbody > tr.footable-detail-show:visible').each(function() {
+          var $next = $(this).next();
+          if ($next.hasClass('footable-row-detail')) {
+            if (breakpointName == 'default' && !hasBreakpointFired) $next.hide();
+            else $next.show();
+          }
+        });
+
+        ft.raise('footable_breakpoint_' + breakpointName, { 'info': info });
+      }
+    };
+
+    ft.toggleDetail = function(actualRow) {
+      var $row = $(actualRow),
+          created = ft.createOrUpdateDetailRow($row.get(0)),
+          $next = $row.next();
+
+      if (!created && $next.is(':visible')) {
+        $row.removeClass('footable-detail-show');
+        $next.hide();
+      } else {
+        $row.addClass('footable-detail-show');
+        $next.show();
+      }
+    };
+
+    ft.createOrUpdateDetailRow = function (actualRow) {
+      var $row = $(actualRow), $next = $row.next(), $detail, values = [];
+      if ($row.is(':hidden')) return; //if the row is hidden for some readon (perhaps filtered) then get out of here
+      $row.find('> td:hidden').each(function () {
+        var column = ft.columns[$(this).index()];
+        if (column.ignore == true) return true;
+        values.push({ 'name': column.name, 'value': ft.parse(this, column), 'display': $.trim($(this).html()) });
+      });
+      var colspan = $row.find('> td:visible').length;
+      var exists = $next.hasClass('footable-row-detail');
+      if (!exists) { // Create
+        $next = $('<tr class="footable-row-detail"><td class="footable-cell-detail"><div class="footable-row-detail-inner"></div></td></tr>');
+        $row.after($next);
+      }
+      $next.find('> td:first').attr('colspan', colspan);
+      $detail = $next.find('.footable-row-detail-inner').empty();
+      opt.createDetail($detail, values);
+      return !exists;
+    };
+
+    ft.raise = function(eventName, args) {
+      args = args || { };
+      var def = { 'ft': ft };
+      $.extend(true, def, args);
+      var e = $.Event(eventName, def);
+      if (!e.ft) { $.extend(true, e, def); } //pre jQuery 1.6 which did not allow data to be passed to event object constructor
+      $(ft.table).trigger(e);
+      return e;
+    };
+
+    ft.init();
+    return ft;
+  };
+})(jQuery, window);

data/vendor/assets/javascripts/footable-rails/index.js

@@ -0,0 +1,2 @@
+//= require ./footable
+//= require_tree ./plugins/

data/vendor/assets/javascripts/footable-rails/plugins/filter/footable.filter.js

@@ -0,0 +1,81 @@
+(function ($, w, undefined) {
+  if (w.footable == undefined || w.footable == null)
+    throw new Error('Please check and make sure footable.js is included in the page and is loaded prior to this script.');
+
+  var jQversion = w.footable.version.parse($.fn.jquery);
+  if (jQversion.major == 1 && jQversion.minor < 8) { // For older versions of jQuery, anything below 1.8
+    $.expr[':'].ftcontains = function(a, i, m) {
+      return $(a).html().toUpperCase().indexOf(m[3].toUpperCase()) >= 0;
+    };
+  } else { // For jQuery 1.8 and above
+    $.expr[":"].ftcontains = $.expr.createPseudo(function(arg) {
+      return function(elem) {
+        return $(elem).html().toUpperCase().indexOf(arg.toUpperCase()) >= 0;
+      };
+    });
+  }
+
+  var defaults = {
+    filter: {
+      enabled: true,
+      input: '.footable-filter',
+      timeout: 300,
+      minimum: 2
+    }
+  };
+
+  function Filter() {
+    var p = this;
+    p.name = 'Footable Filter';
+    p.init = function(ft) {
+      if (ft.options.filter.enabled == true) {
+        ft.timers.register('filter');
+        $(ft.table).bind({
+          'footable_initialized': function(e) {
+            var $table = $(e.ft.table);
+            var data = {
+              'input': $table.data('filter') || e.ft.options.filter.input,
+              'timeout': $table.data('filter-timeout') || e.ft.options.filter.timeout,
+              'minimum': $table.data('filter-minimum') || e.ft.options.filter.minimum
+            };
+            $(data.input).keyup(function () {
+              e.ft.timers.filter.stop();
+              e.ft.timers.filter.start(function() {
+                var val = $(data.input).val() || '';
+                if (val.length < data.minimum) {
+                  $table.find("> tbody > tr:not(.footable-row-detail)").each(function() {
+                    p.showRow(this, e.ft);
+                  });
+                } else {
+                  var filters = val.split(" ");
+                  $table.find("> tbody > tr").hide();
+                  var rows = $table.find("> tbody > tr:not(.footable-row-detail)");
+                  $.each(filters, function(i, f) {
+                    if (f && f.length)
+                      rows = rows.filter("*:ftcontains('" + f + "')");
+                  });
+                  rows.each(function() {
+                    p.showRow(this, e.ft);
+                  });
+                }
+              }, data.timeout);
+            });
+          }
+        });
+      }
+    };
+    
+    p.showRow = function(row, ft) {
+      var $row = $(row), $next = $row.next(), $table = $(ft.table);
+      if ($row.is(':visible')) return; //already visible - do nothing
+      if ($table.hasClass('breakpoint') && $row.hasClass('footable-detail-show') && $next.hasClass('footable-row-detail')) {
+        $row.add($next).show();
+        ft.createOrUpdateDetailRow(row);
+      }
+      else $row.show();
+    };
+  };
+  
+  w.footable.plugins.register(new Filter(), defaults);
+  
+})(jQuery, window);

data/vendor/assets/javascripts/footable-rails/plugins/filter/footable.plugin.template.js

@@ -0,0 +1,44 @@
+(function ($, w, undefined) {
+  if (w.footable == undefined || w.foobox == null)
+    throw new Error('Please check and make sure footable.js is included in the page and is loaded prior to this script.');
+
+  var defaults = {
+    /*
+       Plugin options here, example:
+
+        var defaults = {
+          myPlugin: {
+            enabled: true
+          }
+        };
+
+       This would allow you to access this option using ft.options.myPlugin.enabled
+    */
+  };
+
+  function MyPlugin() {
+    var p = this;
+    p.name = 'Footable MyPlugin';
+    p.init = function(ft) {
+      $(ft.table).bind({
+        /*
+           Bind to relevant events here to modify/add functionality to Footable, example:
+
+            $(ft.table).bind({
+              'footable_initialized': function(e){
+                if (e.ft.options.myPlugin.enabled == true){
+                  alert('Hello World');
+                }
+              }
+            });
+
+           This would listen for the 'footable_initialized' event and when called check if the plugin is enabled
+           and if it is alert 'Hello World' to the user.
+        */
+      });
+    };
+  };
+  
+  w.footable.plugins.register(new MyPlugin(), defaults);
+  
+})(jQuery, window);

data/vendor/assets/javascripts/footable-rails/plugins/sortable/footable.sortable.js

@@ -0,0 +1,153 @@
+(function ($, w, undefined) {
+  if (w.footable == undefined || w.footable == null)
+    throw new Error('Please check and make sure footable.js is included in the page and is loaded prior to this script.');
+
+  var defaults = {
+    sort: true,
+    sorters: {
+      alpha: function (a, b) {
+        if (a[0] == b[0]) return 0;
+        if (a[0] < b[0]) return -1;
+        return 1;
+      },
+      numeric: function (a, b) {
+        return a - b;
+      }
+    },
+    parsers: {
+      numeric: function (cell) {
+        var val = $(cell).data('value') || $(cell).text().replace(/[^0-9.-]/g, '');
+        val = parseFloat(val);
+        if (isNaN(val)) val = 0;
+        return val;
+      }
+    },
+    classes: {
+        sort: {
+            sortable : 'footable-sortable',
+            sorted : 'footable-sorted',
+            descending : 'footable-sorted-desc',
+            indicator : 'footable-sort-indicator'
+        }
+    }
+  };
+
+  function Sortable() {
+    var p = this;
+    p.name = 'Footable Sortable';
+    p.init = function(ft) {
+      if (ft.options.sort == true) {
+        $(ft.table).bind({
+          'footable_initialized': function(e) {
+            var cls = ft.options.classes.sort;
+
+            var $table = $(e.ft.table), $tbody = $table.find('> tbody');
+
+            $(e.ft.table).find('tr th').each(function (ec) {
+              var $th = $(this);
+              var column = e.ft.columns[$th.index()];
+              if (column.sort.ignore != true) { 
+                $th.addClass(cls.sortable);
+                $('<span />').addClass(cls.indicator).appendTo($th);
+              }
+            });
+            
+            $(e.ft.table).find('tr th.' + cls.sortable).click(function (ec) {
+              var $th = $(this), index = $th.index();
+              var column = e.ft.columns[index];
+              if (column.sort.ignore == true) return true;
+              ec.preventDefault();
+      
+              $table.find('> thead > tr > th').not($th).removeClass(cls.sorted + ' ' + cls.descending);
+
+              if ($th.hasClass(cls.sorted)) {
+                p.reverse(e.ft, $tbody);
+                $th.removeClass(cls.sorted).addClass(cls.descending);
+              } else if ($th.hasClass(cls.descending)) {
+                p.reverse(e.ft, $tbody);
+                $th.removeClass(cls.descending).addClass(cls.sorted);
+              } else {
+                p.sort(e.ft, $tbody, column);
+                $th.removeClass(cls.descending).addClass(cls.sorted);
+              }
+              e.ft.bindToggleSelectors();
+              return false;
+            });
+
+            var didSomeSorting = false;
+            for(var c in e.ft.columns) {
+                var column = e.ft.columns[c];
+                if (column.sort.initial) {
+                    p.sort(e.ft, $tbody, column);
+                    didSomeSorting = true;
+                    var $th = $table.find('thead th:eq(' + c + ')');
+
+                    if (column.sort.initial == "descending") {
+                        p.reverse(e.ft, $tbody);
+                        $th.addClass(cls.descending);
+                    } else {
+                        $th.addClass(cls.sorted);
+                    }
+
+                    break;
+                } else if (column.sort.ignore != true) {
+                  
+                }
+            }
+            if (didSomeSorting) { e.ft.bindToggleSelectors(); }
+          },
+          'footable_column_data': function(e) {
+            var $th = $(e.column.th);
+            e.column.data.sort = e.column.data.sort || { };
+            e.column.data.sort.initial = $th.data('sort-initial') || false;
+            e.column.data.sort.ignore = $th.data('sort-ignore') || false;
+            e.column.data.sort.selector = $th.data('sort-selector') || null;
+          }
+        });
+      }
+    };
+
+    p.rows = function(ft, tbody, column) {
+      var rows = [];
+      tbody.find('> tr').each(function () {
+        var $row = $(this), $next = null;
+        if ($row.hasClass('footable-row-detail')) return true;
+        if ($row.next().hasClass('footable-row-detail')) {
+          $next = $row.next().get(0);
+        }
+        var row = { 'row': $row, 'detail': $next };
+        if (column != undefined && column.index != undefined) {
+          row.value = ft.parse(this.cells[column.index], column);
+        }
+        rows.push(row);
+        return true;
+      }).remove();
+      return rows;
+    };
+
+    p.sort = function(ft, tbody, column) {
+      var rows = p.rows(ft, tbody, column);
+      var sorter = ft.options.sorters[column.type] || ft.options.sorters.alpha;
+      rows.sort(function(a, b) { return sorter(a.value, b.value); });
+      for (var j = 0; j < rows.length; j++) {
+        tbody.append(rows[j].row);
+        if (rows[j].detail != null) {
+          tbody.append(rows[j].detail);
+        }
+      }
+    };
+
+    p.reverse = function(ft, tbody) {
+      var rows = p.rows(ft, tbody);
+      for (var i = rows.length - 1; i >= 0; i--) {
+        tbody.append(rows[i].row);
+        if (rows[i].detail != null) {
+          tbody.append(rows[i].detail);
+        }
+      }
+    };
+  };
+  
+  w.footable.plugins.register(new Sortable(), defaults);
+  
+})(jQuery, window);

data/vendor/assets/stylesheets/footable-rails/footable.css

@@ -0,0 +1,92 @@
+.footable > thead > tr > th,.footable > thead > tr > td {
+  position: relative;
+}
+
+.footable {
+  border-spacing: 0;
+  width: 100%;
+  border: solid #ccc 1px;
+  -moz-border-radius: 6px;
+  -webkit-border-radius: 6px;
+  border-radius: 6px;
+  font-family: 'trebuchet MS' , 'Lucida sans' , Arial;
+  font-size: 14px;
+  color: #444;
+}
+
+.footable.breakpoint > tbody > tr > td.expand {
+  background: url('assets/images/plus.png') no-repeat 5px center;
+  padding-left: 40px;
+}
+
+.footable.breakpoint > tbody > tr.footable-detail-show > td.expand {
+  background: url('assets/images/minus.png') no-repeat 5px center;
+}
+
+.footable.breakpoint > tbody > tr.footable-row-detail {
+  background: #eee;
+}
+
+.footable > tbody > tr:hover {
+  background: #fbf8e9;
+}
+
+.footable.breakpoint > tbody > tr:hover:not(.footable-row-detail) {
+  cursor: pointer;
+}
+
+.footable > tbody > tr > td, .footable > thead > tr > th {
+  border-left: 1px solid #ccc;
+  border-top: 1px solid #ccc;
+  padding: 10px;
+  text-align: left;
+}
+
+.footable > thead > tr > th, .footable > thead > tr > td {
+  background-color: #dce9f9;
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#ebf3fc), to(#dce9f9));
+  background-image: -webkit-linear-gradient(top, #ebf3fc, #dce9f9);
+  background-image: -moz-linear-gradient(top, #ebf3fc, #dce9f9);
+  background-image: -ms-linear-gradient(top, #ebf3fc, #dce9f9);
+  background-image: -o-linear-gradient(top, #ebf3fc, #dce9f9);
+  background-image: linear-gradient(to bottom, #ebf3fc, #dce9f9);
+  -webkit-box-shadow: 0 1px 0 rgba(255,255,255,.8) inset;
+  -moz-box-shadow: 0 1px 0 rgba(255,255,255,.8) inset;
+  box-shadow: 0 1px 0 rgba(255,255,255,.8) inset;
+  border-top: none;
+  text-shadow: 0 1px 0 rgba(255,255,255,.5);
+}
+
+.footable > thead > tr > th:first-child, .footable > thead > tr > td:first-child {
+  -moz-border-radius: 6px 0 0 0;
+  -webkit-border-radius: 6px 0 0 0;
+  border-radius: 6px 0 0 0;
+}
+
+.footable > thead > tr > th:last-child, .footable > thead > tr > td:last-child {
+  -moz-border-radius: 0 6px 0 0;
+  -webkit-border-radius: 0 6px 0 0;
+  border-radius: 0 6px 0 0;
+}
+
+.footable > thead > tr > th:only-child, .footable > thead > tr > td:only-child {
+  -moz-border-radius: 6px 6px 0 0;
+  -webkit-border-radius: 6px 6px 0 0;
+  border-radius: 6px 6px 0 0;
+}
+
+.footable > tbody > tr:last-child > td:first-child {
+  -moz-border-radius: 0 0 0 6px;
+  -webkit-border-radius: 0 0 0 6px;
+  border-radius: 0 0 0 6px;
+}
+
+.footable > tbody > tr:last-child > td:last-child {
+  -moz-border-radius: 0 0 6px 0;
+  -webkit-border-radius: 0 0 6px 0;
+  border-radius: 0 0 6px 0;
+}
+
+.footable > tbody img {
+  vertical-align:middle;
+}

data/vendor/assets/stylesheets/footable-rails/index.css

@@ -0,0 +1,2 @@
+*= require ./footable
+*= require_tree ./plugins/

data/vendor/assets/stylesheets/footable-rails/plugins/sortable/footable.sortable.css

@@ -0,0 +1,24 @@
+.footable > thead > tr > th > span.footable-sort-indicator {
+  width: 16px;
+  height: 16px;
+  display: block;
+  float:right;
+  background: url('assets/images/sorting_sprite.png') no-repeat top left;
+}
+
+.footable > thead > tr > th.footable-sortable:hover {
+  cursor:pointer;
+}
+
+.footable > thead > tr > th.footable-sortable > span {
+  
+}
+
+.footable > thead > tr > th.footable-sorted > span.footable-sort-indicator {
+  background-position: 0 -16px;
+}
+
+.footable > thead > tr > th.footable-sorted-desc > span.footable-sort-indicator {
+  background-position: 0 -32px;
+}
+

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: footable-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gonzalo Rodríguez-Baltanás Díaz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'Plugin for unobstrusive tables '
+email:
+- siotopo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile.rb
+- footable-rails.gemspec
+- lib/footable-rails.rb
+- lib/footable-rails/engine.rb
+- lib/footable-rails/railtie.rb
+- lib/footable-rails/version.rb
+- vendor/assets/images/footable-rails/down.png
+- vendor/assets/images/footable-rails/minus.png
+- vendor/assets/images/footable-rails/plus.png
+- vendor/assets/images/footable-rails/sorting_sprite.png
+- vendor/assets/images/footable-rails/up.png
+- vendor/assets/javascripts/footable-rails/footable.js
+- vendor/assets/javascripts/footable-rails/index.js
+- vendor/assets/javascripts/footable-rails/plugins/filter/footable.filter.js
+- vendor/assets/javascripts/footable-rails/plugins/filter/footable.plugin.template.js
+- vendor/assets/javascripts/footable-rails/plugins/sortable/footable.sortable.js
+- vendor/assets/stylesheets/footable-rails/footable.css
+- vendor/assets/stylesheets/footable-rails/index.css
+- vendor/assets/stylesheets/footable-rails/plugins/sortable/footable.sortable.css
+homepage: https://github.com/Nerian/FooTable-rails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1224216804177223604
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1224216804177223604
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Plugin for unobstrusive tables
+test_files: []