tableize 0.0.1

data/README.md

@@ -0,0 +1,132 @@
+Tableize
+========
+
+Installation
+------------
+    gem install tableize
+
+Examples
+-----
+#### Basic
+    table_for Post, @posts do |t|
+        t.column "Title", :title
+        t.column "Author", :author
+    end
+
+Is the same as:
+
+    table_for do |t|
+        t.columns :title, :author
+    end
+
+Both examples generate the following html:
+
+    <table class="posts">
+        <thead>
+            <tr>
+                <th class="title string">Title</th>
+                <th class="author string">Author</th>
+            </tr>
+        </thead>
+        <tbody>
+            <tr class="post_1">
+                <td>Hello World!</td>
+                <td>Christian Blais</td>
+            </tr>
+        </tbody>
+    </table>
+
+#### Few defaults
+* Inherited Resources
+
+    By default, `Tableize` will search for both `resource_class` and `collection` methods. So you don't have to specify them each time, unless
+    of course you want to override the default behavior. That being said, the following code produce the exact same output as the basic example
+    above.
+
+        table_for do |t|
+            t.column "Title", :title
+            t.column "Author", :author
+        end
+
+* I18n
+
+    By default, `Tableize` will try to internationalised your attribute, so you don't have to name each of your column. So, assuming my
+    model responds to `human_attribute_name`, the following example still produces the exact same output.
+
+        table_for do |t|
+            t.column :title
+            t.column :author
+        end
+
+* Columns
+
+    `Tableize` responds to `defaults` method, which will create a column for each public attribute of your model. Use it like this:
+
+        table_for do |t|
+            t.defaults
+        end
+
+* Multiple columns, one line
+
+        table_for do |t|
+            t.columns :title, :author
+        end
+
+#### Advanced features
+* Lambdas
+
+    You can use lambdas if you want to have a custom column.
+
+        table_for do |t|
+            t.column "Title" do |post|
+                post.title + "!"
+            end
+        end
+
+    You can also specify a method to be called before the yield.
+
+        table_for do |t|
+            t.column "Title", :title do |title|
+                title + "!"
+            end
+        end
+
+* Extras
+
+    Let's say `author` is a relation, and you want to show his first name and last name as separate columns. The following would works:
+
+        table_for do |t|
+            t.column "First name", :author do |author|
+                author.first_name
+            end
+            t.column "Last name", :author do |author|
+                author.last_name
+            end
+        end
+
+    But the above code triggers the `author` method twice. In order to avoid that, you could use the `extra` method, which will be executed only
+    once per row, yielding the result alongside the resource in each block. You can use more than one extra without any problem.
+
+        table_for do |t|
+            t.extra do |post|
+                post.author
+            end
+
+            t.column "First name" do |post, author|
+                author.first_name
+            end
+            t.column "Last name" do |post, author|
+                author.last_name
+            end
+        end
+
+* Hashes
+
+    `Tableize` also accepts hashes instead of regular collections. Use it the same way.
+
+        collection = [{:title => "Hello World", "author" => "Christian Blais"}]
+
+        table_for Post, collection do |t|
+            t.column :title
+            t.column "author"
+        end

data/lib/tableize.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + "/tableize/helper"
+require File.dirname(__FILE__) + "/tableize/utils"
+require File.dirname(__FILE__) + "/tableize/table_builder"
+require File.dirname(__FILE__) + "/tableize/column_builder"

data/lib/tableize/column_builder.rb

@@ -0,0 +1,77 @@
+module Tableize
+  class ColumnBuilder
+
+    attr_reader :title, :method
+
+    def initialize(resource_class, *args, &block)
+      @options        = args.extract_options!
+      @resource_class = resource_class
+      @html_options   = @options.delete(:html) || {}
+      @block          = block
+      @title          = get_title(args)
+      @method         = get_method(args)
+    end
+
+    def value(resource, extras)
+      if @block
+        @method ? @block.call(resource.send(@method), *extras) : @block.call(resource, *extras)
+      else
+        if @method
+          if resource.respond_to?(@method)
+            resource.send(@method)
+          elsif resource.kind_of?(Hash)
+            resource[@method]
+          end
+        end
+      end
+    end
+
+    def td_options
+      get_options(:td)
+    end
+
+    def th_options
+      options = get_options(:th)
+
+      if @method
+        options[:class] = Tableize::convert_to_array(options[:class], @method.to_s.underscore, value_type)
+      end
+
+      options
+    end
+
+    protected
+
+    def get_options(key)
+      @html_options[key] || {}
+    end
+
+    def get_title(args)
+      if title = args.first
+        if title.kind_of?(String)
+          args.shift
+        elsif @options.key?(:title)
+          @options[:title]
+        elsif title.kind_of?(Symbol) && @resource_class.respond_to?(:human_attribute_name)
+          @resource_class.send(:human_attribute_name, title)
+        else
+          title.to_s
+        end
+      end
+    end
+
+    def get_method(args)
+      if method = args.last
+        method
+      end
+    end
+
+    def value_type
+      if @method && @resource_class.respond_to?(:columns)
+        if column = @resource_class.columns.detect{ |column| column.name.to_sym == @method }
+          column.type
+        end
+      end
+    end
+  end
+end

data/lib/tableize/helper.rb

@@ -0,0 +1,8 @@
+module Tableize
+  def table_for(*args, &block)
+    Tableize::TableBuilder.new(self, *args, &block).render
+  end
+  alias_method :table, :table_for
+end
+
+ActionView::Base.send :include, Tableize

data/lib/tableize/table_builder.rb

@@ -0,0 +1,130 @@
+module Tableize
+  class TableBuilder
+
+    delegate :content_tag, :to => :@view_context
+
+    DEFAULT_OPTIONS = {
+      :default_table_class  => true,
+      :default_tr_class     => true
+    }
+
+    def initialize(view_context, *args, &block)
+      @options        = DEFAULT_OPTIONS.merge(args.extract_options!)
+      @table_options  = @options.delete(:html) || {}
+      @tr_options     = @table_options.delete(:tr) || {}
+      @view_context   = view_context
+      @block          = block
+      @resource_class = get_resource_class(args)
+      @collection     = get_collection(args)
+      @columns        = []
+      @extras         = []
+    end
+
+    def defaults
+      (@resource_class.new.attributes.keys - @resource_class.protected_attributes.to_a).each do |attribute|
+        column(attribute.to_sym)
+      end
+    end
+
+    def columns(*args)
+      args.each do |arg|
+        column(arg)
+      end
+    end
+
+    def column(*args, &block)
+      @columns << Tableize::ColumnBuilder.new(@resource_class, *args, &block)
+    end
+
+    def extra(&block)
+      @extras << block if block_given?
+    end
+
+    def render
+      @view_context.capture{ @block.call(self) }
+
+      content_tag(:table, table_options) do
+        [thead, tbody].join.html_safe
+      end
+    end
+
+    protected
+
+    def thead
+      content_tag(:thead) do
+        content_tag(:tr) do
+          @columns.map do |column|
+            content_tag(:th, column.th_options) do
+              column.title
+            end
+          end.join.html_safe
+        end
+      end
+    end
+
+    def tbody
+      content_tag(:tbody) do
+        @collection.map do |resource|
+          extras = @extras.map{ |block| block.call(resource) }
+
+          content_tag(:tr, tr_options(resource)) do
+            @columns.map do |column|
+              content_tag(:td, column.td_options) do
+                column.value(resource, extras).to_s.html_safe
+              end
+            end.join.html_safe
+          end
+        end.join.html_safe
+      end
+    end
+
+    def table_options
+      options = @table_options.dup
+
+      if @options[:default_table_class] && @resource_class.respond_to?(:model_name)
+        options[:class] = Tableize::convert_to_array(options[:class], @resource_class.model_name.tableize)
+      end
+
+      options
+    end
+
+    def tr_options(resource)
+      options = @tr_options.dup
+
+      if @options[:default_tr_class] && @resource_class.respond_to?(:model_name)
+        options[:class] = Tableize::convert_to_array(options[:class], "#{@resource_class.model_name.underscore}_#{get_resource_id(resource)}")
+      end
+
+      options
+    end
+
+    def get_resource_id(resource)
+      if resource.respond_to?(:id)
+        resource.id
+      elsif resource.kind_of?(Hash)
+        resource[:id] || resource["id"]
+      end
+    end
+
+    def get_resource_class(args)
+      if resource_class = args.shift
+        resource_class
+      elsif @options.key?(:resource_class)
+        @options[:resource_class]
+      elsif @view_context.respond_to?(:resource_class)
+        @view_context.resource_class
+      end
+    end
+
+    def get_collection(args)
+      if collection = args.shift
+        collection
+      elsif @options.key?(:collection)
+        @options[:collection]
+      elsif @view_context.respond_to?(:collection)
+        @view_context.collection
+      end
+    end
+
+  end
+end

data/lib/tableize/utils.rb

@@ -0,0 +1,11 @@
+module Tableize
+  def self.convert_to_array(array, *args)
+    array = [array].flatten.compact
+
+    args.each do |arg|
+      array.push(arg)
+    end
+
+    array
+  end
+end

data/lib/version.rb

@@ -0,0 +1,7 @@
+module Tableize
+  MAJOR = 0
+  MINOR = 0
+  BUILD = 1
+
+  VERSION = "#{MAJOR}.#{MINOR}.#{BUILD}"
+end

data/tableize.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require './lib/version'
+
+Gem::Specification.new do |s|
+  s.name        = "tableize"
+  s.version     = Tableize::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Christian Blais"]
+  s.email       = ["christ.blais@gmail.com"]
+  s.homepage    = "http://github.com/christianblais/tableize"
+  s.summary     = "Simple table helper"
+  s.description = "Simple table helper"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.require_paths = ['lib', 'test']
+end

data/test/app/.gitignore

@@ -0,0 +1,5 @@
+.bundle
+db/*.sqlite3
+log/*.log
+tmp/
+.sass-cache/

data/test/app/Gemfile

@@ -0,0 +1,43 @@
+source 'http://rubygems.org'
+
+gem 'rails', '3.1.1'
+
+# Bundle edge Rails instead:
+# gem 'rails',     :git => 'git://github.com/rails/rails.git'
+
+gem 'sqlite3'
+gem 'haml'
+gem 'utilities'
+gem 'inherited_resources'
+gem 'tableize', :path => "~/projects/gems/tableize"
+
+# Gems used only for assets and not required
+# in production environments by default.
+group :assets do
+  gem 'sass-rails',   '~> 3.1.4'
+  gem 'coffee-rails', '~> 3.1.1'
+  gem 'uglifier', '>= 1.0.3'
+end
+
+gem 'jquery-rails'
+
+# To use ActiveModel has_secure_password
+# gem 'bcrypt-ruby', '~> 3.0.0'
+
+# Use unicorn as the web server
+# gem 'unicorn'
+
+# Deploy with Capistrano
+# gem 'capistrano'
+
+# To use debugger
+# gem 'ruby-debug19', :require => 'ruby-debug'
+
+# fixing /gems/execjs-1.2.4/lib/execjs/runtimes.rb:45:in `autodetect': Could not find a JavaScript runtime. See https://github.com/sstephenson/execjs for a list of available runtimes. (ExecJS::RuntimeUnavailable)
+gem 'execjs'
+gem 'therubyracer'
+
+group :test do
+  # Pretty printed test output
+  gem 'turn', :require => false
+end