rails-tables 0.6.6 → 0.7.0.rc1

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.6.6
+Version: 0.7.0.rc1
 
 Please refer to the [RailsTables Wiki][wiki] for:
 

data/app/assets/javascripts/rails-tables.js.coffee

@@ -6,7 +6,6 @@ $ ->
 
 @rails_tables = {}
 @rails_tables.columns = (datatable)->
-  console.log $(datatable).data().order_column, $(datatable).data().order_direction
   asSorting: [ $(datatable).data().order_direction ], aTargets: [ $(datatable).data().order_column ]
 @rails_tables.params = (datatable) ->
   (aoData) ->

data/lib/rails-tables.rb

@@ -1,5 +1,6 @@
 require "rails-tables/engine"
 require "rails-tables/exceptions"
+require "rails-tables/dsl_proxy"
 require "rails-tables/datatable"
 require "rails-tables/model_additions"
 require "rails-tables/relation_additions"

data/lib/rails-tables/datatable.rb

@@ -6,7 +6,7 @@ class RailsTables::Datatable
   include RailsTables::Searching
   delegate :params, to: 'self.view'
 
-  attr_accessor :name, :root, :model, :view
+  attr_accessor :name, :root, :model, :view, :locals
 
   # Called in has_datatable for model, or on an ActiveRecord::Relation in method_missing
   def initialize(name, model)
@@ -26,7 +26,7 @@ class RailsTables::Datatable
       options[:source] = self.class.source
     end
     if self.initial_order.present?
-      options[:order_column] = self.columns.select{|c|c.name==self.class.initial_order.first[0].to_s}.first.order
+      options[:order_column] = self.columns.select{|c|c.name==self.class.initial_order.first[0].to_s}.first.index
       options[:order_direction] = self.class.initial_order.first[1]
     end
     options[:unsorted] = 'true'
@@ -34,8 +34,9 @@ class RailsTables::Datatable
   end
 
   # Pass in view and scope table for controller
-  def render_with(view)
+  def render_with(view, locals={})
     self.view = view
+    self.locals = locals
     return self
   end
 
@@ -60,14 +61,18 @@ class RailsTables::Datatable
 
   class_attribute :columns, :column_factory
   # Allow user defined columns, lazily instanciate later after 'self.root' is defined
-  def self.column(name, *args)
-    arguments = args.pop || {}
+  def self.column(name, options={}, &block)
     self.column_factory = [] if self.column_factory.nil?
-    self.column_factory << { name: name.to_s, args: arguments }
+    self.column_factory << { name: name.to_s, block: block }.merge(options)
   end
   # Lazily instanciates and caches columns
   def columns
-    @columns ||= self.column_factory.map.with_index{ |new_column, index| RailsTables::Column.new(self.class.name, self.model, new_column[:name], index, new_column[:args]) }
+    @columns ||= self.column_factory.map.with_index do |new_column, index|
+      new_column[:index] = index
+      new_column[:table] = self
+      new_column[:model] = self.model
+      RailsTables::ColumnBuilder.define(new_column)
+    end
   end
 
   class_attribute :joins
@@ -76,9 +81,9 @@ class RailsTables::Datatable
   def self.join(join)
     self.joins += [join.to_s]
   end
-  # Deduce joins based on columns and explicitly joined tables 
+  # Deduce joins based on columns and explicitly joined tables
   def joins
-    @joins ||= (self.columns.reject(&:virtual).map(&:column_source).reject(&:blank?) + self.class.joins).uniq 
+    @joins ||= (self.columns.reject(&:virtual).map(&:column_source).reject(&:blank?).map(&:to_s) + self.class.joins).uniq
   end
 
 private
@@ -106,7 +111,7 @@ private
   # Generate HTML for each row
   def data
     objects.map do |object|
-      self.columns.map{ |column| column.render(self.view, object) }
+      self.columns.map{ |column| column.render(object) }
     end
   end
 

data/lib/rails-tables/datatable/column.rb

@@ -1,93 +1,88 @@
-class RailsTables::Column
+require "rails-tables/datatable/column/renderers"
+module RailsTables
+  mattr_accessor :column_attributes
+  self.column_attributes = [:name, :index, :table, :model, :method_name, :column_source, :follow_source, :renderer, :blank_value, :virtual, :sortable, :searchable]
 
-  attr_accessor :table_name, :model, :name, :order, :method, :column_source, :render_with, :blank_value, :virtual, :sortable, :searchable
+  class ColumnBuilder
+    attr_reader :column
+    def self.define(column)
+      block = column.delete(:block)
+      @builder = self.new(column)
+      DslProxy.exec(@builder, &block) if block
+      @builder.column
+    end
+    def initialize(column)
+      @column = Column.from_hash(column)
+    end
+    RailsTables.column_attributes.reject{|c|c==:renderer}.each do |attr|
+      define_method attr do |value|
+        @column.send("#{attr}=".to_sym, value)
+      end
+    end
+    def renderer(value=nil, &block)
+      @column.renderer = block || value || nil
+    end
+  end
 
-  def initialize(table_name, model, name, order, *args)
-    self.table_name = table_name
-    self.model = model
-    self.name = name
-    self.order = order
+  Column = Struct.new(*RailsTables.column_attributes) do
+    include RailsTables::Renderers
+    # Arrange a hash into properly ordered array of args for this Struct
+    def self.from_hash hash
+      self[*hash.values_at(*self.members.map {|m| m.to_sym})]
+    end
+    # Set some defaults
+    def initialize(*args)
+      super
+      self[:method_name]    = name.to_s                      if method_name.nil?
+      self[:column_source]  = ''                             if column_source.nil?
+      self[:renderer]       = :default_renderer              if renderer.nil?
+      self[:follow_source]  = !self[:renderer].is_a?(Proc)   if follow_source.nil?
+      self[:blank_value]    = '—'                      if blank_value.nil?
+      self[:virtual]        = false                          if virtual.nil?
+      self[:sortable]       = !virtual                       if sortable.nil?
+      self[:searchable]     = !virtual                       if searchable.nil?
 
-    attributes = args.pop || {}
-    self.method = attributes.fetch(:method, name).to_s
-    self.column_source = attributes.fetch(:column_source, '').to_s
+      define_singleton_method :render do |object|
+        render_method = renderer.is_a?(Proc) ? renderer : method(renderer)
+        object = follow_source_on(object) if follow_source
+        content = self.instance_exec object, &render_method
+        content.present? ? content.to_s.html_safe : blank_value
+      end
+    end
 
-    virtual = (self.column_source.blank? and not self.model.column_names.include? self.method)
-    self.virtual = attributes.fetch(:virtual, virtual)
-    self.sortable = attributes.fetch(:sortable, !self.virtual)
-    self.searchable = attributes.fetch(:searchable, !self.virtual)
+  private
 
-    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}"
+    def follow_source_on(object)
+      related = object
+      column_source.to_s.split('.').each do |relation|
+        related = related.try(:send, relation)
+      end
+      related
     end
 
-    self.render_with = attributes.fetch(:render_with, :default_render)
-    self.blank_value = attributes.fetch(:blank_value, '–')
+    def default_renderer(object)
+      object.send(method_name) if object.respond_to? method_name
+    end
 
-    define_singleton_method :render do |view, object|
-      if self.render_with.kind_of? Symbol
-        content = self.send(self.render_with, view, follow_source(object))
+    def respond_to?(sym)
+      if table.view.respond_to? sym
+        true
+      elsif table.locals.has_key? sym
+        true
       else
-        content = self.render_with.call(view, object)
+        super
       end
-      content.present? ? content.to_s.html_safe : self.blank_value
     end
-  end
 
-private
-
-  def follow_source(object)
-    related = object
-    self.column_source.split('.').each do |relation|
-      related = related.try(:send, relation)
+    def method_missing(sym, *args)
+      if table.view.respond_to? sym
+        table.view.send(sym, *args)
+      elsif table.locals.has_key? sym
+        table.locals[sym]
+      else
+        super
+      end
     end
-    related
-  end
-
-  def default_render(view, object)
-    property = object.try(:send, self.method)
-    property if not property.nil?
-  end
-
-  def self_referential_link(view, object)
-    property = object.try(:send, self.method)
-    view.link_to property, object if not property.nil?
-  end
-  def related_link(view, object)
-    property = object.try(:send, self.method)
-    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 time(view, object)
-    property = object.try(:send, self.method)
-    property.strftime("%I:%M%p") if not property.nil?
-  end
-  def date(view, object)
-    property = object.try(:send, self.method)
-    property.strftime("%m/%d/%Y") if not property.nil?
   end
-  def datetime(view, object)
-    property = object.try(:send, self.method)
-    property.strftime("%m/%d/%Y at %I:%M%p") if not property.nil?
-  end
-
-  def currency(view, object)
-    property = object.try(:send, self.method)
-    view.number_to_currency(property.to_f) if not property.nil?
-  end
-  def phone(view, object)
-    property = object.try(:send, self.method)
-    view.number_to_phone(property.to_f) if not property.nil?
-  end
-
-  def truncate(view, object)
-    property = object.try(:send, self.method)
-    view.truncate(property, 50) if not property.nil?
-  end
-
 end

data/lib/rails-tables/datatable/column/renderers.rb

@@ -0,0 +1,38 @@
+module RailsTables
+  module Renderers
+    def link_to_object(object)
+      property = object.try(:send, method_name)
+      link_to property, object if not property.nil?
+    end
+    def link_to_objects(objects)
+      objects.reject(&:blank?).map{ |object| link_to_object(object).strip }.join(', ') if not objects.nil?
+    end
+
+    def time(object)
+      property = object.try(:send, method_name)
+      property.strftime("%I:%M%p") if not property.nil?
+    end
+    def date(object)
+      property = object.try(:send, method_name)
+      property.strftime("%m/%d/%Y") if not property.nil?
+    end
+    def datetime(object)
+      property = object.try(:send, method_name)
+      property.strftime("%m/%d/%Y at %I:%M%p") if not property.nil?
+    end
+
+    def currency(object)
+      property = object.try(:send, method_name)
+      number_to_currency(property.to_f) if not property.nil?
+    end
+    def phone(object)
+      property = object.try(:send, method_name)
+      number_to_phone(property.to_f) if not property.nil?
+    end
+
+    def truncate(object)
+      property = object.try(:send, method_name)
+      truncate(property, 50) if not property.nil?
+    end
+  end
+end

data/lib/rails-tables/datatable/searching.rb

@@ -10,9 +10,9 @@ module RailsTables::Searching
   module ClassMethods
     # Allow user defined fields to sort on in addition to introspected fields
     def search_on(column_source, methods)
-      Array(methods).each do |method|
+      Array(methods).each do |method_name|
         join column_source
-        self.searches += [{column_source: column_source.to_s, method: method.to_s}]
+        self.searches += [{column_source: column_source.to_s, method_name: method_name.to_s}]
       end
     end
   end
@@ -29,7 +29,7 @@ private
   def searchables
     searches = self.columns.
       select(&:searchable).
-      map{ |c| {column_source: c.column_source, method: c.method} }
+      map{ |c| {column_source: c.column_source, method_name: c.method_name} }
     searches += self.class.searches
     @searches ||= searches.uniq
   end
@@ -38,7 +38,7 @@ private
     terms = terms.split if terms.is_a? String
     searchables.map do |search|
       terms.map do |word|
-        Squeel::Nodes::KeyPath.new(search[:column_source].split('.') << Squeel::Nodes::Stub.new(search[:method])) =~ "%#{word}%"
+        Squeel::Nodes::KeyPath.new(search[:column_source].to_s.split('.') << Squeel::Nodes::Stub.new(search[:method_name].to_s)) =~ "%#{word}%"
       end.compact.inject(&:|)
     end.compact.inject(&:|)
   end

data/lib/rails-tables/datatable/sorting.rb

@@ -34,7 +34,7 @@ private
       direction = params[:sSortDir_0] == "asc" ? 1 : -1
     end
     if column.sortable
-      Squeel::Nodes::KeyPath.new(column.column_source.split('.') << Squeel::Nodes::Order.new(Squeel::Nodes::Stub.new(column.method), direction))
+      Squeel::Nodes::KeyPath.new(column.column_source.to_s.split('.') << Squeel::Nodes::Order.new(Squeel::Nodes::Stub.new(column.method_name.to_s), direction))
     end
   end
 

data/lib/rails-tables/dsl_proxy.rb

@@ -0,0 +1,120 @@
+class DslProxy < BasicObject
+  
+  # Pass in a builder-style class, or other receiver you want set as "self" within the
+  # block, and off you go.  The passed block will be executed with all
+  # block-context local and instance variables available, but with all
+  # method calls sent to the receiver you pass in.  The block's result will
+  # be returned.  
+  #
+  # If the receiver doesn't respond_to? a method, any missing methods
+  # will be proxied to the enclosing context.
+  def self.exec(receiver, &block) # :yields: receiver
+    # Find the context within which the block was defined
+    context = ::Kernel.eval('self', block.binding)
+
+    # Create or re-use our proxy object
+    if context.respond_to?(:_to_dsl_proxy)
+      # If we're nested, we don't want/need a new dsl proxy, just re-use the existing one
+      proxy = context._to_dsl_proxy
+    else
+      # Not nested, create a new proxy for our use
+      proxy = DslProxy.new(context)
+    end
+
+    # Exec the block and return the result
+    proxy._proxy(receiver, &block)
+  end
+  
+  # Simple state setup
+  def initialize(context)
+    @_receivers = []
+    @_instance_original_values = {}
+    @_context = context
+  end
+  
+  def _proxy(receiver, &block) # :yields: receiver
+    # Sanity!
+    raise 'Cannot proxy with a DslProxy as receiver!' if receiver.respond_to?(:_to_dsl_proxy)
+    
+    if @_receivers.empty?
+      # On first proxy call, run each context instance variable, 
+      # and set it to ourselves so we can proxy it
+      @_context.instance_variables.each do |var|
+        unless var.to_s.starts_with?('@_')
+          value = @_context.instance_variable_get(var.to_s)
+          @_instance_original_values[var] = value
+          #instance_variable_set(var, value)
+          instance_eval "#{var} = value"
+        end
+      end
+    end
+
+    # Save the dsl target as our receiver for proxying
+    _push_receiver(receiver)
+
+    # Run the block with ourselves as the new "self", passing the receiver in case
+    # the code wants to disambiguate for some reason
+    result = instance_exec(@_receivers.last, &block)
+    
+    # Pop the last receiver off the stack
+    _pop_receiver
+    
+    if @_receivers.empty?
+      # Run each local instance variable and re-set it back to the context if it has changed during execution
+      #instance_variables.each do |var|
+      @_context.instance_variables.each do |var|
+        unless var.to_s.starts_with?('@_')
+          value = instance_eval("#{var}")
+          #value = instance_variable_get("#{var}")
+          if @_instance_original_values[var] != value
+            @_context.instance_variable_set(var.to_s, value)
+          end
+        end
+      end
+    end
+    
+    return result
+  end
+  
+  # For nesting multiple proxies
+  def _to_dsl_proxy
+    self
+  end
+  
+  # Set the currently active receiver
+  def _push_receiver(receiver)
+    @_receivers.push receiver
+  end
+  
+  # Remove the currently active receiver, restore old receiver if nested
+  def _pop_receiver
+    @_receivers.pop
+  end
+
+  # Proxies all calls to our receiver, or to the block's context
+  # if the receiver doesn't respond_to? it.
+  def method_missing(method, *args, &block)
+    #$stderr.puts "Method missing: #{method}"
+    if @_receivers.last.respond_to?(method)
+      #$stderr.puts "Proxy [#{method}] to receiver"
+      @_receivers.last.__send__(method, *args, &block)
+    else
+      #$stderr.puts "Proxy [#{method}] to context"
+      @_context.__send__(method, *args, &block)
+    end
+  end
+  
+  # Let anyone who's interested know what our proxied objects will accept
+  def respond_to?(method, include_private = false)
+    return true if method == :_to_dsl_proxy
+    @_receivers.last.respond_to?(method, include_private) || @_context.respond_to?(method, include_private)
+  end
+  
+  # Proxies searching for constants to the context, so that eg Kernel::foo can actually
+  # find Kernel - BasicObject does not partake in the global scope!
+  def self.const_missing(name)
+    #$stderr.puts "Constant missing: #{name} - proxy to context"
+    @_context.class.const_get(name)
+  end
+  
+end

data/lib/rails-tables/version.rb

@@ -1,3 +1,3 @@
 module RailsTables
-  VERSION = "0.6.6"
+  VERSION = "0.7.0.rc1"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rails-tables
 version: !ruby/object:Gem::Version
-  version: 0.6.6
-  prerelease: 
+  version: 0.7.0.rc1
+  prerelease: 6
 platform: ruby
 authors:
 - Christopher Keele
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-12 00:00:00.000000000 Z
+date: 2013-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -117,10 +117,12 @@ extra_rdoc_files: []
 files:
 - app/assets/javascripts/rails-tables.js.coffee
 - config/routes.rb
+- lib/rails-tables/datatable/column/renderers.rb
 - lib/rails-tables/datatable/column.rb
 - lib/rails-tables/datatable/searching.rb
 - lib/rails-tables/datatable/sorting.rb
 - lib/rails-tables/datatable.rb
+- lib/rails-tables/dsl_proxy.rb
 - lib/rails-tables/engine.rb
 - lib/rails-tables/exceptions.rb
 - lib/rails-tables/model_additions.rb
@@ -146,9 +148,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23