tableficate 0.0.1

data/lib/tableficate/utils.rb

@@ -0,0 +1,7 @@
+module Tableficate
+  module Utils
+    def self.template_path(template, theme = '')
+      File.join(['tableficate', theme, template].delete_if(&:blank?))
+    end
+  end
+end

data/lib/tableficate/version.rb

@@ -0,0 +1,3 @@
+module Tableficate
+  VERSION = "0.0.1"
+end

data/lib/tableficate.rb

@@ -0,0 +1,17 @@
+require 'tableficate/engine'
+require 'tableficate/exceptions'
+require 'tableficate/utils'
+require 'tableficate/finder'
+require 'tableficate/column'
+require 'tableficate/action_column'
+require 'tableficate/filters/filter'
+require 'tableficate/filters/input_filters'
+require 'tableficate/filters/select_filter'
+require 'tableficate/table'
+require 'tableficate/helper'
+require 'tableficate/base'
+require 'tableficate/active_record_extension'
+require 'tableficate/version'
+
+ActionView::Base.send(:include, Tableficate::Helper)
+ActiveRecord::Base.send(:include, Tableficate::ActiveRecordExtension)

data/spec/action_column_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Tableficate::ActionColumn do
+  before(:all) do
+    @action_column = Tableficate::ActionColumn.new(nil, nil) do
+      Actions!
+    end
+  end
+
+  it 'should always have sorting off ' do
+    @action_column.show_sort?.should be false
+  end
+
+  it 'should always indicate that it is not sorted' do
+    @action_column.is_sorted?.should be false
+  end
+
+  it 'should have a blank name' do
+    @action_column.name.should == ''
+  end
+end

data/spec/active_record_extension_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'Tableficate::ActiveRecordExtention' do
+  it 'should add and retreive data from the scope' do
+    scope = NobelPrizeWinner.tableficate_ext
+    scope.tableficate_add_data(:name, 'Aaron')
+    scope.tableficate_get_data.should == {name: 'Aaron'}
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Tableficate::Base do
+  it 'should set the scope' do
+    class SymbolScope < Tableficate::Base
+      scope(:nobel_prize_winner)
+    end
+    SymbolScope.send(:instance_variable_get, '@scope').should == NobelPrizeWinner
+
+    class BlockScope < Tableficate::Base
+      scope do
+        NobelPrizeWinner.joins(:nobel_prizes)
+      end
+    end
+    BlockScope.send(:instance_variable_get, '@scope').should == NobelPrizeWinner.joins(:nobel_prizes)
+
+    class NoScope < Tableficate::Base; end
+    lambda {NoScope.tableficate({})}.should raise_error(Tableficate::MissingScope)
+  end
+
+  it 'should allow for a default order' do
+    class DefaultOrder < Tableficate::Base
+      scope(:nobel_prize_winner)
+
+      default_sort(:first_name)
+    end
+    npw = DefaultOrder.tableficate({})
+    npw.order_values.should == ["#{npw.table_name}.first_name ASC"]
+    npw.reverse_order_value.should == nil
+
+    class DefaultOrderDesc < Tableficate::Base
+      scope(:nobel_prize_winner)
+
+      default_sort(:first_name, 'desc')
+    end
+    npw = DefaultOrderDesc.tableficate({})
+    npw.order_values.should == ["#{npw.table_name}.first_name ASC"]
+    npw.reverse_order_value.should be true
+
+    class DefaultOrderWithOverride < Tableficate::Base
+      scope(:nobel_prize_winner)
+
+      default_sort(:full_name)
+
+      column(:full_name, sort: 'first_name ASC, last_name ASC')
+    end
+    npw = DefaultOrderWithOverride.tableficate({})
+    npw.order_values.should == ["first_name ASC, last_name ASC"]
+    npw.reverse_order_value.should == nil
+
+    class DefaultOrderWithOverrideDesc < Tableficate::Base
+      scope(:nobel_prize_winner)
+
+      default_sort(:full_name, 'desc')
+
+      column(:full_name, sort: 'first_name ASC, last_name ASC')
+    end
+    npw = DefaultOrderWithOverrideDesc.tableficate({})
+    npw.order_values.should == ["first_name ASC, last_name ASC"]
+    npw.reverse_order_value.should be true
+  end
+
+  it 'should filter using match: "contains"' do
+    class FilterByContainsInput < Tableficate::Base
+      scope(:nobel_prize_winner)
+
+      filter(:first_name, match: 'contains')
+    end
+    npw = FilterByContainsInput.tableficate({filter: {first_name: 'Al'}})
+    npw.size.should == 1
+    npw.first.first_name.should == 'Albert'
+  end
+
+  it 'should filter multiple inputs using match: "contains"' do
+    class FilterByContainsInput < Tableficate::Base
+      scope(:nobel_prize_winner)
+
+      filter(:first_name, match: 'contains')
+    end
+    npw = FilterByContainsInput.tableficate({filter: {first_name: ['Al', 'Mar']}})
+    npw.size.should == 2
+    npw.first.first_name.should == 'Albert'
+    npw.last.first_name.should == 'Marie'
+  end
+
+  it 'should allow custom block filters' do
+    class BlockFilter < Tableficate::Base
+      scope(:nobel_prize_winner)
+
+      filter(:full_name) do |value, scope|
+        first_name, last_name = value.split(/\s+/)
+
+        if last_name.nil?
+          scope.where(['first_name LIKE ? OR last_name LIKE ?', first_name, first_name])
+        else
+          scope.where(['first_name LIKE ? AND last_name LIKE ?', first_name, last_name])
+        end 
+      end 
+    end
+    npw = BlockFilter.tableficate({filter: {full_name: 'Bohr'}})
+    npw.first.first_name.should == 'Niels'
+  end
+end

data/spec/column_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Tableficate::Column do
+  it 'should show the header provided or default to the column name' do
+    column = Tableficate::Column.new(nil, :first_name)
+    column.header.should == 'First Name'
+
+    column = Tableficate::Column.new(nil, :first_name, header: 'Given Name')
+    column.header.should == 'Given Name'
+  end
+
+  it 'should show the value from the database field if no alternative is provided' do
+    row = NobelPrizeWinner.find_by_first_name('Norman')
+    column = Tableficate::Column.new(nil, :first_name)
+
+    column.value(row).should == 'Norman'
+  end
+  it 'should return the value provided from the block' do
+    row = NobelPrizeWinner.find_by_first_name_and_last_name('Norman', 'Borlaug')
+    column = Tableficate::Column.new(nil, :full_name) do |row|
+      [row.first_name, row.last_name].join(' ')
+    end
+
+    column.value(row).should == 'Norman Borlaug'
+  end
+
+  it 'should allow sorting to be turned on and off' do
+    column = Tableficate::Column.new(nil, :first_name, show_sort: false)
+    column.show_sort?.should be false
+
+    column = Tableficate::Column.new(nil, :first_name, show_sort: true)
+    column.show_sort?.should be true
+
+    # defaults to false
+    column = Tableficate::Column.new(nil, :first_name)
+    column.show_sort?.should be false
+  end
+
+  it 'should indicate whether a column is sorted or not' do
+    table = Tableficate::Table.new(nil, NobelPrizeWinner.limit(1), {}, {current_sort: {column: :first_name, dir: 'asc'}})
+
+    column = Tableficate::Column.new(table, :first_name)
+    column.is_sorted?('asc').should be true
+
+    column = Tableficate::Column.new(table, :first_name)
+    column.is_sorted?('desc').should be false
+
+    column = Tableficate::Column.new(table, :first_name)
+    column.is_sorted?.should be true
+
+    column = Tableficate::Column.new(table, :last_name)
+    column.is_sorted?.should be false
+  end
+end

data/spec/filter_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Tableficate::Filter do
+  before(:all) do
+    @table = Tableficate::Table.new(nil, NobelPrizeWinner.limit(1), {}, {})
+    @table.column(:first_name, header: 'Given Name')
+  end
+
+  it 'should find the correct template type' do
+    Tableficate::Filter.new(@table, :first_name).template.should == 'filter'
+  end
+
+  it 'should use the provided label or default to the column header' do
+    Tableficate::Filter.new(@table, :first_name).label.should == 'Given Name'
+    Tableficate::Filter.new(@table, :first_name, label: 'First').label.should == 'First'
+  end
+
+  it 'should provide a field name' do
+    Tableficate::Filter.new(@table, :first_name).field_name.should == "#{@table.as}[filter][first_name]"
+  end
+
+  it 'should provide a field value when given params or a blank value' do
+    Tableficate::Filter.new(@table, :first_name).field_value({filter: {first_name: 'Aaron'}}).should == 'Aaron'
+    Tableficate::Filter.new(@table, :first_name).field_value({}).should == ''
+  end
+
+  it 'should allow for filters that do not match a particular field' do
+    Tableficate::Filter.new(@table, :custom_field).label.should == 'Custom Field'
+  end
+end

data/spec/finder_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Tableficate::Finder do
+  it 'should filter based on single input passed in' do
+    # exact input
+    npw = NobelPrizeWinner.tableficate({filter: {first_name: 'Albert'}})
+    npw.size.should == 1
+    npw.first.first_name.should == 'Albert'
+    npw = NobelPrizeWinner.tableficate({filter: {first_name: 'Al'}})
+    npw.size.should == 0
+  end
+
+  it 'should filter based on multiple inputs passed in' do
+    npw = NobelPrizeWinner.tableficate({filter: {first_name: ['Albert', 'Marie']}})
+    npw.size.should == 2
+    npw.first.first_name.should == 'Albert'
+    npw.last.first_name.should == 'Marie'
+    npw = NobelPrizeWinner.tableficate({filter: {first_name: ['Al', 'Mar']}})
+    npw.size.should == 0
+  end
+
+  it 'should attach the table name to the fields from the primary table to avoid ambiguity' do
+    npw = NobelPrizeWinner.joins(:nobel_prizes).tableficate({sort: 'first_name'})
+    npw.order_values.should == ["#{npw.table_name}.first_name ASC"]
+
+    # secondary table fields are left vague for maximum flexibility
+    npw = NobelPrizeWinner.joins(:nobel_prizes).tableficate({sort: 'year'})
+    npw.order_values.should == ["year ASC"]
+  end
+
+  it 'should allow ranged input filters' do
+    np = NobelPrize.tableficate({filter: {year: {start: 1900, stop: 1930}}})
+    np.size.should == 4
+  end
+end

data/spec/input_filter_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Tableficate::InputFilter do
+  before(:all) do
+    @table = Tableficate::Table.new(nil, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
+    @table.column(:first_name)
+  end
+
+  it 'should find the correct template type' do
+    Tableficate::InputFilter.new(@table, :first_name).template.should == 'input_filter'
+
+    Tableficate::InputFilter.new(@table, :first_name, field_options: {type: 'email'}).template.should == 'input_filter'
+
+    file = File.open('app/views/tableficate/_email_input_filter.html.erb', 'w')
+    Tableficate::InputFilter.new(@table, :first_name, field_options: {type: 'email'}).template.should == 'email_input_filter'
+    File.delete(file.path)
+
+    file = File.open('app/views/tableficate/_email_input_filter.html.haml', 'w')
+    Tableficate::InputFilter.new(@table, :first_name, field_options: {type: 'email'}).template.should == 'email_input_filter'
+    File.delete(file.path)
+  end
+end
+
+describe Tableficate::InputStartFilter do
+  before(:all) do
+    @table = Tableficate::Table.new(nil, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
+    @table.column(:year)
+  end
+
+  it 'should append "[start]" to field_name' do
+    Tableficate::InputStartFilter.new(@table, :year).field_name == "#{@table.as}[filter][year][start]"
+  end
+
+  it 'should append "_start" to the name' do
+    Tableficate::InputStartFilter.new(@table, :year).name == :year_start
+  end
+
+  it 'should provide a field value when given params or a blank value' do
+    Tableficate::InputStartFilter.new(@table, :year).field_value({filter: {year: {start: '2011'}}}).should == '2011'
+    Tableficate::InputStartFilter.new(@table, :year).field_value({}).should == ''
+  end
+end
+
+describe Tableficate::InputStopFilter do
+  before(:all) do
+    @table = Tableficate::Table.new(nil, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
+    @table.column(:year)
+  end
+
+  it 'should append "[stop]" to field_name' do
+    Tableficate::InputStopFilter.new(@table, :year).field_name == "#{@table.as}[filter][year][stop]"
+  end
+
+  it 'should append "_stop" to the name' do
+    Tableficate::InputStopFilter.new(@table, :year).name == :year_stop
+  end
+
+  it 'should provide a field value when given params or a blank value' do
+    Tableficate::InputStopFilter.new(@table, :year).field_value({filter: {year: {stop: '2011'}}}).should == '2011'
+    Tableficate::InputStopFilter.new(@table, :year).field_value({}).should == ''
+  end
+end
+
+describe Tableficate::InputRangeFilter do
+  before(:all) do
+    @table = Tableficate::Table.new(nil, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
+    @table.column(:year)
+  end
+
+  it 'should find the correct template type' do
+    Tableficate::InputRangeFilter.new(@table, :year).template.should == 'input_range_filter'
+  end
+
+  it 'should create a start and stop input' do
+    filter = Tableficate::InputRangeFilter.new(@table, :year)
+
+    filter.start.is_a?(Tableficate::InputStartFilter).should be true
+    filter.stop.is_a?(Tableficate::InputStopFilter).should be true
+  end
+
+  it 'should use the :start and :stop option hashes for the individual filters and default any values not passed to the range options provided' do
+    filter = Tableficate::InputRangeFilter.new(@table, :year, label: 'Nobel Prize Won In')
+    filter.start.label.should == 'Nobel Prize Won In'
+    filter.stop.label.should == 'Nobel Prize Won In'
+
+    filter = Tableficate::InputRangeFilter.new(@table, :birth_date, label: 'Nobel Prize Won In', start: {label: 'Nobel Prize Won Between'}, stop: {label: 'and'})
+    filter.start.label.should == 'Nobel Prize Won Between'
+    filter.stop.label.should == 'and'
+  end
+end

data/spec/select_filter_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Tableficate::SelectFilter do
+  it 'should find the correct template type' do
+    table = Tableficate::Table.new(nil, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
+    table.column(:year)
+
+    Tableficate::SelectFilter.new(table, :year, []).template.should == 'select_filter'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+ENV["RAILS_ENV"] ||= 'test'
+
+require File.expand_path("../test_app/config/environment", __FILE__)

data/spec/table_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Tableficate::Table do
+  before(:each) do
+    @table = Tableficate::Table.new(nil, NobelPrizeWinner.limit(1), {}, {current_sort: {column: :first_name, dir: 'asc'}})
+  end
+
+  it 'should have the current sort if provided' do
+    @table.current_sort.should == {column: :first_name, dir: 'asc'}
+  end
+
+  it 'should use the :as option or default to the table_name of the scope' do
+    Tableficate::Table.new(nil, NobelPrizeWinner.limit(1), {as: 'npw'}, {}).as.should == 'npw'
+    @table.as.should == 'nobel_prize_winners'
+  end
+
+  it 'should add a Column' do
+    @table.column(:first_name)
+    @table.column(:last_name)
+
+    @table.columns.first.name.should == :first_name
+    @table.columns.first.is_a?(Tableficate::Column).should be true
+    @table.columns.last.name.should == :last_name
+  end
+
+  it 'should indicate that it is sortble if any column is sortable' do
+    @table.column(:first_name)
+    @table.show_sort?.should be false
+
+    @table.column(:last_name, show_sort: true)
+    @table.show_sort?.should be true
+  end
+
+  it 'should overwrite the column sorting unless it is provided' do
+    @table.column(:first_name)
+    @table.column(:last_name, show_sort: true)
+
+    @table.columns.first.show_sort?.should be false
+    @table.columns.last.show_sort?.should be true
+
+    table = Tableficate::Table.new(nil, NobelPrizeWinner.limit(1), {show_sorts: true}, {})
+    table.column(:first_name)
+    table.column(:last_name, show_sort: false)
+
+    table.columns.first.show_sort?.should be true
+    table.columns.last.show_sort?.should be false
+  end
+
+  it 'should add an ActionColumn' do
+    @table.actions do
+      Action!
+    end
+
+    @table.columns.first.is_a?(Tableficate::ActionColumn).should be true
+  end
+
+  it 'should determine whether any columns are sortable' do
+    @table.column(:first_name, show_sort: true)
+
+    @table.show_sort?.should be true
+
+    table = Tableficate::Table.new(nil, NobelPrizeWinner.limit(1), {show_sorts: true}, {})
+    table.column(:first_name, show_sort: false)
+
+    table.show_sort?.should be false
+  end
+
+  it 'should add an InputFilter' do
+    @table.input_filter(:first_name, label: 'First')
+    @table.input_filter(:last_name, label: 'Last')
+
+    @table.filters.first.name.should == :first_name
+    @table.filters.first.is_a?(Tableficate::InputFilter).should be true
+    @table.filters.last.name.should == :last_name
+  end
+
+  it 'should add an InputRangeFilter' do
+    @table.input_range_filter(:first_name, label: 'First')
+    @table.input_range_filter(:last_name, label: 'Last')
+
+    @table.filters.first.name.should == :first_name
+    @table.filters.first.is_a?(Tableficate::InputRangeFilter).should be true
+    @table.filters.last.name.should == :last_name
+  end
+
+  it 'should add an SelectFilter' do
+    @table.select_filter(:first_name, {}, label: 'First')
+    @table.select_filter(:last_name, {}, label: 'Last')
+
+    @table.filters.first.name.should == :first_name
+    @table.filters.first.is_a?(Tableficate::SelectFilter).should be true
+    @table.filters.last.name.should == :last_name
+  end
+end

data/spec/test_app/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+log/*.log
+tmp/
+.sass-cache/

data/spec/test_app/Gemfile

@@ -0,0 +1,21 @@
+source 'http://rubygems.org'
+
+gem 'rails', '3.1.0'
+
+gem 'sqlite3'
+
+group :assets do
+  gem 'sass-rails', '~> 3.1.0'
+  gem 'coffee-rails', '~> 3.1.0'
+  gem 'uglifier'
+end
+
+gem 'jquery-rails'
+
+gem 'tableficate', path: '../../'
+
+group :test do
+  gem 'turn', :require => false
+  gem 'rspec'
+  gem 'capybara'
+end