datatable 0.1.0alpha2

data/example_app/spec/helpers/aocolumn_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+describe "ruby_aocolumns" do
+
+  describe "using active relation" do
+
+    it "should have tests" do
+      pending
+    end
+
+  end
+
+  describe "using raw sql" do
+
+    before do
+      Object.send(:remove_const, :T) rescue nil
+      class T < Datatable::Base
+        sql <<-SQL
+          SELECT
+            orders.id,
+            orders.order_number
+          FROM
+            orders
+        SQL
+        columns(
+          {'orders.id' => {:type => :integer}},
+          {'orders.order_number' => {:type => :string}}
+        )
+      end
+      assign(:datatable, T)
+    end
+
+    it 'should return nil for all columns when no properties are set' do
+      T.columns(
+        { 'orders.id'           => {:type => :integer }},
+        { 'orders.order_number' => {:type => :string  }}
+      )
+      helper.send(:ruby_aocolumns)[0].should be_nil
+      helper.send(:ruby_aocolumns)[1].should be_nil
+    end
+
+    it 'should support asSorting' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :asSorting => 'asc'   }},
+        { 'orders.order_number' => {:type => :string,  :asSorting => 'desc'  }}
+      )
+      helper.send(:ruby_aocolumns)[0]['asSorting'].should == 'asc'
+      helper.send(:ruby_aocolumns)[1]['asSorting'].should == 'desc'
+    end
+
+    it 'should support bSearchable' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :bSearchable => true   }},
+        { 'orders.order_number' => {:type => :string,  :bSearchable => false  }}
+      )
+      helper.send(:ruby_aocolumns)[0]['bSearchable'].should == true
+      helper.send(:ruby_aocolumns)[0]['bSearchable'].should == true
+      helper.send(:ruby_aocolumns)[1]['bSearchable'].should == false
+    end
+
+    it 'should support bSortable' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :bSortable => true   }},
+        { 'orders.order_number' => {:type => :string,  :bSortable => false  }}
+      )
+      helper.send(:ruby_aocolumns)[0]['bSortable'].should == true
+      helper.send(:ruby_aocolumns)[1]['bSortable'].should == false
+    end
+
+    it 'should support bUseRendered' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :bUseRendered => true   }},
+        { 'orders.order_number' => {:type => :string,  :bUseRendered => false  }}
+      )
+      helper.send(:ruby_aocolumns)[0]['bUseRendered'].should == true
+      helper.send(:ruby_aocolumns)[1]['bUseRendered'].should == false
+    end
+
+    it 'should support bVisible' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :bVisible => false }},
+        { 'orders.order_number' => {:type => :string                      }}
+      )
+      helper.send(:ruby_aocolumns)[0]['bVisible'].should_not be_nil
+      helper.send(:ruby_aocolumns)[0]['bVisible'].should be_false
+      helper.send(:ruby_aocolumns)[1].should be_nil
+    end
+
+    it 'should support fnRender' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :fnRender => "function(oObj){'foo'}" }},
+        { 'orders.order_number' => {:type => :string,  :fnRender => "function(oObj){'bar'}" }}
+      )
+      helper.send(:ruby_aocolumns)[0]['fnRender'].should == "function(oObj){'foo'}"
+      helper.send(:ruby_aocolumns)[1]['fnRender'].should == "function(oObj){'bar'}"
+    end
+
+    it 'should support iDataSort' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :iDataSort => 1 }},
+        { 'orders.order_number' => {:type => :string,  :iDataSort => 0 }}
+      )
+      helper.send(:ruby_aocolumns)[0]['iDataSort'].should == 1
+      helper.send(:ruby_aocolumns)[1]['iDataSort'].should == 0
+    end
+
+    it 'should support mDataProp' do
+      pending "need to understand what it does before I can write a spec for it"
+    end
+
+    it 'should support sClass' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :sClass => 'foo' }},
+        { 'orders.order_number' => {:type => :string,  :sClass => 'bar' }}
+      )
+      helper.send(:ruby_aocolumns)[0]['sClass'].should == 'foo'
+      helper.send(:ruby_aocolumns)[1]['sClass'].should == 'bar'
+    end
+
+    it 'should support sDefaultContent' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :sDefaultContent => 'foo' }},
+        { 'orders.order_number' => {:type => :string,  :sDefaultContent => 'bar' }}
+      )
+      helper.send(:ruby_aocolumns)[0]['sDefaultContent'].should == 'foo'
+      helper.send(:ruby_aocolumns)[1]['sDefaultContent'].should == 'bar'
+    end
+
+    it 'should support sName' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :sName => 'foo' }},
+        { 'orders.order_number' => {:type => :string,  :sName => 'bar' }}
+      )
+      helper.send(:ruby_aocolumns)[0]['sName'].should == 'foo'
+      helper.send(:ruby_aocolumns)[1]['sName'].should == 'bar'
+    end
+
+    it "should support sSortDataType" do
+      pending "figure out if this is relevant for server side sorting?"
+    end
+
+    it 'should support sTitle' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :sTitle => 'foo' }},
+        { 'orders.order_number' => {:type => :string,  :sTitle => 'bar' }}
+      )
+      helper.send(:ruby_aocolumns)[0]['sTitle'].should == 'foo'
+      helper.send(:ruby_aocolumns)[1]['sTitle'].should == 'bar'
+    end
+
+    it 'should support sType' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :sType => 'string' }},
+        { 'orders.order_number' => {:type => :string,  :sType => 'numeric' }}
+      )
+      helper.send(:ruby_aocolumns)[0]['sType'].should == 'string'
+      helper.send(:ruby_aocolumns)[1]['sType'].should == 'numeric'
+    end
+
+    it 'should support sWidth' do
+      T.columns(
+        {           'orders.id' => {:type => :integer, :sWidth => '42px' }},
+        { 'orders.order_number' => {:type => :string,  :sWidth => '42%' }}
+      )
+      helper.send(:ruby_aocolumns)[0]['sWidth'].should == '42px'
+      helper.send(:ruby_aocolumns)[1]['sWidth'].should == '42%'
+    end
+
+  end
+
+  describe "aocolumn" do
+    before do
+      Object.send(:remove_const, :T) rescue nil
+      class T < Datatable::Base
+        sql <<-SQL
+          SELECT
+            orders.id,
+            orders.order_number
+          FROM
+            orders
+        SQL
+        columns(
+          {'orders.id' => {:type => :integer, :fnRender => "function(oObj){'foo'}" }},
+          {'orders.order_number' => {:type => :string}}
+        )
+      end
+      assign(:datatable, T)
+    end
+
+    it "should render functions properly" do
+      helper.send(:aocolumns_text).should contain("function(oObj){'foo'}")
+    end
+
+    it "linkto should replace fnRender" do
+      T.columns(
+        {'orders.id' => {:type => :integer, :fnRender => "function(oObj){'bar'}", :link_to => link_to('{{0}}', order_path('{{0}}')) }},
+        {'orders.order_number' => {:type => :string, :bVisible => false}}
+      )
+      true.should_not be_false
+    end
+
+  end
+
+end
+
+describe "fnRender" do
+  it "demonstrate simple exmaple"
+  it "use link_to when it's defined'"
+  it "barf when both link_to and fnRender are used"
+end
+
+#describe 'Creating links for SQL DataTables' do
+#
+#  before do
+#
+#    Object.send(:remove_const, :T) rescue nil
+#
+#    class T < Datatable::Base
+#      sql <<-SQL
+#        SELECT id FROM orders
+#      SQL
+#
+#      columns(
+#        {"orders.id" => {:type => :integer, :link_to => link_to('{{0}}', order_path('{{0}}')) }}
+#      )
+#    end
+#
+#    @params = {
+#      'iColumns' => 1,
+#      "bSearchable_0" => true
+#    }
+#  end
+#
+#  it 'should provide a link HTML element' do
+#    t = T.query(@params)
+#    T.columns['orders.id'][:link_to].should == "<a href=\"/orders/%7B%7B0%7D%7D\">{{0}}</a>"
+#  end
+#
+#end

data/example_app/spec/helpers/data_table_helper_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+
+describe Datatable::Helper do
+
+  describe "with sql defined class" do
+    before do
+      Object.send(:remove_const, :T) rescue nil
+      class T < Datatable::Base
+        sql <<-SQL
+          SELECT id FROM orders
+        SQL
+        columns(
+          {"orders.id" => {:type => :integer, :link_to => link_to('{{0}}', order_path('{{0}}')) }}
+        )
+      end
+      assign(:datatable, T)
+    end
+
+    describe "link_to" do
+      it "contains href" do
+        helper.datatable_javascript.should contain('<a href=\"/orders/%7B%7B0%7D%7D\">{{0}}</a>')
+      end
+    end
+
+  end
+
+
+  describe "active record test" do
+
+    before do
+      Object.send(:remove_const, :OrderTable) rescue nil
+      class OrderTable < Datatable::Base
+        set_model Order
+        column :order_number, :link_to => link_to('{{0}}', order_path('{{0}}'))
+        column :memo
+      end
+      assign(:datatable, OrderTable)
+    end
+
+    describe "link_to" do
+      it "contains href" do
+        helper.datatable_javascript.should contain('<a href=\"/orders/%7B%7B0%7D%7D\">{{0}}</a>')
+      end
+    end
+
+    describe "html emitter" do
+
+      it "should emit table" do
+        helper.datatable_html.should have_selector("table#datatable")
+      end
+
+      it "should emit table with 2 columns" do
+        helper.datatable_html.should have_selector("tr th:nth-child(2)")
+      end
+
+      it "should be html safe" do
+        helper.datatable_html.html_safe?.should be_true
+      end
+
+      it 'should include individual column search inputs if enabled' do
+        helper.datatable_html.should_not have_selector('tfoot th input')
+
+        OrderTable.option('individual_column_searching', true)
+        helper.datatable_html.should have_selector('tfoot th input')
+      end
+
+    end
+
+    describe "javascript emitter" do
+      it "should output a javascript tag" do
+        helper.datatable_javascript.should match(/script/)
+      end
+
+      it "should ouput the options" do
+        helper.request.path = 'ohai'
+        helper.datatable_javascript.should match('sAjaxSource')
+        helper.datatable_javascript.should match('ohai')
+      end
+
+      it "should be JSON" do
+        helper.datatable_javascript.should match(/"bProcessing":true/)
+      end
+
+      it "should be HTML safe" do
+        helper.datatable_javascript.html_safe?.should be_true
+      end
+
+    end
+
+    describe "javascript options" do
+
+      it "should output default options" do
+        expected = {
+          'oLanguage' => {
+          'sInfoFiltered' => '',
+          'sProcessing' => 'Loading'
+        },
+          'sAjaxSource' => '',
+          'sDom' => '<"H"lfr>t<"F"ip>',
+          'iDisplayLength' => 25,
+          'bProcessing' => true,
+          'bServerSide' => true,
+          'sPaginationType' => "full_numbers",
+          'aoColumns' => "aocolumns_place_holder",
+          'bJQueryUI' => Datatable::Base.config.jquery_ui ? true : false
+        }
+        if Datatable::Base.config.table_tools == true
+          expected['oTableTools'] = {
+            'sSwfPath' => 'flash/copy_cvs_xls_pdf.swf'
+          }
+        end
+        helper.send(:javascript_options).should == expected
+      end
+
+      it "should merge defaults with others" do
+        class OrderTable < Datatable::Base
+          option 'foo', 'bar'
+        end
+        helper.send(:javascript_options)['foo'].should == 'bar'
+      end
+
+      it 'should automatically set the jquery ui options based on the config' do
+        Datatable::Base.config do |config|
+          config.jquery_ui = nil
+        end
+        helper.send(:javascript_options)['bJQueryUI'].should == false
+
+        Datatable::Base.config do |config|
+          config.jquery_ui = false
+        end
+        helper.send(:javascript_options)['bJQueryUI'].should == false
+
+        Datatable::Base.config do |config|
+          config.jquery_ui = true
+        end
+        helper.send(:javascript_options)['bJQueryUI'].should == true
+
+
+      end
+
+
+    end
+  end
+end
+
+
+

data/example_app/spec/helpers/headings_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe "headings" do
+
+  describe "arel" do
+    before do
+      Object.send(:remove_const, :T) rescue nil
+      class T < Datatable::Base
+        set_model Order
+        column :order_number
+        column :memo
+      end
+      assign(:datatable, T)
+    end
+
+    it "should have tests"
+
+  end
+
+  describe "raw sql" do
+
+    before do
+      Object.send(:remove_const, :T) rescue nil
+      class T < Datatable::Base
+        sql <<-SQL
+          SELECT
+            orders.id,
+            orders.order_number,
+            customers.first_name,
+            customers.last_name,
+            orders.memo
+          FROM
+            orders
+          JOIN
+            customers
+          ON
+            customers.id = orders.customer_id
+        SQL
+        columns(
+          {'orders.id' => {:type => :integer}},
+          {'orders.order_number' => {:type => :string}},
+          {'customers.first_name' => {:type => :string}},
+          {'customers.last_name' => {:type => :string}},
+          {'orders.memo' => {:type => :string}}
+        )
+      end
+      assign(:datatable, T)
+    end
+
+    it 'should humanize headings by default'  do
+      ["Order Id", "Order Order Number", "Customer First Name", "Customer Last Name", "Order Memo"].each do |heading|
+        helper.datatable_html.should contain(heading)
+      end
+    end
+
+    it 'should use pretty headings when they are available' do
+      T.columns(
+        {'orders.id' => {:type => :integer, :heading => "Another heading that we specify manually"}},
+        {'orders.order_number' => {:type => :string, :heading => 'Yet another' }},
+        {'customers.first_name' => {:type => :string}},
+        {'customers.last_name' => {:type => :string}},
+        {'orders.memo' => {:type => :string, :heading => 'And another'}}
+      )
+      ["Another heading that we specify manually","Yet another" , "And another"].each do |heading|
+        helper.datatable_html.should contain(heading)
+      end
+    end
+
+  end
+
+end

data/example_app/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../../config/environment", __FILE__)
+require 'rspec/rails'
+
+require 'webrat'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+end

data/generators.txt

@@ -0,0 +1,6 @@
+find out about
+go to the github repo
+probably look for some kind of quick-start or quick-tu
+
+#=> print out what to add to the controller 
+  & print out what to add to the view

data/lib/datatable/active_record_dsl.rb

@@ -0,0 +1,49 @@
+module Datatable
+  module ActiveRecordDSL
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def relation
+        @relation
+      end
+
+      def set_model(model)
+        @model = model
+        @relation = model
+      end
+
+      def current_model
+        @inner_model || @model
+      end
+
+      def column(c, options={})
+
+        raise "set_model not called on #{self.name}" unless @model
+
+        @columns ||= ActiveSupport::OrderedHash.new
+
+        column_hash = {}
+        column_hash[:type] = current_model.columns.detect{ |col| col.name == c.to_s}.type
+        column_hash[:link_to] = options[:link_to]
+
+        @columns["#{current_model.table_name}.#{c}"] = column_hash
+
+        @relation= @relation.select(current_model.arel_table[c])
+      end
+
+      # TODO: Change to joins to match arel
+      def join(association, &block)
+
+        @inner_model = current_model.reflect_on_association(association).klass
+        @relation = @relation.joins(association)
+        instance_eval(&block) if block_given?
+        @inner_model = nil
+      end
+
+    end
+
+  end
+end

data/lib/datatable/errors.rb

@@ -0,0 +1,5 @@
+module Datatable
+  class DatatableException < StandardError; end
+  class UknownQueryParameter < DatatableException; end
+end
+