rails-tables 0.5.1 → 0.6.0

data/README.md

@@ -12,7 +12,7 @@ A clean jQuery datatables DSL
 [jqd-railscast]: http://railscasts.com/episodes/340-datatables (Episode #340: Datatables)
 [squeel]: https://github.com/ernie/squeel (Squeel: ActiveRecord 3, improved)
 
-Version: 0.5.1
+Version: 0.6.0
 
 Please refer to the [RailsTables Wiki][wiki] for:
 

data/app/tables/column.rb

@@ -1,10 +1,11 @@
 class Column
 
-  attr_accessor :model, :name, :method, :column_source, :render_with, :blank_value, :virtual, :sortable, :searchable
+  attr_accessor :table_name, :model, :name, :method, :column_source, :render_with, :blank_value, :virtual, :sortable, :searchable
 
-  def initialize(model, name, *args)
+  def initialize(table_name, model, name, *args)
+    self.table_name = table_name
     self.model = model
-    self.name = name.to_s
+    self.name = name
 
     attributes = args.pop || {}
     self.method = attributes.fetch(:method, name).to_s
@@ -15,7 +16,12 @@ class Column
     self.sortable = attributes.fetch(:sortable, !self.virtual)
     self.searchable = attributes.fetch(:searchable, !self.virtual)
 
-    raise Exception, "Virtual columns are required to supply a render method (render_with: lambda): Column #{self.name}, Model: #{self.model.name}" if virtual and not attributes.has_key?(:render_with)
+    if virtual and not attributes.has_key?(:render_with)
+      raise Exception,
+        "Virtual columns are required to supply a render method (render_with: lambda): "\
+        "Column: #{self.name}, Datatable: #{self.table_name}, Model: #{self.model.name}"
+    end
+
     self.render_with = attributes.fetch(:render_with, :default_render)
     self.blank_value = attributes.fetch(:blank_value, '–')
 
@@ -49,15 +55,11 @@ private
   end
   def related_link(view, object)
     property = object.try(:send, self.method)
-    view.link_to property, property if not property.nil?
+    view.link_to property, object if not property.nil?
   end
   def related_link_list(view, objects)
     objects.reject(&:blank?).map{ |object| related_link(view, object).strip }.join(', ') if not objects.nil?
   end
-  # def unique_related_link_list(view, objects, field)
-  #   binding.pry if objects.length > 1
-  #   related_link_list(view, objects.uniq{|o| o.send(field)} )
-  # end
   def time(view, object)
     property = object.try(:send, self.method)
     property.strftime("%I:%M%p") if not property.nil?

data/app/tables/datatable.rb

@@ -3,12 +3,17 @@ class Datatable
   include Datatable::Searching
   delegate :params, to: 'self.view'
 
-  attr_accessor :name, :model, :view, :scopes
+  attr_accessor :name, :root, :model, :view
 
-  # Called in has_datatable for model
+  # Called in has_datatable for model, or on an ActiveRecord::Relation in method_missing
   def initialize(name, model)
     self.name = name
-    self.model = model
+    self.root = self.model = model
+  end
+
+  def set_root(root)
+    self.root = root
+    self
   end
 
   # Render data attributes for table for view
@@ -27,10 +32,8 @@ class Datatable
   end
 
   # Pass in view and scope table for controller
-  def render_with(view, *args)
-    arguments = args.pop || {}
+  def render_with(view)
     self.view = view
-    self.scopes = Array(arguments.fetch(:scopes, []))
     return self
   end
 
@@ -54,15 +57,15 @@ class Datatable
   end
 
   class_attribute :columns, :column_factory
-  # Allow user defined columns, lazily instanciate later after 'self.model' is defined
+  # Allow user defined columns, lazily instanciate later after 'self.root' is defined
   def self.column(name, *args)
     arguments = args.pop || {}
     self.column_factory = [] if self.column_factory.nil?
-    self.column_factory << { name: name, args: arguments }
+    self.column_factory << { name: name.to_s, args: arguments }
   end
   # Lazily instanciates and caches columns
   def columns
-    @columns ||= self.column_factory.map{ |new_column| Column.new(self.model, new_column[:name], new_column[:args]) }
+    @columns ||= self.column_factory.map{ |new_column| Column.new(self.class.name, self.model, new_column[:name], new_column[:args]) }
   end
 
   class_attribute :joins
@@ -80,14 +83,11 @@ private
 
   # Compose query to fetch objects from database
   def objects
-    query = self.model.uniq
+    query = self.root.uniq
     self.joins.each do |join|
       query = query.joins{ join.split('.').inject((join.present? ? self : nil), :__send__).outer }
       query = query.includes{ join.split('.').inject((join.present? ? self : nil), :__send__).outer }
     end
-    self.scopes.each do |scope|
-      query = scope.call(query)
-    end
     query = query.reorder{ my{sort} } if sortable
     query = query.where{ my{search(params[:sSearch])} } if searchable
     query = query.paginate(page: page, per_page: per_page)

data/app/tables/datatable/searching.rb

@@ -17,8 +17,11 @@ module Datatable::Searching
     end
   end
 
-    attr_accessor :searches
+  # InstanceMethods
+  attr_accessor :searches
+
 private
+
   def searchable
     params[:sSearch].present?
   end
@@ -33,7 +36,7 @@ private
   # Build Squeel Stubs for search
   def search(terms)
     terms = terms.split if terms.is_a? String
-    searchables.map do |search|
+    @searches.map do |search|
       terms.map do |word|
         Squeel::Nodes::KeyPath.new(search[:column_source].split('.') << Squeel::Nodes::Stub.new(search[:method])) =~ "%#{word}%"
       end.compact.inject(&:|)

data/app/tables/datatable/sorting.rb

@@ -18,6 +18,7 @@ module Datatable::Sorting
 
   end
 
+  # InstanceMethods
 private
   # Check if table is sortable
   def sortable

data/lib/rails-tables.rb

@@ -1,5 +1,7 @@
 require "rails-tables/engine"
+require "rails-tables/exceptions"
 require "rails-tables/model_additions"
+require "rails-tables/relation_additions"
 
 module RailsTables
 end

data/lib/rails-tables/exceptions.rb

@@ -0,0 +1,3 @@
+module RailsTables
+  class NameError < ::NameError; end
+end

data/lib/rails-tables/model_additions.rb

@@ -1,11 +1,53 @@
 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))
+  extend ActiveSupport::Concern
+
+  included do
+    extend ClassMethods
+  end
+
+  module ClassMethods
+
+    def has_datatable(*args)
+      arguments = { }
+      if args.present?
+        if args.first.is_a? Hash
+          arguments = args.pop
+        else
+          arguments[:name] = args.first if args.try(:first)
+          arguments[:klass] = args.second if args.try(:second)
+        end
+      end
+      name = arguments.fetch(:name, 'datatable').to_s
+      klass = arguments.fetch(:klass, "#{self.name.pluralize.underscore}_datatable").to_s.camelize
+      klass = klass.constantize
+
+      cattr_accessor :datatables unless self.respond_to? :datatables
+      self.datatables ||= {}
+
+      if self.has_datatable? name
+        raise RailsTables::NameError,
+          "#{self.name} already has a datatable with the name '#{name}'. "\
+          "Please supply a :name parameter to has_datatable other than: #{self.datatables.keys.join(', ')}"
+      else
+        self.datatables[name] = klass
+        cattr_writer name
+        self.send("#{name}=", klass.new(name, self))
+        self.class.instance_eval do
+          define_method name do
+            self.class_variable_get("@@#{name}").set_root(self)
+          end
+        end
+      end
+    end
+
+    def has_datatable?(table_name=:datatable)
+      self.respond_to? :datatables and self.datatables.keys.include? table_name.to_s
+    end
+
   end
+
+# InstanceMethods
+
 end
 
-ActiveRecord::Base.extend RailsTables::ModelAdditions
+ActiveRecord::Base.send :include, RailsTables::ModelAdditions

data/lib/rails-tables/relation_additions.rb

@@ -0,0 +1,25 @@
+module RailsTables::RelationAdditions
+
+  delegate :has_datatable?, to: :klass
+
+  def respond_to?(method, include_private = false)
+    if self.has_datatable? method.to_s
+      true
+    else
+      super
+    end
+  end
+
+protected
+
+  def method_missing(method, *args, &block)
+    if self.has_datatable? method.to_s
+      self.klass.send(method.to_s).set_root(self)
+    else
+      super
+    end
+  end
+
+end
+
+ActiveRecord::Relation.send :include, RailsTables::RelationAdditions

data/lib/rails-tables/version.rb

@@ -1,3 +1,3 @@
 module RailsTables
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-tables
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-30 00:00:00.000000000 Z
+date: 2012-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -122,7 +122,9 @@ files:
 - app/tables/datatable.rb
 - config/routes.rb
 - lib/rails-tables/engine.rb
+- lib/rails-tables/exceptions.rb
 - lib/rails-tables/model_additions.rb
+- lib/rails-tables/relation_additions.rb
 - lib/rails-tables/version.rb
 - lib/rails-tables.rb
 - lib/tasks/rails-tables_tasks.rake