rails-tables 0.3.3 → 0.4.0

data/app/tables/column.rb

@@ -1,17 +1,22 @@
 class Column
 
-  attr_accessor :name, :column_name, :referring_column_name, :render_with, :sortable, :blank_value
-  def initialize(name, *args)
+  attr_accessor :model, :name, :method, :column_source, :render_with, :sortable, :searchable, :blank_value
+  def initialize(model, name, *args)
+    self.model = model
     self.name = name
 
     attributes = args.pop || {}
-    self.column_name = attributes.fetch(:column_name, name)
-    self.referring_column_name = attributes.fetch(:referring_column_name, nil)
+    self.method = attributes.fetch(:method, name)
+    self.column_source = attributes.fetch(:column_source, '')
     self.render_with = attributes.fetch(:render_with, :default_render)
     self.sortable = attributes.fetch(:sortable, true)
+    self.searchable = attributes.fetch(:searchable, true)
     self.blank_value = attributes.fetch(:blank_value, '–')
 
     define_singleton_method :render do |view, object|
+      self.column_source.split('.').each do |relation|
+        object = object.try(:send, relation)
+      end
       if self.render_with.kind_of? Symbol
         content = self.send(self.render_with, view, object)
       else
@@ -21,39 +26,31 @@ class Column
     end
   end
 
-  def render(object)
-    self.relation_chain.each do |relation|
-      object = object.send(relation)
-    end
-  end
-
-
   def default_render(view, object)
-    property = object.send(self.column_name)
+    property = object.try(:send, self.method)
     property if not property.nil?
   end
   def self_referential_link(view, object)
-    property = object.send(self.column_name)
+    property = object.try(:send, self.method)
     view.link_to property, object if not property.nil?
   end
   def related_link(view, object)
-    property = object.send(self.column_name)
+    property = object.try(:send, self.method)
     view.link_to property, property if not property.nil?
   end
-  def related_link_list(view, object)
-    property = object.send(self.referring_column_name)
-    property.collect { |related_object| related_link(view, related_object) }.join(', ') if not property.nil?
+  def related_link_list(view, objects)
+    objects.map{ |object| related_link(view, object) }.reject(&:nil?).join(', ') if not objects.nil?
   end
   def time(view, object)
-    property = object.send(self.column_name)
+    property = object.try(:send, self.method)
     property.strftime("%I:%M%p") if not property.nil?
   end
   def date(view, object)
-    property = object.send(self.column_name)
+    property = object.try(:send, self.method)
     property.strftime("%m/%d/%Y") if not property.nil?
   end
   def datetime(view, object)
-    property = object.send(self.column_name)
+    property = object.try(:send, self.method)
     property.strftime("%m/%d/%Y at %I:%M%p") if not property.nil?
   end
 

data/app/tables/datatable.rb

@@ -12,15 +12,13 @@ class_attribute :source
     self.source = Rails.application.routes.url_helpers.send(source, format: "json")
   end
 
-class_attribute :defaults
-self.defaults = {
-  initial_orderings: {},
-}
+class_attribute :initial_orderings
   def self.initial_ordering(orderings)
-    self.initial_orderings orderings
+    self.set_initial_orderings orderings
   end
-  def self.initial_orderings(orderings)
-    self.defaults[:initial_orderings].merge! orderings
+  def self.set_initial_orderings(orderings)
+    self.initial_orderings = {} if self.initial_orderings.nil?
+    self.initial_orderings.merge! orderings
   end
 
   def html_data
@@ -28,8 +26,8 @@ self.defaults = {
     if self.class.source?
       options[:source] = self.class.source
     end
-    if self.defaults.has_key? :initial_orderings
-      self.class.defaults[:initial_orderings].each do |column, order|
+    unless self.initial_orderings.nil?
+      self.class.initial_orderings.each do |column, order|
         options["#{column}_ordering"] = order.to_s
       end
     end
@@ -54,62 +52,76 @@ attr_accessor :view, :scopes
     }
   end
 
-class_attribute :columns, :searches, :authorized_scopes, :match_any
+class_attribute :columns, :column_factory
   def self.column(name, *args)
     arguments = args.pop || {}
-    self.columns = [] if self.columns.nil?
-    self.columns << Column.new(name, arguments)
+    self.column_factory = [] if self.column_factory.nil?
+    self.column_factory << { name: name, args: arguments }
   end
-  def self.search_by(name, *args)
-    arguments = args.pop || {}
-    self.searches = [] if self.searches.nil?
-    self.searches << Search.new(name, self, arguments)
+  def columns
+    @columns ||= self.column_factory.map{ |new_column| Column.new(self.model, new_column[:name], new_column[:args]) }
   end
+
+class_attribute :match_any
   self.match_any = true
   def self.match_all_columns
     self.match_any = false
   end
 
+attr_accessor :joins
+  def joins
+    @joins ||= self.columns.map(&:column_source).uniq.reject(&:blank?)
+  end
+attr_accessor :searches
+  def searches
+    @searches ||= self.columns.select(&:searchable).select{|c| c.column_source.present?}
+  end
+
 private
 
   def objects
+    query = self.model
+    self.joins.each do |join|
+      query = query.uniq.includes{ join.split('.').inject((strs.present? ? self : nil), :__send__).outer }
+    end
     if sortable
-      objects = self.model.reorder("#{sort_column} #{sort_direction}")
-    else
-      objects = self.model
+      sort_expression = sort
+      query = query.reorder{ my{sort_expression} }#("#{sort_column} #{sort_direction}")
     end
     self.scopes.each do |scope|
-      objects = scope.call(objects)
+      query = scope.call(query)
     end
     if params[:sSearch].present?
-      objects = objects.send("#{self.name}_search", params[:sSearch])
+      search_expression = search(params[:sSearch])
+      query = query.where{ my{search_expression} }
     end
-    objects = objects.paginate(page: page, per_page: per_page)
-    objects
+    query = query.paginate(page: page, per_page: per_page)
+  end
+  
+  def sortable
+    self.columns.map{ |column| column.sortable }[params[:iSortCol_0].to_i] unless params[:bUseDefaultSort] == 'true'
+  end
+  def sort
+    column = self.columns[params[:iSortCol_0].to_i]
+    direction = params[:sSortDir_0] == "asc" ? 1 : -1
+    Squeel::Nodes::KeyPath.new(column.column_source.split('.') << Squeel::Nodes::Order.new(column.method, direction))
   end
 
-  def search(objects, terms)
-    self.searches.each do |search|
-      objects = search.search(objects, terms)
-    end
+  def search(terms)
+    terms = terms.split if terms.is_a? String
+    self.searches.map do |column|
+      terms.map do |word|
+        Squeel::Nodes::KeyPath.new(column.column_source.split('.') << Squeel::Nodes::Stub.new(column.method)) =~ "%#{word}%"
+      end.compact.inject(&:|)
+    end.compact.inject(&:|)
   end
-  
+
   def page
     params[:iDisplayStart].to_i/per_page + 1
   end
   def per_page
     params[:iDisplayLength].to_i > 0 ? params[:iDisplayLength].to_i : 10
   end
-  
-  def sortable
-    self.columns.map{ |column| column.sortable }[params[:iSortCol_0].to_i] unless params[:bUseDefaultSort] == 'true'
-  end
-  def sort_column
-    self.columns.map(&:column_name)[params[:iSortCol_0].to_i]
-  end
-  def sort_direction
-    params[:sSortDir_0] == "asc" ? "asc" : "desc"
-  end
 
   def data
     objects.map do |object|

data/lib/rails-tables/model_additions.rb

@@ -1,22 +1,11 @@
-def has_datatable(*args)
-  arguments = args.pop || {}
-  name = arguments.fetch(:name, 'datatable')
-  klass = arguments.fetch(:klass, "#{self.name.pluralize}Datatable")
-  cattr_accessor name
-  self.send("#{name}=", klass.constantize.new(name, self))
-  self.class.instance_eval do
-    define_method "#{name}_search" do |terms|
-      searches =
-        self.datatable.searches.map do |search|
-          self.instance_exec search.column_name, terms, &search.search
-        end.inject do |t, expr|
-          if self.datatable.match_any
-            t | expr
-          else
-            t & expr
-          end
-        end
-      self.where{ searches }
-    end
+module RailsTables::ModelAdditions
+  def has_datatable(*args)
+    arguments = args.pop || {}
+    name = arguments.fetch(:name, 'datatable')
+    klass = arguments.fetch(:klass, "#{self.name.pluralize.underscore}_datatable").camelize
+    cattr_accessor name
+    self.send("#{name}=", klass.constantize.new(name, self))
   end
-end
+end
+
+ActiveRecord::Base.extend RailsTables::ModelAdditions

data/lib/rails-tables/version.rb

@@ -1,3 +1,3 @@
 module RailsTables
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-tables
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-21 00:00:00.000000000 Z
+date: 2012-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -43,6 +43,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: jquery-datatables-rails
   requirement: !ruby/object:Gem::Requirement
@@ -91,7 +107,8 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.0.11
-description: A clean jQuery datatables DSL.
+description: RailsTables is a simple DSL built on top of jquery-datatables-rails to
+  quickly compose performant jQuery datatables for your Rails app.
 email:
 - dev@chriskeele.com
 executables: []
@@ -101,7 +118,6 @@ files:
 - app/assets/javascripts/rails-tables.js.coffee
 - app/tables/column.rb
 - app/tables/datatable.rb
-- app/tables/search.rb
 - config/routes.rb
 - lib/rails-tables/engine.rb
 - lib/rails-tables/model_additions.rb

data/app/tables/search.rb

@@ -1,56 +0,0 @@
-class Search
-  cattr_accessor :strategies
-  self.strategies = {
-    contains_strategy: {
-      type: :string,
-      match_with: '%%%s%%'
-    },
-    starts_with_strategy: {
-      type: :string,
-      match_with: '%s%%'
-    },
-    ends_with_strategy: {
-      type: :string,
-      match_with: '%%%s'
-    }
-  }
-  attr_accessor :name, :table, :column_name, :search_with, :match_any, :split_terms
-  def initialize(name, table, *args)
-    self.name = name
-    self.table = table
-
-    attributes = args.pop || {}
-    self.column_name = attributes.fetch(:column_name, name)
-    self.search_with = attributes.fetch(:search_with, :contains_strategy)
-    self.match_any = attributes.fetch(:match_any, true)
-    self.split_terms = attributes.fetch(:split_terms, true)
-
-    
-    define_singleton_method :search do
-      if self.search_with.kind_of? Symbol
-        strategy_builder(self.search_with, self.match_any, self.split_terms)
-      else
-        self.search_with(self.match_any, self.split_terms)
-      end
-    end
-  end
-
-  def strategy_builder(strategy_name, match_any, split_terms)
-    Proc.new do |field, terms|
-      if split_terms
-        terms = terms.split
-      else
-        terms = [terms]
-      end
-      terms.map{|s| Search.strategies[strategy_name][:match_with] % s}.map do |term|
-        Squeel::Nodes::Predicate.new(Squeel::Nodes::Stub.new(field), :matches, term)
-      end.inject do |t, expr|
-        if match_any
-          t | expr
-        else
-          t & expr
-        end
-      end
-    end
-  end
-end