table_go 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA1: 
-  metadata.gz: 11ffd5d8824ce99aa33d4b2971ec89d32a450aff
-  data.tar.gz: 4522febd5dfeceb72a8db1ad82702dd6b81d7e65
 SHA512: 
-  metadata.gz: 95e9071b51873d44a8f3296e0df969c99181f4dfaf0af5e821220128ea93da448ce49c47c16846788d4caf20691c9e5f20580b4149f0919960963d26ef92279d
-  data.tar.gz: c618637e6020b59ff7cc0d2968826112b4b7562b3008ca3447264aec5c0741f698ef7ab115770f38a78ef6b4dba24b692ea7914062fe0b4440e7cdd18dc09dbd
+  metadata.gz: 98d1c35fd3e8d901ed141a60dae4c72feb84288f71e40953ccb6a509c923fdb0f4ac5069446a4df37d2a183e378a5fe38682999f4e290390552e49895c890477
+  data.tar.gz: 245dbc606d4525f4338fefc23b6cc7a8aaa9bbdf06f76a6c9cde4f89a998e66f99170b22e637e8951a02e0091705ccd19007f5b0c4f491bdfdd41010c7b002af
+SHA1: 
+  metadata.gz: fd07ac423cdbee16255d07adae5b52d3fbb0e705
+  data.tar.gz: 0eb4b6402e9df3792144845b1e4373aef069936f

data/README.md

@@ -76,6 +76,30 @@ example in HAML
 - add sorting for column
 
 
+## Changelog
+
+#### 0.2.3
+
+- speed optimisation for haml templates
+- allowing block style table options
+
+#### 0.2.2
+
+- small fixes
+- tests
+
+#### 0.2.1
+
+- tests
+
+#### 0.2.0
+
+- allow multiline block level customization of columns
+
+#### 0.1.9
+
+- simple, flexible and fast html table generator
+
 
 ## Contributing
 

data/lib/table_go.rb

@@ -2,7 +2,6 @@ require 'table_go/version'
 
 module TableGo
   autoload :Table, 'table_go/table'
-  autoload :Columns, 'table_go/columns'
   autoload :Column, 'table_go/column'
   autoload :TableRenderer, 'table_go/table_renderer'
   autoload :Renderers, 'table_go/renderers'
@@ -19,11 +18,10 @@ module TableGo
   end
 
   def self.render(collection, model_klass, renderer_klass, template, options = {}, &block)
-    table     = Table.new(collection, model_klass, &block)
+    table     = Table.new(collection, model_klass, options, &block)
     renderer  = TableRenderer.new(table)
     renderer.renderer_klass = renderer_klass
     renderer.template       = template
-    renderer.apply_options(options)
     renderer.render_template
   end
 

data/lib/table_go/formatter.rb

@@ -64,7 +64,7 @@ module TableGo
     end
 
     def self.apply_send(formatter, record, column, value)
-      value.send(formatter).to_s.html_safe
+      value.send(formatter)
     end
 
   end

data/lib/table_go/renderers/csv_renderer.rb

@@ -6,9 +6,9 @@ module TableGo
 
       def render_template
         ::FasterCSV.generate(:col_sep => ";", :row_sep => "\n", :force_quotes => true, :quote_char => '"') do |csv|
-          csv << source_table.columns.map { |column| label_for_column(column) }
-          source_table.collection.each do |record|
-            csv << source_table.columns.map do |column|
+          csv << table.columns.map { |column| label_for_column(column) }
+          table.collection.each do |record|
+            csv << table.columns.map do |column|
               value = value_from_record_by_column(record, column)
               apply_formatter(record, column, value)
             end

data/lib/table_go/renderers/html_renderer.rb

@@ -4,8 +4,8 @@ module TableGo
       include RendererBase
 
       def render_template
-        content_tag(:table, table_html) do
-          concat(content_tag(:caption, title)) if title
+        content_tag(:table, table.table_html) do
+          concat(content_tag(:caption, table.title)) if table.title
           concat(table_head)
           concat(table_body)
         end
@@ -14,7 +14,7 @@ module TableGo
       def table_head
         content_tag(:thead) do
           content_tag(:tr) do
-            source_table.columns.each do |column|
+            table.columns.each do |column|
               concat(content_tag(:th, label_for_column(column), html_options_for_header(column)))
             end
           end
@@ -23,9 +23,9 @@ module TableGo
 
       def table_body
         content_tag(:tbody) do
-          source_table.collection.each do |record|
+          table.collection.each do |record|
              tr = content_tag(:tr, html_options_for_row(record)) do
-              source_table.columns.each do |column|
+              table.columns.each do |column|
                 value = value_from_record_by_column(record, column)
                 concat(content_tag(:td, apply_formatter(record, column, value), html_options_for_cell(record, column, value)))
               end

data/lib/table_go/renderers/renderer_base.rb

@@ -4,30 +4,21 @@ module TableGo
       extend ActiveSupport::Concern
 
       included do
-        attr_accessor :source_table, :title, :table_html, :row_html, :template
+        attr_accessor :table, :template
         delegate :content_tag, :concat, :to => :template
       end
 
-
-      def apply_options(options)
-        self.title      = options.delete(:title)
-        self.table_html = options.delete(:table_html)
-        self.row_html   = options.delete(:row_html)
-      end
-
       def render_template
         raise ArgumentError.new('implement #render_template in concrete renderer')
       end
 
-
-
       private
 
         def label_for_column(column)
           column.label || begin
-            if column.method && 1==3# reflection = source_table.model_klass.reflections[column.name]
+            if column.method && 1==3# reflection = table.model_klass.reflections[column.name]
               reflection.klass.human_attribute_name(column.method).html_safe
-            # if column.method && reflection = source_table.model_klass.reflections[column.name]
+            # if column.method && reflection = table.model_klass.reflections[column.name]
             #   reflection.klass.human_attribute_name(column.method).html_safe
             else
               column.human_attribute_name
@@ -45,7 +36,7 @@ module TableGo
 
         def html_options_for_row(record)
           {}.tap do |h|
-            (row_html || {}).each do |k, v|
+            (table.row_html || {}).each do |k, v|
               h[k] = v.is_a?(Proc) ? v.call(record) : v
             end
           end
@@ -69,40 +60,131 @@ module TableGo
         end
 
         def apply_formatter(record, column, value)
-          case
-            when formatter = column.as
-              Formatter.apply(formatter, record, column, value)
-            when formatter = column.send
-              Formatter.apply_send(formatter, record, column, value)
-            when formatter = column.block
-              apply_formatter_for_block(formatter, record, column, value)
-            else
-              value
-          end
+          begin
+            case
+              when formatter = column.as
+                Formatter.apply(formatter, record, column, value)
+              when formatter = column.send
+                Formatter.apply_send(formatter, record, column, value)
+              when formatter = column.block
+                apply_formatter_for_block(formatter, record, column, value)
+              else
+                value
+            end
+          end.to_s.html_safe
         end
 
 
 
         def apply_formatter_for_block(formatter, record, column, value)
-          s = nil
+          # template.capture { Formatter.apply(formatter, record, column, value )}
+          # template.capture_haml { Formatter.apply(formatter, record, column, value )}
+          # template.send(:capture_haml) { Formatter.apply(formatter, record, column, value )}
+          string = nil
           capture_view do
-            s = Formatter.apply(formatter, record, column, value )
-          end.presence || s # for compatibility to legacy haml "- t.column :ident"
+            string = Formatter.apply(formatter, record, column, value )
+          end.presence || string # for compatibility to legacy haml "- t.column :ident"
         end
 
-        def capture_view(&proc)
-          @capturer ||= template.is_haml? ? capture_haml : capture_action_view
-          @capturer.call(proc)
-        end
 
-        def capture_haml(&proc)
-          lambda { |c| template.capture_haml { c.call } }
+        def capture_view
+          template.is_haml? ? capture_haml { yield } : template.capture { yield }
         end
 
-        def capture_action_view
-          lambda { |c| template.capture { c.call } }
+        delegate :with_haml_buffer, :haml_buffer, :to => :template
+
+        # stripped down ripoff from Haml's capture_haml, needed for speed
+        def capture_haml(*args, &block)
+          # buffer = eval('if defined? _hamlout then _hamlout else nil end', block.binding) || haml_buffer
+          # buffer = haml_buffer
+          # with_haml_buffer(buffer) do
+            position = haml_buffer.buffer.length
+
+            haml_buffer.capture_position = position
+            block.call(*args)
+
+            # captured = haml_buffer.buffer.slice!(0..-1)
+            captured = haml_buffer.buffer.slice!(position..-1)
+            # return captured if haml_buffer.options[:ugly]
+
+            # debugger
+            # Note that the "reject" is needed for rbx 1.2.4, which includes empty
+            # strings in the returned array when splitting by /^/.
+            # captured = captured.split(/^/).reject {|x| x == ""}
+
+            # min_tabs = nil
+            # captured.each do |line|
+            #   tabs = line.index(/[^ ]/) || line.length
+            #   min_tabs ||= tabs
+            #   min_tabs = min_tabs > tabs ? tabs : min_tabs
+            # end
+
+            # captured.map do |line|
+            #   line.slice(min_tabs, line.length)
+            # end.join
+          # end
+        ensure
+          haml_buffer.capture_position = nil
         end
 
+
+        # def capture_haml(*args, &block)
+        #   # buffer = eval('if defined? _hamlout then _hamlout else nil end', block.binding) || haml_buffer
+        #   # buffer = haml_buffer
+        #   # with_haml_buffer(buffer) do
+        #     position = haml_buffer.buffer.length
+
+        #     haml_buffer.capture_position = position
+        #     block.call(*args)
+
+        #     captured = haml_buffer.buffer.slice!(position..-1)
+        #     # return captured if haml_buffer.options[:ugly]
+
+        #     # debugger
+        #     # Note that the "reject" is needed for rbx 1.2.4, which includes empty
+        #     # strings in the returned array when splitting by /^/.
+        #     captured = captured.split(/^/).reject {|x| x == ""}
+
+        #     # min_tabs = nil
+        #     # captured.each do |line|
+        #     #   tabs = line.index(/[^ ]/) || line.length
+        #     #   min_tabs ||= tabs
+        #     #   min_tabs = min_tabs > tabs ? tabs : min_tabs
+        #     # end
+
+        #     # captured.map do |line|
+        #     #   line.slice(min_tabs, line.length)
+        #     # end.join
+        #   # end
+        # ensure
+        #   haml_buffer.capture_position = nil
+        # end
+
+        # def capture_view
+        #   template.is_haml? ? template.capture_haml { yield } : template.capture { yield }
+        # end
+
+        # def capture_view
+        #   template.send(capture_method) { yield }
+        # end
+
+        # def capture_method
+        #   @capture_method ||= template.is_haml? ? :capture_haml : :capture
+        # end
+
+        # def capture_view(&proc)
+        #   @capturer ||= template.is_haml? ? capture_haml : capture_action_view
+        #   @capturer.call(proc)
+        # end
+
+        # def capture_haml(&proc)
+        #   lambda { |c| template.capture_haml { c.call } }
+        # end
+
+        # def capture_action_view
+        #   lambda { |c| template.capture { c.call } }
+        # end
+
     end
   end
 end

data/lib/table_go/table.rb

@@ -1,21 +1,24 @@
 module TableGo
   class Table
 
-    attr_accessor :collection, :model_klass, :columns
+    attr_accessor :collection, :model_klass
+    attr_accessor :columns
 
-    def initialize(collection, model_klass, &block)
+    def initialize(collection, model_klass, options, &block)
       @collection  = collection
       @model_klass = model_klass
-      @columns     = Columns.new(self)
-      evaluate_dsl(block)
+      @columns     = []
+      apply_options!(options)
+      evaluate_dsl!(block)
     end
 
-    def evaluate_dsl(block)
+    def evaluate_dsl!(block)
       if block
-        block.call(@columns)
+        # instance_eval(&block)
+        block.call(self)
       else
         attribute_names_from_model_klass.each do |column_name|
-          @columns.column(column_name)
+          column(column_name)
         end
       end
     end
@@ -24,9 +27,35 @@ module TableGo
     #   @model_klass_reflection_keys ||= model_klass.reflections.keys
     # end
 
+
     def attribute_names_from_model_klass
       model_klass.respond_to?(:column_names) ? model_klass.column_names : []
     end
 
+    def apply_options!(options)
+      options.each { |k, v| send(k, v) }
+    end
+
+
+
+    def column(name, options = {}, &block)
+      @columns << Column.new(self, name, options, &block)
+    end
+
+    def title(title = nil)
+      @title = title if title
+      @title
+    end
+
+    def table_html(table_html = nil)
+      @table_html = table_html if table_html
+      @table_html
+    end
+
+    def row_html(row_html = nil)
+      @row_html = row_html if row_html
+      @row_html
+    end
+
   end
 end

data/lib/table_go/table_renderer.rb

@@ -1,16 +1,16 @@
 module TableGo
   class TableRenderer
     attr_accessor :renderer_klass, :template
-    delegate      :apply_options, :render_template, :to => :renderer
+    delegate      :render_template, :to => :renderer
 
-    def initialize(source_table)
-      @source_table = source_table
+    def initialize(table)
+      @table = table
     end
 
     def renderer
       @renderer ||= renderer_klass.new.tap do |r|
-        r.template     = template
-        r.source_table = @source_table
+        r.template  = template
+        r.table     = @table
       end
     end
 

data/lib/table_go/version.rb

@@ -1,3 +1,3 @@
 module TableGo
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end

data/spec/fixtures/simple_table.html.haml

@@ -1,3 +1,4 @@
+%p Suppe
 = table_go_for(articles, Article) do |t|
   - t.column :ident
   - t.column :custom_single_cell do |value, record, column|
@@ -7,3 +8,8 @@
     = " Title: %s" % record.title
   - t.column :custom_single_cell_with_backwards_compatibility do |value, record, column|
     - "Ident: %s" % record.ident
+  - t.column :field_with_html_markup, :label => 'field with_html_markup' do |value, record, column|
+    = link_to('click me', 'http://nowhere.com')
+    %br
+    = link_to('and here', 'http://otherwhere.com')
+%p Pampe

data/spec/table_go/{helper_spec.rb → helpers_spec.rb}

@@ -23,9 +23,9 @@ describe TableGo::Helpers do
       Haml::Engine.new(read_file_from_fixtures_path('simple_table.html.haml')).render(template, :articles => articles)
     end
 
-
     it "it should render in haml" do
-      subject.cleanup_html.should == %Q(
+      subject.cleanup_html.should eql %Q(
+        <p>Suppe</p>
         <table>
           <thead>
             <tr>
@@ -33,6 +33,7 @@ describe TableGo::Helpers do
               <th>Custom single cell</th>
               <th>Custom multiline cell</th>
               <th>Custom single cell with backwards compatibility</th>
+              <th>field with_html_markup</th>
             </tr></thead>
           <tbody>
             <tr>
@@ -40,20 +41,38 @@ describe TableGo::Helpers do
               <td>Ident: 1 - Title: iPutz</td>
               <td>Ident: 1 - Title: iPutz</td>
               <td>Ident: 1</td>
+              <td><a href="http://nowhere.com">click me</a><br /><a href="http://otherwhere.com">and here</a></td>
             </tr>
             <tr>
               <td>2</td>
               <td>Ident: 2 - Title: Nutzbook</td>
               <td>Ident: 2 - Title: Nutzbook</td>
               <td>Ident: 2</td>
+              <td><a href="http://nowhere.com">click me</a><br /><a href="http://otherwhere.com">and here</a></td>
             </tr>
           </tbody>
         </table>
+        <p>Pampe</p>
       ).cleanup_html
     end
 
 
   end
 
+  # context 'speedtest' do
+
+  #   let(:more_articles) { 1000.times.map { articles }.flatten }
+
+
+  #   it 'should run fast' do
+  #     puts Benchmark.measure {
+  #       2.times do
+  #         Haml::Engine.new(read_file_from_fixtures_path('simple_table.html.haml')).render(template, :articles => more_articles)
+  #       end
+  #     }
+  #   end
+
+  # end
+
 end
 

data/spec/table_go/renderers/html_renderer_spec.rb

@@ -20,7 +20,7 @@ describe TableGo::Renderers::HtmlRenderer do
     subject { TableGo.render_html(articles, Article, template, {}) }
 
     it 'should render a simple automatic html table' do
-      subject.cleanup_html.should == %Q(
+      subject.cleanup_html.should eql %Q(
         <table>
           <thead>
             <tr>
@@ -96,7 +96,7 @@ describe TableGo::Renderers::HtmlRenderer do
         t.column :info_text,
                  :label => 'with block level custom formatter' do |value, record, column|
 
-          "a special<br/>value"
+            "a special<br/>value"
 
         end
 
@@ -114,7 +114,7 @@ describe TableGo::Renderers::HtmlRenderer do
     end
 
     it 'should render a html table', 'with custom attributes' do
-      subject.cleanup_html.should == %Q(
+      subject.cleanup_html.should eql %Q(
         <table id="articles">
           <caption>one Table</caption>
           <thead>
@@ -157,10 +157,39 @@ describe TableGo::Renderers::HtmlRenderer do
         </table>
       ).cleanup_html
     end
+  end
 
 
-  end
+  describe "block style options" do
+    let(:table_with_hash_options) do
+      TableGo.render_html(articles, Article, template,
+        :title => 'one Table',
+        :table_html => { :id => :articles },
+        :row_html   => { :class => :row_css_class,
+                         :id    => lambda { |record| "row_#{record.ident}" }}) do |t|
+        t.column :ident,
+                 :column_html => { :class => lambda { |record, column, value| value.even? ? :even : :odd } }
+      end
+    end
 
+    subject(:table_with_block_options) do
+      TableGo.render_html(articles, Article, template) do |t|
+        t.title      'one Table'
+        t.table_html :id => :articles
+        t.row_html   :class => :row_css_class,
+                     :id    => lambda { |record| "row_#{record.ident}" }
+
+        t.column :ident,
+                 :column_html => { :class => lambda { |record, column, value| value.even? ? :even : :odd } }
+      end
+    end
+
+
+    it "should render the same way as with hash style options" do
+      subject.should eql table_with_hash_options
+    end
+
+  end
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: table_go
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - Lars Gollnow
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-09-27 00:00:00 Z
+date: 2013-10-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: actionpack
@@ -67,7 +67,6 @@ files:
 - Rakefile
 - lib/table_go.rb
 - lib/table_go/column.rb
-- lib/table_go/columns.rb
 - lib/table_go/formatter.rb
 - lib/table_go/helpers.rb
 - lib/table_go/railtie.rb
@@ -80,7 +79,7 @@ files:
 - lib/table_go/version.rb
 - spec/fixtures/simple_table.html.haml
 - spec/spec_helper.rb
-- spec/table_go/helper_spec.rb
+- spec/table_go/helpers_spec.rb
 - spec/table_go/renderers/csv_renderer_spec.rb
 - spec/table_go/renderers/html_renderer_spec.rb
 - table_go.gemspec
@@ -110,6 +109,6 @@ summary: ""
 test_files: 
 - spec/fixtures/simple_table.html.haml
 - spec/spec_helper.rb
-- spec/table_go/helper_spec.rb
+- spec/table_go/helpers_spec.rb
 - spec/table_go/renderers/csv_renderer_spec.rb
 - spec/table_go/renderers/html_renderer_spec.rb

data/lib/table_go/columns.rb

@@ -1,19 +0,0 @@
-module TableGo
-  class Columns
-    include Enumerable
-    attr_accessor :table
-
-    def initialize(table)
-      @table, @columns = table, []
-    end
-
-    def column(name, options = {}, &block)
-      @columns << Column.new(table, name, options, &block)
-    end
-
-    def each(&block)
-      @columns.each(&block)
-    end
-
-  end
-end