zable 0.0.6 → 0.0.7

data/README.md

@@ -0,0 +1,68 @@
+# Zable
+
+Zable lets you easily build sortable and searchable tables of your active record objects.
+
+## zable view helper
+
+The zable helper method will render the actual table in your view.
+
+```ruby
+zable collection, options = {} do
+  # define columns
+end
+```
+
+* **collection** - (Array) An array of active_record objects
+* **options** - (Hash)
+  * **:class** - (String) Html class
+  * **:id** - (String) Html id
+
+Within the zable block, you can use the `column` method to define the columns of your table.
+
+```ruby
+column(attribute, options={})
+column(attribute, options={}, &block)
+
+# example
+zable @items do
+  column :column_1
+  column :column_2 {|item| item.to_s}
+end
+```
+
+* **attribute** - (Symbol) Name of the attribute on the active_record object for this column. When no block is supplied, this will be the content of this column.
+* **options** - (Hash)
+  * **:title** - (String or Proc) You can use this to designate a custom header title string, or with a proc, supply completely custom header markup.
+  * **:sort** - (Boolean, default: true) By default, the header title will be a link that can be used to sort its respective column. However by setting this option to false, the title will not be a link.
+
+
+## Example
+
+user.rb:
+```ruby
+# basic sortable behavior on attribute
+sortable :name, :email, :created_at
+
+# sort on a non-attribute
+scope :sort_age, -> criteria { includes(:profile).order("profile.age #{criteria[:order]}") }
+```
+
+users_controller.rb:
+```ruby
+def index
+  @users = User.populate(params)
+end
+```
+
+index.html.erb:
+```erb
+<%= 
+  zable @items, :table_class => ["users-table", "shiny-colorful-table"] do
+    column(:name)
+    column(:email)
+    column(:created_at, :title => "Join Date")
+    column(:age) {|user| user.profile.age}
+    column(:edit, :title => "") {|user| link_to "Edit", edit_user_path(user)}
+  end
+%>
+```

data/app/helpers/zable_helper.rb

@@ -5,36 +5,9 @@ module ZableHelper
     base.send :include, Zable::Html
   end
 
-  def zable(collection, klass, args={}, &block)
-    reset_cycle("zable_cycle")
-
-    html = ''.html_safe #stylesheet_link_tag("zable")
-    html << pagination_element(collection, args.slice(:entry_name, :params)) if args[:paginate]
-    html << zable_element(args, block, collection, klass, args[:params])
-    html << pagination_element(collection, args.slice(:entry_name, :params)) if args[:paginate]
-    html
-  end
-
-  def zable_element(args, block, collection, klass, params)
-    cols = columns(&block)
-    cols.instance_variable_set :@search_params, controller.request.params[:search]
-    cols.instance_variable_set :@_extra_params, params
-    content_tag(:table, tag_args(args)) do
-      table_header(klass, cols) << table_body(collection, cols, args)
-    end
-  end
-
-  def pagination_element(collection, options)
-    content_tag :div, :class => 'brownFilterResultsBox' do
-      page_entries_info(collection, options.slice(:entry_name)) <<
-        will_paginate(collection, :renderer => LinkWithParamsRenderer.new(options[:params] || {}))
-    end
-  end
-
-  def columns
-    controller.request.instance_variable_set :@zable_columns, []
-    yield
-    controller.request.instance_variable_get :@zable_columns
+  def zable(collection, args={}, &block)
+    table = Zable::View.new(collection, self, args, &block)
+    table.render
   end
 
   def sorted_column?(name)
@@ -50,18 +23,4 @@ module ZableHelper
     current_sort_order == :desc ? :asc : :desc
   end
 
-  def column(name, options={}, &block)
-    col = {
-        :name       => name,
-        :title      => options[:title],
-        :sort       => options.has_key?(:sort) ? options[:sort] : true,
-        :block      => block,
-        :sorted?    => sorted_column?(name),
-        :sort_order => link_sort_order(name)
-    }
-
-    zable_columns = controller.request.instance_variable_get :@zable_columns
-    zable_columns << col
-  end
-
 end

data/lib/zable/html.rb

@@ -2,37 +2,37 @@ module Zable
   module Html
 
     ## Table header methods
-    def table_header(klass, columns)
+    def table_header(columns)
       content_tag :thead do
-        table_header_row(klass, columns)
+        table_header_row(columns)
       end
     end
 
-    def table_header_row(klass, columns)
+    def table_header_row(columns)
       content_tag :tr do
-        table_header_cells(klass, columns)
+        table_header_cells(columns)
       end
     end
 
-    def table_header_cells(klass, columns)
+    def table_header_cells(columns)
       columns.inject("".html_safe) do |str, attr|
-        str << table_header_cell(klass, attr, columns)
+        str << table_header_cell(attr, columns)
       end
     end
 
-    def table_header_cell(klass, attr, columns)
-      content_tag :th, :id => header_cell_id(klass, attr) do
+    def table_header_cell(attr, columns)
+      content_tag :th, :data => {:column => idify(attr[:name])} do
         header_cell_content(attr, columns)
       end
     end
 
     def header_cell_content(attr, columns)
-      str = link_to_if attr[:sort], header_cell_link_text(attr), header_cell_href(attr, columns)
-      str << header_cell_sort_image(attr)
-    end
-
-    def header_cell_id(klass, attr)
-      "#{idify klass.name}_#{idify attr[:name]}".html_safe
+      if attr[:title] && attr[:title].respond_to?(:call)
+        attr[:title].call
+      else
+        str = link_to_if attr[:sort], header_cell_link_text(attr), header_cell_href(attr)
+        str << header_cell_sort_image(attr)
+      end
     end
 
     def current_url
@@ -60,10 +60,8 @@ module Zable
       attr[:sort_order] == :desc ? "ascending.gif" : "descending.gif"
     end
 
-    def header_cell_href(attr, columns)
-      search = columns.instance_variable_get :@search_params
-      extra_params = columns.instance_variable_get(:@_extra_params) || {}
-      all_params = [sort_params(attr), search_params(search), extra_params.to_query.html_safe].reject(&:blank?).join("&".html_safe)
+    def header_cell_href(attr)
+      all_params = [sort_params(attr), search_params(@search), (@_extra_params || {}).to_query.html_safe].reject(&:blank?).join("&".html_safe)
       current_url << "?".html_safe << all_params
     end
 
@@ -144,10 +142,8 @@ module Zable
       val.to_s.demodulize.underscore
     end
 
-    def tag_args(args)
-      tag_args = {}
-      tag_args[:class] = args[:table_class].join(" ".html_safe) if args[:table_class] and !args[:table_class].empty?
-      tag_args
+    def tag_args(options)
+      {class: options[:class], id: options[:id]}
     end
 
   end

data/lib/zable/sort.rb

@@ -6,7 +6,10 @@ module Zable
       module ClassMethods
         def inherited(subclass)
           subclass.class_eval do
-            scope :for_sort_params, -> sort_params { inject_sort_scope(sort_params) }
+            def self.for_sort_params(sort_params)
+              return self unless sort_params
+              inject_sort_scope(sort_params)
+            end
           end
           super(subclass)
         end

data/lib/zable/view.rb

@@ -0,0 +1,71 @@
+module Zable
+
+  class View
+    include Zable::Html
+
+    attr_reader :columns
+
+    def initialize(collection, template, options={}, &block)
+      @collection = collection
+
+      @template = template # this refers to the view context
+      raise "Must pass in valid view context" unless @template.kind_of? ActionView::Context
+      @search = @template.controller.request.params[:search]
+      @_extra_params = options[:params]
+
+      @options = options
+      @columns = []
+      instance_eval(&block)
+    end
+
+    def render
+      reset_cycle("zable_cycle")
+
+      html = ''.html_safe #stylesheet_link_tag("zable")
+      html << pagination_element if @options[:paginate]
+      html << zable_element
+      html << pagination_element if @options[:paginate]
+      html
+    end
+
+    def column(name, options={}, &block)
+      col = {
+        :name       => name,
+        :title      => options[:title],
+        :sort       => options.has_key?(:sort) ? options[:sort] : true,
+        :block      => block,
+        :sorted?    => sorted_column?(name),
+        :sort_order => link_sort_order(name)
+      }
+
+      @columns << col
+    end
+
+    private
+
+    def h
+      @template
+    end
+
+    def method_missing(*args, &block)
+      # missing methods will be sent to the view context - these will generally be rails helper methods
+      h.send(*args, &block)
+    end
+
+    def zable_element
+      content_tag(:table, tag_args(@options)) do
+        table_header(@columns) << table_body(@collection, @columns, @options)
+      end
+    end
+
+    def pagination_element
+      content_tag :div, :class => 'brownFilterResultsBox' do
+        page_entries_info(@collection, @options.slice(:entry_name)) <<
+          will_paginate(@collection, :renderer => Zable::WillPaginate::LinkWithParamsRenderer.new(@options[:params] || {}))
+      end
+    end
+
+
+  end
+
+end

data/lib/zable.rb

@@ -7,5 +7,6 @@ module Zable
   require 'zable/search'
   require 'zable/hash'
   require 'zable/will_paginate'
+  require 'zable/view'
 
 end

metadata

@@ -1,19 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: zable
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
 - Derek Croft
+- Joe Kurleto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-13 00:00:00.000000000 Z
+date: 2013-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: will_paginate
-  requirement: &70333429550560 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +22,12 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70333429550560
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: HTML searching, sorting and pagination made dead simple
 email: 
 executables: []
@@ -34,6 +40,7 @@ files:
 - lib/zable/html.rb
 - lib/zable/search.rb
 - lib/zable/sort.rb
+- lib/zable/view.rb
 - lib/zable/will_paginate.rb
 - lib/zable/zable_test_helper.rb
 - lib/zable.rb
@@ -41,7 +48,7 @@ files:
 - public/images/common/pagination_bg_dis.gif
 - MIT-LICENSE
 - Rakefile
-- README.rdoc
+- README.md
 homepage: 
 licenses: []
 post_install_message: 
@@ -62,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: HTML tables

data/README.rdoc

@@ -1,8 +0,0 @@
-= Zable
-
-
-zable @items, Item, :table_class => ["items-table", "shiny-colorful-table"] do
-  column(:name)
-  column(:color)
-  column(:owner_name) { |item| item.owner.name }
-end