easy_table 0.0.4

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in easy_table.gemspec
+gemspec
+
+gem 'railties', '~> 3.2.0'
+gem 'activemodel', '~> 3.2.0'
+gem 'actionpack', '~> 3.2.0'
+
+gem 'mocha'
+gem 'shoulda'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jakub Głuszecki
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+# EasyTable
+
+EasyTable provides a helper for building HTML tables in Rails applications.
+
+It is inspired by simple_form gem: https://github.com/plataformatec/simple_form
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'easy_table', :git => 'https://github.com/cthulhu666/easy_table.git'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+All examples assume that You are using Haml. Please, use Haml !
+
+### Simplest example
+
+```haml
+= table_for(@people) do |t|
+  - t.column :name
+  - t.column :surname
+```
+
+This produces:
+
+```haml
+%table
+  %thead
+    %tr
+      %th name
+      %th surname
+  %tbody
+    %tr#person-1
+      %td John
+      %td Doe
+```
+
+Assuming `@people` is a collection consisting of one record, person with id = 1, John Doe
+
+### Simple example
+
+```haml
+= table_for(@people, class: 'people') do |t|
+  - t.column :name, class: 'name' do |person|
+    - person.name.downcase 
+  - t.column :surname, class: lambda { |person| ['surname', person.surname.length > 5 && 'long'].compact } do |person|
+    - person.surname.upcase
+```
+
+This produces:
+
+```haml
+%table.people
+  %thead
+    %tr
+      %th name
+      %th surname
+  %tbody
+    %tr#person-1
+      %td.name john
+      %td.surname DOE
+    %tr#person-2
+      %td.name alice
+      %td.surname.long COOPER
+```
+
+Assuming `@people` is a collection consisting of two records:
+ * person with id = 1, John Doe
+ * person with id = 2, Alice Cooper
+
+### Example with more complex table structure
+
+```haml
+= table_for(@people) do |t|
+  - t.span 'personal data' do |s|
+    - s.column :name
+    - s.colunm :surname
+  - t.span 'contact data' do |s|
+    - s.column :email
+    - s.column :phone
+```
+
+This produces:
+
+```haml
+%table
+  %thead
+    %tr
+      %th{colspan: 2, scope: 'col'} personal data
+      %th{colspan: 2, scope: 'col'} contact data
+    %tr
+      %th name
+      %th surname
+      %th email
+      %th phone
+  %tbody
+    %tr#person-1
+      %td John
+      %td Doe
+      %td john.doe@gmail.com
+      %td 123456789    
+```
+
+### I18n and column headers
+
+```yaml
+en:
+  easy_table:
+    person: # this is matched based on controller_name.singularize
+      name: 'Name'
+      surname: 'Surname'
+```
+
+With following form definition
+
+```haml
+= table_for(@people) do |t|
+  - t.column :name
+  - t.column :surname
+```
+
+It will use 'Name' and 'Surname' as column header labels:
+
+```haml
+%table
+  %thead
+    %tr
+      %th Name
+      %th Surname
+```
+
+You can also explicitly set column header passing it as a second argument to ```column``` and ```span``` methods:
+
+```haml
+= table_for(@people) do |t|
+  - t.column :name, 'Name'
+  - t.column :surname, 'Surname'
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the simple_form plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/easy_table.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/easy_table/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jakub Głuszecki"]
+  gem.email         = ["jakub.gluszecki@gmail.com"]
+  gem.description   = "HTML tables made easy (in Rails 3)"
+  gem.summary       = "HTML tables made easy (in Rails 3)"
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "easy_table"
+  gem.require_paths = ["lib"]
+  gem.version       = EasyTable::VERSION
+
+  gem.add_dependency('activemodel', '~> 3.0')
+  gem.add_dependency('actionpack', '~> 3.0')
+  gem.add_dependency 'rubytree'
+end

data/lib/easy_table.rb

@@ -0,0 +1,15 @@
+require "easy_table/version"
+
+require 'action_view'
+require 'easy_table/action_view_extensions/table_helper'
+require 'easy_table/components/base'
+require 'easy_table/components/columns'
+require 'easy_table/components/column'
+require 'easy_table/components/spans'
+require 'easy_table/components/span'
+require 'easy_table/table_builder'
+require 'tree'
+
+module EasyTable
+
+end

data/lib/easy_table/action_view_extensions/table_helper.rb

@@ -0,0 +1,14 @@
+module EasyTable
+  module ActionViewExtensions
+    module TableHelper
+      def table_for(collection, options = {}, &block)
+        t = EasyTable::TableBuilder.new(collection, self, options)
+        block.yield(t) if block_given?
+        t.build
+      end
+    end
+
+  end
+end
+
+ActionView::Base.send :include, EasyTable::ActionViewExtensions::TableHelper

data/lib/easy_table/components/base.rb

@@ -0,0 +1,10 @@
+module EasyTable
+  module Components
+    module Base
+      def translate(key)
+        controller = @template.controller_name
+        I18n.t("easy_table.#{controller.singularize}.#{key}", default: key.to_s)
+      end
+    end
+  end
+end

data/lib/easy_table/components/column.rb

@@ -0,0 +1,57 @@
+module EasyTable
+  module Components
+    class Column
+      include Base
+
+      delegate :tag, :capture, :content_tag, :to => :@template
+
+      def initialize(node, title, label, opts, template, block)
+        @node, @title, @label, @template, @block, @opts = node, title, label, template, block, opts
+        header_opts = @opts.select { |k, v| k =~ /^header_.*/ }
+        header_opts.each { |k, v| @opts.delete(k) }
+        @header_opts = header_opts.inject({}) do |h, e|
+          k, v = *e
+          h[k[7..-1]] = v
+          h
+        end
+      end
+
+      def head
+        concat content_tag(:th, label, @header_opts)
+      end
+
+      def td(record)
+        if @block.present?
+          html = capture { @block.call(record, self) }
+        else
+          html = record.send(@title).to_s
+        end
+        concat(content_tag(:td, html, html_opts(record)))
+      end
+
+      private
+
+      def label
+        @label || translate(@title)
+      end
+
+      def concat(tag)
+        @template.safe_concat(tag) unless tag.nil?
+        ""
+      end
+
+      def html_opts(record)
+        @opts.inject({}) do |h, e|
+          k, v = *e
+          h[k] = case v
+                   when Proc
+                     v.call(record)
+                   else
+                     v
+                 end
+          h
+        end
+      end
+    end
+  end
+end

data/lib/easy_table/components/columns.rb

@@ -0,0 +1,22 @@
+module EasyTable
+  module Components
+    module Columns
+      def column(title, label_or_opts = nil, opts = {}, &block)
+        if label_or_opts.is_a?(Hash) && label_or_opts.extractable_options?
+          label, opts = nil, label_or_opts
+        else
+          label, opts = label_or_opts, opts
+        end
+        child = node << Tree::TreeNode.new(title)
+        column = Column.new(child, title, label, opts, @template, block)
+        child.content = column
+      end
+
+      private
+
+      def node
+        @node
+      end
+    end
+  end
+end

data/lib/easy_table/components/span.rb

@@ -0,0 +1,44 @@
+module EasyTable
+  module Components
+    class Span
+      include Base
+      include Columns
+      include Spans
+
+      def initialize(node, title, label, html_opts, template, block)
+        @node, @title, @label, @template, @block, @html_opts = node, title, label, template, block, html_opts
+        block.call(self)
+      end
+
+      delegate :tag, :content_tag, :to => :@template
+
+      def head
+        opts = @html_opts.merge(colspan: colspan, scope: 'col')
+        concat content_tag(:th, label, opts)
+      end
+
+      def td(record)
+        columns.each do |col|
+          col.td(record)
+        end
+      end
+
+      private
+
+      def label
+        return nil if @title.nil?
+        @label || translate(@title)
+      end
+
+      def colspan
+        node.inject(0) { |count, n| count += 1 if n.is_leaf?; count }
+      end
+
+      def concat(tag)
+        @template.safe_concat(tag)
+        ""
+      end
+
+    end
+  end
+end

data/lib/easy_table/components/spans.rb

@@ -0,0 +1,27 @@
+module EasyTable
+  module Components
+    module Spans
+      def span(*args, &block)
+        opts = options_from_hash(args)
+        title, label = *args
+        child = node << Tree::TreeNode.new(title || generate_node_name)
+        span = Span.new(child, title, label, opts, @template, block)
+        child.content = span
+      end
+
+      private
+
+      def node
+        @node
+      end
+
+      def options_from_hash(args)
+        args.last.is_a?(Hash) ? args.pop : {}
+      end
+
+      def generate_node_name
+        "#{node.name}-span-#{node.size}"
+      end
+    end
+  end
+end

data/lib/easy_table/table_builder.rb

@@ -0,0 +1,70 @@
+module EasyTable
+  class TableBuilder
+
+    include EasyTable::Components::Columns
+    include EasyTable::Components::Spans
+
+    delegate :tag, :content_tag, :to => :@template
+
+    def initialize(collection, template, options)
+      @collection = collection
+      @options = options
+      @template = template
+      @node = Tree::TreeNode.new('root')
+    end
+
+    def build
+      content_tag(:table, @options) do
+        concat(content_tag(:thead) do
+          thead
+        end)
+        concat(content_tag(:tbody) do
+          @collection.each do |record|
+            concat(content_tag(:tr, tr_opts(record)) do
+              node.each_leaf do |leaf|
+                leaf.content.td(record)
+              end
+            end)
+          end
+        end)
+      end
+    end
+
+    private
+
+    def thead
+      rows = node.inject([]) do |arr, n|
+        arr[n.level] ||= []
+        arr[n.level] << n
+        arr
+      end
+      rows.shift
+      rows.each do |row|
+        concat(
+            content_tag(:tr) do
+              row.map { |node| node.content }.each do |span_or_column|
+                span_or_column.head
+              end
+            end
+        )
+      end
+    end
+
+    def tr_opts(record)
+      id =  "#{record.class.model_name.parameterize}-#{record.to_param}" if record.class.respond_to?(:model_name)
+      id ||=  "#{record.class.name.parameterize}-#{record.id}" if record.respond_to?(:id)
+
+      id.present? ?
+          {id: id} : {}
+    end
+
+    def concat(tag)
+      @template.safe_concat(tag)
+      ""
+    end
+
+    def options_from_hash(args)
+      args.last.is_a?(Hash) ? args.pop : {}
+    end
+  end
+end

data/lib/easy_table/version.rb

@@ -0,0 +1,3 @@
+module EasyTable
+  VERSION = "0.0.4"
+end

data/test/action_view_extensions/table_helper_test.rb

@@ -0,0 +1,135 @@
+if __FILE__== $0
+  require '../test_helper'
+else
+  require 'test_helper'
+end
+
+class TableHelperTest < ActionView::TestCase
+
+  context "a table" do
+    setup do
+      @collection = ['foo', 'bar', 'buzz']
+      concat(table_for(@collection, class: 'easy') do |t|
+        t.column :downcase
+        t.column(:upcase) { |t| t.upcase }
+      end)
+    end
+
+    should "have 'easy' class" do
+      assert_select 'table.easy'
+    end
+
+    should "have 3 rows" do
+      rows = css_select 'table tbody tr'
+      assert_equal 3, rows.size
+    end
+
+    should "have 2 columns" do
+      cols = css_select 'table tbody tr:first-child td'
+      assert_equal 2, cols.size
+    end
+
+    should "have proper headers" do
+      headers = css_select 'table thead tr th'
+      assert_equal '<th>downcase</th>', headers[0].to_s
+      assert_equal '<th>upcase</th>', headers[1].to_s
+    end
+  end
+
+  context "a complex table" do
+    setup do
+      Person = Struct.new(:id, :name, :surname, :email, :phone) unless defined?(Person)
+      @collection = []
+      @collection << Person.new(1, "John", "Doe", "jdoe@gmail.com", "500600700")
+      @collection << Person.new(2, "Barack", "Obama", "bobama@polskieobozy.com", "501601701")
+      concat(table_for(@collection) do |t|
+        t.span(:names) do |s|
+          s.column :name, class: 'name', header_class: 'name_head'
+          s.column(:surname) { |person| content_tag(:span, person.surname.capitalize) }
+        end
+        t.span(:contact_data) do |s|
+          s.column :email, class: lambda { |person| ['foo', 'bar', person.email =~ /gmail/ && 'gmail'].compact }
+          s.column :phone
+        end
+      end)
+    end
+
+    should "have rows with proper id attributes" do
+      assert_select 'table tbody tr#tablehelpertest-person-1'
+      assert_select 'table tbody tr#tablehelpertest-person-2'
+    end
+
+    should "have 2 th-s in thead's first row'" do
+      row = css_select 'table thead tr:first-child th'
+      assert_equal 2, row.size
+    end
+
+    should "have 4 th-s in thead's second row'" do
+      row = css_select 'table thead tr:nth-child(2) th'
+      assert_equal 4, row.size
+    end
+
+    should "have proper body content" do
+      assert_select 'table tbody tr:first-child td:first-child', {count: 1, text: 'John'}
+      assert_select 'table tbody tr:first-child td:nth-child(2) span', {count: 1, text: 'Doe'}
+    end
+
+    should "have proper td class in name column" do
+      td = css_select('table tbody tr:first-child td:first-child').first
+      assert_equal 'name', td.attributes['class']
+    end
+
+    should "have proper th class in name column" do
+      td = css_select('table thead tr:nth-child(2) th:first-child').first
+      assert_equal 'name_head', td.attributes['class']
+    end
+
+    should "have proper td class in first row in email column" do
+      td = css_select('table tbody tr:nth-child(1) td:nth-child(3)').first
+      assert_equal 'foo bar gmail', td.attributes['class']
+    end
+
+    should "have proper td class in second row in email column" do
+      td = css_select('table tbody tr:nth-child(2) td:nth-child(3)').first
+      assert_equal 'foo bar', td.attributes['class']
+    end
+  end
+
+  context "table with nested spans" do
+    setup do
+      @collection = []
+      concat(
+          table_for(@collection) do |t|
+            t.span :span1 do |s1|
+              s1.span :span2 do |s2|
+                s2.column :col1
+                s2.column :col2
+              end
+              s1.span :span3 do |s3|
+                s3.column :col3
+                s3.column :col4
+              end
+            end
+            t.span :span4 do |s4|
+              s4.column :col5
+              s4.column :col6
+            end
+            t.column :col7, header_rowspan: 3
+          end
+      )
+    end
+
+    should "have 3 rows in thead" do
+      assert_select 'table thead tr', 3
+    end
+
+    should "have rowspan=3 in last th of first tr" do
+      th = css_select('table thead tr:first-child th:last-child').first
+      assert_equal '3', th.attributes['rowspan']
+    end
+
+    should "have 11 th elements in thead" do
+      assert_select 'table thead th', count: 11
+    end
+  end
+end

data/test/components/spans_test.rb

@@ -0,0 +1,39 @@
+if __FILE__== $0
+  require '../test_helper'
+else
+  require 'test_helper'
+end
+
+class SpansTest < ActionView::TestCase
+  include EasyTable::Components::Spans
+
+  setup do
+    @node = Tree::TreeNode.new('root')
+  end
+
+  should "create a Span given title, a hash and a block" do
+    span('title', class: 'klazz') { |s| }
+    s =  node.children.first.content
+    assert_equal 'title', s.instance_variable_get(:@title)
+  end
+
+  should "create a Span given title, label, a hash and a block" do
+    span('title', 'label', class: 'klazz') { |s| }
+    s =  node.children.first.content
+    assert_equal 'title', s.instance_variable_get(:@title)
+  end
+
+  should "create a Span given a hash and a block" do
+    span(class: 'klazz') { |s| }
+    s =  node.children.first.content
+    assert_nil s.instance_variable_get(:@title)
+  end
+
+  should "create a Span fiven only a block" do
+    span { |s| }
+    s =  node.children.first.content
+    assert_nil s.instance_variable_get(:@title)
+  end
+
+
+end

data/test/table_builder_test.rb

@@ -0,0 +1,5 @@
+require 'test_helper'
+
+class TableBuilderTest < ActionView::TestCase
+
+end

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'test/unit'
+require 'mocha'
+require 'shoulda-context'
+
+require 'active_model'
+require 'action_controller'
+require 'action_view'
+require 'action_view/template'
+
+# Rails 3.0.4 is missing this "deprecation" require.
+require 'active_support/core_ext/module/deprecation'
+require 'action_view/test_case'
+
+module Rails
+  def self.env
+    ActiveSupport::StringInquirer.new("test")
+  end
+end
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+require 'easy_table'
+
+I18n.default_locale = :en
+
+class ActionView::TestCase
+  include EasyTable::ActionViewExtensions::TableHelper
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: easy_table
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Jakub Głuszecki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &16553160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16553160
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: &16552040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16552040
+- !ruby/object:Gem::Dependency
+  name: rubytree
+  requirement: &16551480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16551480
+description: HTML tables made easy (in Rails 3)
+email:
+- jakub.gluszecki@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- easy_table.gemspec
+- lib/easy_table.rb
+- lib/easy_table/action_view_extensions/table_helper.rb
+- lib/easy_table/components/base.rb
+- lib/easy_table/components/column.rb
+- lib/easy_table/components/columns.rb
+- lib/easy_table/components/span.rb
+- lib/easy_table/components/spans.rb
+- lib/easy_table/table_builder.rb
+- lib/easy_table/version.rb
+- test/action_view_extensions/table_helper_test.rb
+- test/components/spans_test.rb
+- test/table_builder_test.rb
+- test/test_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: HTML tables made easy (in Rails 3)
+test_files:
+- test/action_view_extensions/table_helper_test.rb
+- test/components/spans_test.rb
+- test/table_builder_test.rb
+- test/test_helper.rb