fluid_table 3.2.0

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010-2012 Decisiv, Inc.
+Copyright (c) 2009 Brennan Dunn
+
+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.md

@@ -0,0 +1,3 @@
+# FluidTable
+
+FluidTable is a paginated data table helper for rails.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Test fluid_table'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => [:test]

data/lib/fluid_table.rb

@@ -0,0 +1,19 @@
+require 'rails'
+require 'action_controller'
+require 'active_support/core_ext/proc'
+
+require 'fluid_table/class_methods'
+require 'fluid_table/instance_methods'
+require 'fluid_table/column'
+require 'fluid_table/context'
+require 'fluid_table/version'
+
+class FluidTable
+  include ActionView::Helpers::TagHelper
+
+  class_attribute :row_options, :class_columns, :table_options
+  attr_accessor :view, :records, :cloned_columns, :render_options, :cache_rendered_rows
+
+  extend ClassMethods
+  include InstanceMethods
+end

data/lib/fluid_table/class_methods.rb

@@ -0,0 +1,22 @@
+class FluidTable
+  module ClassMethods
+    
+    def define_column(*args, &proc)
+      options = [Hash,Proc].include?(args.last.class) ? args.pop : {}
+      identity, alt_name = *args
+      Column.new(self, identity, alt_name, options, &proc).tap do |column|
+        (self.class_columns ||= Array.new).push(column)
+        column.default_position = class_columns.index(column)
+      end
+    end
+    
+    def render(view,records = nil)
+      new(view).render(records)
+    end
+    
+    def valid?
+      !class_columns.empty?
+    end
+    
+  end
+end

data/lib/fluid_table/column.rb

@@ -0,0 +1,200 @@
+class FluidTable
+  class Column
+    include Comparable
+    include ActionView::Helpers::TagHelper
+    
+    attr_accessor :table, :identity, :alt_name, :options, :html_options, :proc, :forced_options # basic init
+    attr_accessor :is_visible, :default_position, :configured_position  # overrides
+    attr_accessor :table_instance # duped context 
+    
+    DefaultOptions = { :default => true, :cacheable => true }
+    
+    def initialize(table, identity, alt_name = nil, options = {}, &proc)
+      self.table          = table
+      self.identity       = identity
+      self.alt_name       = alt_name
+      self.options        = options.reverse_merge(DefaultOptions)
+      self.html_options   = options.delete(:html) || {}
+      self.proc           = proc
+      self.forced_options = {}
+    end
+    
+    def <=>(other_column)
+      if position == other_column.position
+        return -1 if positioned? && !other_column.positioned?
+        return 1 if !positioned? && other_column.positioned?
+      end
+      position <=> other_column.position
+    end
+    
+    def current
+      table_instance.view.current
+    end
+    
+    def position
+      configured_position || default_position
+    end
+    
+    def cacheable?
+      options[:cacheable]
+    end
+    
+    def visible?
+      return @visible unless @visible.nil?
+      @visible = options[:visible] ? options[:visible].bind(table_instance.view).call : true
+    end
+    
+    def config_filter_key
+      :"filter_for_#{sort.field}"
+    end
+    
+    def filter
+      options[:filter]
+    end
+    
+    def filter_distinct?
+      filter == :distinct
+    end
+    
+    def filterable?
+      filter.present?
+    end
+    
+    def filter_data
+      return [] unless filterable?
+      if filter_distinct?
+        filter_data_for_distinct
+      else
+        filter.first.is_a?(Array) ? filter.map(&:first) : filter
+      end
+    end
+    
+    def filter_data_for_current
+      return [] unless filterable?
+      data = filter_data
+      values = current_filter_values
+      data.sort.inject(ActiveSupport::OrderedHash.new) do |hsh, key|
+        checked = values.include?(key)
+        value = if !filter_distinct? && filter.first.is_a?(Array)
+                  filter.detect{ |arr| arr.first == key }.try(:last)
+                else
+                  checked ? 1 : 0
+                end
+        hsh[key] = [checked ? 1 : 0, key].join('|')
+        hsh
+      end
+    end
+
+    def filter_condition
+      filter_values = current_filter_values.dup
+      conditions = []
+      if filter_values.delete('none...')
+        conditions << "#{sort.table}.#{sort.field} IS NULL"
+      end
+      unless filter_values.empty?
+        conditions << "#{sort.table}.#{sort.field} IN (?)"
+      end
+      return nil if conditions.empty?
+      condition = "(#{conditions.join(' OR ')})"
+      unless filter_values.empty?
+        condition = [condition, filter_values]
+      end
+      condition
+    end
+
+    def positioned?
+      !!configured_position
+    end
+    
+    def name
+      alt_name || identity.to_s.humanize
+    end
+
+    def sort_on
+      options[:sort_on]
+    end
+    
+    def sort
+      return nil unless sort_on
+      @sort ||= begin
+        stable, sfield = sort_on.split('.')
+        Struct.new(:table, :field).new(stable, sfield)
+      end
+    end
+
+    def html(scope)
+      attributes = html_options.is_a?(Proc) ? html_options.call(Context.new(table_instance, scope)) : html_options
+      merge_options = forced_options.is_a?(Proc) ? forced_options.call(Context.new(table_instance, scope)) : forced_options
+      content_tag(:td, interior_content(scope).to_s.html_safe, attributes.merge(merge_options))
+    end
+    
+    def display?
+      is_visible.nil? ? options[:default] : is_visible
+    end
+    
+    def reset!
+      self.is_visible = self.configured_position = nil
+    end
+    
+    
+    private
+    
+    def current_user_filters
+      table_instance.current_user_filters
+    end
+    
+    def current_filter_values
+      return [] unless filterable?
+      value = current_user_filters[config_filter_key] || ''
+      value.split(',').map(&:strip)
+    end
+    
+    # FIXME this absolutely does not belong here
+    def filter_data_for_distinct
+      base_finders = {:select => sort.field, :group => sort.field}
+      set = case table.klass_name
+            when 'FleetRecentEstimates', 'FleetRequestedEstimates'
+              case sort_on
+              when 'vehicles.fleet_info'
+                current.dealer.fleet_vehicles.all(base_finders)
+              when 'estimates.fleet_status'
+                current.dealer.fleet_estimates.all(base_finders)
+              when 'dealer_info.dealer_name'
+                Dealer.find_by_sql(%|
+                  SELECT [dealer_name] 
+                  FROM [dealer_info] 
+                  WHERE [dealer_id] IN (SELECT [dealer_id] FROM [estimates] WHERE [vehicle_owner] = #{Dealer.connection.quote(current.dealer.id)})
+                  ORDER BY [dealer_name] ASC|.squish)
+              end
+            when 'SvcRecentEstimates', 'SvcAssignedEstimates'
+              case sort_on
+              when 'estimates.assigned_to', 'estimates.customer_company_name'
+                table_instance.scoped_records.all(base_finders)
+              end
+            end || []
+      fields = set.map { |o| o.send(sort.field) } + current_filter_values
+      fields.uniq.reject { |o| o.blank? }.sort
+    end
+    
+    def interior_content(scope)
+      if proc && table_instance
+        call_by_arity(scope)
+      elsif scope.respond_to?(identity)
+        scope.send identity
+      else
+        ''
+      end
+    end
+    
+    def call_by_arity(scope)
+      call_arguments = case proc.arity
+        when 1      then [scope]
+        when 2      then [scope, table_instance]
+        when 3      then [scope, table_instance, self]
+        else        []
+      end
+      proc.bind(table_instance.view).call(*call_arguments)
+    end
+    
+  end
+end

data/lib/fluid_table/context.rb

@@ -0,0 +1,28 @@
+class FluidTable
+  class Context < Struct.new(:table,:record)
+    
+    def view
+      table.view if table
+    end
+    
+    def respond_to?(method)
+      view && view.respond_to?(method)
+    end
+    
+    
+    private
+    
+    def method_missing(method, *args)
+      if table.view
+        if block_given?
+          table.view.send(method, *args) { |*block_args| yield(*block_args) }
+        else
+          table.view.send(method, *args)
+        end
+      else
+        block_given? ? super { |*block_args| yield(*block_args) } : super
+      end
+    end
+    
+  end
+end

data/lib/fluid_table/instance_methods.rb

@@ -0,0 +1,86 @@
+class FluidTable
+  module InstanceMethods
+    
+    def initialize(view,render_options={})
+      self.view = view
+      load_cloned_columns
+      self.render_options = render_options
+      load_customizations
+    end
+    
+    def displayed_columns
+      cloned_columns.select(&:display?).sort
+    end
+    
+    def hidden_columns
+      cloned_columns - displayed_columns
+    end
+    
+    # Overwrite this method in your implementation to add table headers, etc.
+    def render(records = find_records)
+      self.records = records
+      rendered_table = content_tag :table, content_tag(:tbody,render_table_body), table_options || {}
+      render_header + rendered_table + render_footer
+    end
+    
+    # Stub methods
+    def find_records ; [] ; end
+    def customize_column(column) ; column ; end
+    def render_header ; ActiveSupport::SafeBuffer.new ; end
+    def render_footer ; ActiveSupport::SafeBuffer.new ; end
+    def if_array_empty?
+      content_tag :td, %|There's nothing here|, :colspan => displayed_columns.size
+    end
+    
+    private
+  
+    def load_cloned_columns
+      self.cloned_columns = class_columns.map { |cc| cloned = cc.dup ; cloned.table_instance = self ; cloned }
+      cloned_columns.reject! { |c| !c.visible? }
+      cloned_columns.sort!
+    end
+    
+    def load_customizations
+      cloned_columns.each { |c| customize_column(c) }
+    end
+    
+    def render_table_body
+      return render_empty_table if records.blank?
+      records.map do |record|
+        content_tag(:tr,render_row(record),render_tr_options(record))
+      end.join.html_safe
+    end
+    
+    def render_empty_table
+      content_tag(:tr,if_array_empty?)
+    end
+    
+    def render_row(record)
+      # The goal is to have one cache hit for the row, per record. The challenge is that different users can have some 
+      # columns on/off in each row. The solution is to use a hash for the entire row. If the users displayed_columns has 
+      # all the columns from the row cache hash (write_col) then it will not re-write the cache with more data.
+      if cache_rendered_rows
+        cache_key = ActiveSupport::Cache.expand_cache_key ['views',configurator_id,record]
+        row_cache = Rails.cache.fetch(cache_key) { HashWithIndifferentAccess.new }
+        write_col = displayed_columns.select(&:cacheable?).map(&:identity).any? { |id| !row_cache.keys.include?(id) }
+        row_cache = row_cache.dup if write_col
+      end
+      # Rendering the row like normal FluidTable but building up the hash cache if needed.
+      rendered_row = displayed_columns.map do |c|
+        cache_rendered_rows && c.cacheable? ? (row_cache[c.identity] ||= c.html(record)) : c.html(record)
+      end.join
+      # Write the cache back if caching and any cols were not in the orig cache. Return rendered row.
+      Rails.cache.write(cache_key,row_cache) if cache_rendered_rows && write_col
+      return rendered_row.html_safe
+    end
+    
+    def render_tr_options(record)
+      case opt = row_options
+        when Proc   then opt.call(Context.new(self,record))
+        when Hash   then opt
+        else        {}
+      end
+    end
+    
+  end
+end

data/lib/fluid_table/version.rb

@@ -0,0 +1,3 @@
+class FluidTable
+  VERSION = '3.2.0'
+end

data/test/support/user.rb

@@ -0,0 +1,14 @@
+class User < Struct.new(:id, :name)
+  
+  ALL = [
+    [1, 'Brennan Dunn'], 
+    [2, 'Ken Collins'], 
+    [3, 'Brian Knox'], 
+    [4, 'Nagu Parasu'] 
+  ].map { |arr| new(*arr) }
+  
+  def self.all_users
+    ALL
+  end
+  
+end

data/test/support/users.html.erb

@@ -0,0 +1 @@
+<%= UsersTable.render(self,User.all_users) %>

data/test/support/users_table.rb

@@ -0,0 +1,27 @@
+class UsersTable < FluidTable
+  
+  self.table_options = { :class => 'dataTable' }
+  
+  define_column :id, 'User #'
+  
+  define_column :name do |user|
+    user.name.upcase
+  end
+  
+  define_column :age, :html => Proc.new { |c| { :class => "table_id_#{c.table.object_id}" } }
+  define_column :gender
+  
+  UsersTable.define_column :displayed_column
+  UsersTable.define_column :hidden_column, :default => false
+  
+  # overwrites
+  
+  def render_header
+    content_tag(:div, 'This is the header')
+  end
+  
+  def render_footer
+    content_tag(:div, 'This is the footer')
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler'
+require 'bundler/setup'
+Bundler.require(:default)
+require 'minitest/autorun'
+require 'mocha'
+require 'nokogiri'
+
+require 'support/user'
+require 'support/users_table'

data/test/units/column_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+
+class TestTable < FluidTable
+  define_column :id, 'User #'
+  define_column :name, 'User Name'
+  define_column(:google){ link_to_google }
+end
+
+describe FluidTable::Column do
+
+  def self.test_order
+    :alpha
+  end
+
+  describe 'Constructing column objects' do
+    
+    before do
+      @test_table = TestTable.new(nil,nil)
+      @id_column = @test_table.class_columns.detect { |c| c.identity == :id }
+      @name_column = @test_table.class_columns.detect { |c| c.identity == :name }
+      @google_column = @test_table.class_columns.detect { |c| c.identity == :google }
+    end
+    
+    it "should respond to it's identity" do
+      assert_equal :id, @id_column.identity
+    end
+    
+    it 'should attempt to create a humanized string from the identity if an alt_name is not present' do
+      assert_equal 'User #', @id_column.name
+      assert_equal 'User Name', @name_column.name
+    end
+    
+    it "should be able to parse its sort on table and field" do
+      @name_column.options[:sort_on] = 'foo.bar'
+      assert @name_column.sort
+      assert_equal 'foo', @name_column.sort.table
+      assert_equal 'bar', @name_column.sort.field
+    end
+    
+    describe "Outputting a column's HTML" do
+      
+      it 'should wrap output within a table cell' do
+        assert_equal_html '<td></td>', @id_column.html(mock)
+      end
+      
+      # FIXME - I suck and my tests are order-dependent?
+      it 'should attempt to get cell content from scope object when proc is not available' do
+        assert_equal_html '<td>John Doe</td>', @name_column.html(mock({ :name => 'John Doe' }))
+      end
+      
+      it "should call a column's proc (if exists) against the scope of the current view" do
+        view = mock.tap { |m| m.stubs :link_to_google => 'http://google.com' } 
+        table = TestTable.new(view)
+        google_column = table.cloned_columns.detect { |c| c.identity == :google }
+        assert_equal_html '<td>http://google.com</td>', google_column.html(User.all_users.first)
+      end
+      
+      it 'should be able to set custom HTML attributes when supplied a HASH' do
+        @name_column.html_options = { :class => 'foo' }
+        assert_match /class="foo"/, @name_column.html(mock)
+        @name_column.html_options = { :id => 'bar' }
+        assert_match /id="bar"/, @name_column.html(mock)
+      end
+    
+      it 'should be able to set custom HTML attributes when supplied a PROC' do
+        @name_column.html_options = Proc.new { |context| { :id => "name_#{context.record.id}" } }
+        assert_match /id="name_5"/, @name_column.html(mock(:id => '5'))
+      end
+    
+    end
+    
+  end
+  
+  describe 'Columns within a FluidTable' do
+    
+    it 'should not be valid? unless at least one column is defined' do
+      assert ! TestTable.class_columns.empty?
+      assert TestTable.valid?
+      TestTable.stubs(:class_columns).returns([])
+      assert ! TestTable.valid?
+    end
+    
+  end
+
+
+  private
+
+  def assert_equal_html(expected, actual)
+    assert_equal expected.strip.gsub(/\n\s*/, ''), actual.strip.gsub(/\n\s*/, '')
+  end
+
+end

data/test/units/configuration_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+describe "Fluid table configuration" do
+
+  let(:table) { UsersTable.new(nil, nil) }
+
+  it 'should have an array of cloned class_columns for each table instance' do
+    table.cloned_columns.map(&:object_id).wont_equal UsersTable.class_columns.map(&:object_id)
+  end
+
+  it 'should not affect a class column when modifying an instance column' do
+    instance_column = get_column(:age)
+    transform_column(instance_column, false)
+    assert_equal false, instance_column.display?
+    assert_equal true, get_table_column(:age).display?
+  end
+
+  describe "Determining a column's default visibility" do
+
+    let(:displayed_column) { get_column(:displayed_column) }
+    let(:hidden_column)    { get_column(:hidden_column) }
+
+    it 'should default to TRUE for a column display' do
+      assert displayed_column.display?
+    end
+
+    it "should allow for a column's definition to default display to FALSE" do
+      assert !hidden_column.display?
+    end
+
+    it 'should include correct columns when returning from #displayed_columns or #hidden_columns' do
+      assert table.displayed_columns.include?(displayed_column)
+      assert !table.displayed_columns.include?(hidden_column)
+      assert table.hidden_columns.include?(hidden_column)
+      assert !table.hidden_columns.include?(displayed_column)
+    end
+
+  end
+
+  describe 'When overriding position or visibility' do
+
+    it 'should call #customize_column with each column object on table instantiation' do
+      table.class_columns.each do |column|
+        table.expects(:customize_column).with(column)
+      end
+      table.send :load_customizations
+    end
+
+    it 'should override default column visibility settings when instructed' do
+      column = get_column(:age)
+      assert table.displayed_columns.include?(column)
+      transform_column(get_column(:age), false)
+      table.send :load_customizations
+      assert ! table.displayed_columns.include?(column)
+    end
+
+    it "should be able to set a column's position which trumps the default" do
+      age_column = get_column(:age)
+      transform_column(age_column, true, 0)
+      assert_equal age_column.identity, table.displayed_columns.first.identity
+    end
+
+  end
+
+  private
+
+  def get_column(identity)
+    table.cloned_columns.detect { |c| c.identity == identity }
+  end
+
+  def get_table_column(identity)
+    table.class_columns.detect { |c| c.identity == identity }
+  end
+
+  def transform_column(column, is_visible = true, position = nil)
+    column.is_visible = is_visible
+    column.configured_position = position
+  end
+
+end

data/test/units/render_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+describe FluidTable do
+
+  describe "#render" do
+
+    let(:text) { UsersTable.render(stub(:view), User.all_users) }
+    let(:html) { Nokogiri::HTML::DocumentFragment.parse(text) }
+
+    it "renders the header text in a header div" do
+      html.xpath(".//div").first.text.must_equal 'This is the header'
+    end
+
+    it "renders the footer text in a footer div" do
+      html.xpath(".//div").last.text.must_equal 'This is the footer'
+    end
+
+    it "renders a row for each user" do
+      html.xpath(".//tbody/tr").length.must_equal User.all_users.length
+    end
+
+    it "render 'Nothing here' if there are no users" do
+      User.stubs(:all_users).returns([])
+      html.xpath(".//td").map(&:text).must_equal ["There's nothing here"]
+    end
+
+  end
+
+end

data/test/units/table_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+describe "FluidTable render" do
+
+  describe 'A FluidTable object' do
+
+    it 'should have the option of setting attributes to the generated table (as opposed to overwriting #render)' do
+      UsersTable.table_options = { :class => 'dataTable' }
+      assert_match %r{table class="dataTable"}, render_users
+    end
+
+    describe 'Ordering of class_columns' do
+
+      it 'should be defaultly positioned in the order of definition' do
+        assert_equal 0, UsersTable.class_columns.first.default_position
+        assert_equal UsersTable.class_columns.size-1, UsersTable.class_columns.last.default_position
+      end
+
+      it 'should have the #sort order be identical to the default positioning when there are no custom positions' do
+        assert_equal UsersTable.class_columns, UsersTable.class_columns.sort
+      end
+
+    end
+
+    describe 'Supplying row (<tr>) options' do
+
+      it 'should output standard hash options' do
+        UsersTable.row_options = { :class => 'foo' }
+        assert_match %r{tr class="foo"}, render_users
+      end
+
+      it 'should yield a context object when given a Proc' do
+        UsersTable.row_options = Proc.new { |context| { :id => "user_#{context.record.id}" } }
+        assert_match %r{tr id="user_#{User::ALL.size}"}, render_users
+      end
+
+    end
+
+  end
+
+  def render_users
+    UsersTable.render(mock, User::ALL)
+  end
+
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification 
+name: fluid_table
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 3
+  - 2
+  - 0
+  version: 3.2.0
+platform: ruby
+authors: 
+- Brennan Dunn
+- Ken Collins
+- Donald Ball
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 3
+        - 2
+        - 0
+        version: 3.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 9
+        - 2
+        version: 0.9.2
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 45
+        segments: 
+        - 2
+        - 8
+        - 1
+        version: 2.8.1
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 53
+        segments: 
+        - 0
+        - 10
+        - 1
+        version: 0.10.1
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 5
+        - 0
+        version: 1.5.0
+  type: :development
+  version_requirements: *id005
+description: Paginated data tables for rails
+email: 
+- me@brennandunn.com
+- ken@metaskills.net
+- donald.ball@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/fluid_table.rb
+- lib/fluid_table/class_methods.rb
+- lib/fluid_table/column.rb
+- lib/fluid_table/context.rb
+- lib/fluid_table/instance_methods.rb
+- lib/fluid_table/version.rb
+- test/support/user.rb
+- test/support/users.html.erb
+- test/support/users_table.rb
+- test/test_helper.rb
+- test/units/column_test.rb
+- test/units/configuration_test.rb
+- test/units/render_test.rb
+- test/units/table_test.rb
+homepage: http://github.com/Decisiv/fluid_table/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Paginated data tables for rails
+test_files: 
+- test/support/user.rb
+- test/support/users.html.erb
+- test/support/users_table.rb
+- test/test_helper.rb
+- test/units/column_test.rb
+- test/units/configuration_test.rb
+- test/units/render_test.rb
+- test/units/table_test.rb