rails-tables 0.1.0 → 0.2.1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2012 YOURNAME
+Copyright 2012 CHRISTOPHER KEELE
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/app/tables/datatable.rb

@@ -1,13 +1,21 @@
 class Datatable
   delegate :params, to: 'self.view'
-  
-  attr_accessor :view, :filters
-  def initialize(view, filters={})
+
+attr_accessor :name, :model
+  def initialize(name, model)
+    self.name = name
+    self.model = model
+  end
+
+attr_accessor :view, :filters
+  def render_with(view, *args)
+    arguments = args.pop || {}
     self.view = view
-    self.filters = filters
+    self.filters = arguments.fetch(:filters, {})
+    return self
   end
 
-  def as_json(options = {})
+  def as_json(options={})
     {
       sEcho: params[:sEcho].to_i,
       iTotalRecords: objects.size,
@@ -16,41 +24,43 @@ class Datatable
     }
   end
 
-  class << self
-    attr_accessor :columns, :searches
-    def column(name, *args)
-      arguments = args.pop || {}
-      self.columns = [] if self.columns.nil?
-      self.columns << Column.new(name, arguments)
-    end
-    # def search_by(name, *args)
-    #   arguments = args.pop || {}
-    #   self.searches = [] if self.searches.nil?
-    #   self.searches << Search.new(name, self.table, arguments)
-    # end
+class_attribute :columns, :searches, :match_any
+  def self.column(name, *args)
+    arguments = args.pop || {}
+    self.columns = [] if self.columns.nil?
+    self.columns << Column.new(name, arguments)
+  end
+  def self.search_by(name, *args)
+    arguments = args.pop || {}
+    self.searches = [] if self.searches.nil?
+    self.searches << Search.new(name, self, arguments)
+  end
+  self.match_any = true
+  def self.match_any_column(match_any=true)
+    self.match_any = match_any
   end
 
 private
 
   def objects
     if sortable
-      objects = self.class.model.reorder("#{sort_column} #{sort_direction}")
+      objects = self.model.reorder("#{sort_column} #{sort_direction}")
     else
-      objects = self.class.model
+      objects = self.model
     end
     @filters.each do |method, arguments|
       objects = objects.send(method, arguments)
     end
-    # if params[:sSearch].present?
-    #   objects = self.model(:datatable_search, search(objects, params[:sSearch]))
-    #   #objects = objects.where("name like :search or category like :search", search: "%#{params[:sSearch]}%")
-    # end
+    if params[:sSearch].present?
+      objects = objects.send("#{self.name}_search", params[:sSearch])
+      #objects = objects.where("name like :search or category like :search", search: "%#{params[:sSearch]}%")
+    end
     objects = objects.paginate(page: page, per_page: per_page)
     objects
   end
 
   def search(objects, terms)
-    self.class.searches.each do |search|
+    self.searches.each do |search|
       objects = search.search(objects, terms)
     end
   end
@@ -63,10 +73,10 @@ private
   end
   
   def sortable
-    self.class.columns.map{ |column| column.sortable }[params[:iSortCol_0].to_i]
+    self.columns.map{ |column| column.sortable }[params[:iSortCol_0].to_i]
   end
   def sort_column
-    self.class.columns.map(&:column_name)[params[:iSortCol_0].to_i]
+    self.columns.map(&:column_name)[params[:iSortCol_0].to_i]
   end
   def sort_direction
     params[:sSortDir_0] == "desc" ? "desc" : "asc"
@@ -74,7 +84,7 @@ private
 
   def data
     objects.map do |object|
-      self.class.columns.map{ |column| column.render(self.view, object) }
+      self.columns.map{ |column| column.render(self.view, object) }
     end
   end
 

data/app/tables/search.rb

@@ -1,68 +1,56 @@
 class Search
-
-  attr_accessor :name, :table, :column_name, :search_with
+  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(:strategy, :default_strategy)
+    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 |objects, terms|
+    define_singleton_method :search do
       if self.search_with.kind_of? Symbol
-        self.send(self.search_with, self.column_name, objects, terms)
+        strategy_builder(self.search_with, self.match_any, self.split_terms)
       else
-        self.search_with.call(self.column_name, objects, terms)
+        self.search_with(self.match_any, self.split_terms)
       end
     end
   end
 
-  def default_strategy(field, objects, terms)
-    self.starts_with_strategy(field, objects, terms)
-  end
-  def starts_with_strategy(field, objects, terms)
-    terms.split.map{|s| s+="%"}.map do |term|
-      Squeel::Nodes::Predicate.new(Squeel::Nodes::Stub.new(field), :matches, term)
-    end.inject do |t, expr|
-      t | expr
-    end.tap do |block|
-      return objects.where{block}
-    end
-  end
-  def contains_strategy(field, objects, terms)
-    terms.split.map{|s| s="%#{s}%"}.map do |term|
-      Squeel::Nodes::Predicate.new(Squeel::Nodes::Stub.new(field), :matches, term)
-    end.inject do |t, expr|
-      t | expr
-    end.tap do |block|
-      return objects.where{block}
+  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
-  # def self_referential_link(view, object)
-  #   property = object.send(self.column_name)
-  #   view.link_to property, object if not property.nil?
-  # end
-  # def related_link(view, object)
-  #   property = object.send(self.column_name)
-  #   view.link_to self.name, property if not property.nil?
-  # end
-  # def related_link_list(view, object)
-  #   property = object.send(self.referring_column_name)
-  #   property.collect { |related_object| self_referential_link(view, related_object) }.join(', ') if not property.nil?
-  # end
-  # def time(view, object)
-  #   property = object.send(self.column_name)
-  #   property.strftime("%I:%M%p") if not property.nil?
-  # end
-  # def date(view, object)
-  #   property = object.send(self.column_name)
-  #   property.strftime("%m/%d/%Y") if not property.nil?
-  # end
-  # def datetime(view, object)
-  #   property = object.send(self.column_name)
-  #   property.strftime("%m/%d/%Y at %I:%M%p") if not property.nil?
-  # end
-
 end

data/lib/rails-tables/model_additions.rb

@@ -1,13 +1,22 @@
 def has_datatable(*args)
   arguments = args.pop || {}
   name = arguments.fetch(:name, 'datatable')
-  klass = arguments.fetch(:klass, "#{self.name.pluralize}Table")
-  require File.join(Rails.root, 'app', 'tables', "#{klass.underscore}.rb")
-  model = self
-  klass.constantize.class.send(:define_method, 'model') do
-    model
+  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
   end
-  self.class.send(:define_method, name) do
-    klass.constantize
-  end
-end  
+end

data/lib/rails-tables/version.rb

@@ -1,3 +1,3 @@
 module RailsTables
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-tables
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-27 00:00:00.000000000 Z
+date: 2012-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails