greentable 0.0.9 → 0.9.0

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,13 @@
+*.iml
+*.ipr
+*.iws
+test/*.iml
+*.gem
+.idea
+.bundle/
+log/*.log
+pkg/
+test/dummy/log/*.log
+test/dummy/tmp/
+test/dummy/.sass-cache
+coverage

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.1.0
+  - 1.9.3
+#  - jruby-18mode # JRuby in 1.8 mode
+#  - jruby-19mode # JRuby in 1.9 mode
+#  - rbx-2.1.1
+#  - 1.8.7

data/Gemfile

@@ -0,0 +1,17 @@
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in greentable.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# jquery-rails is used by the dummy application
+gem "jquery-rails"
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/Gemfile.lock

@@ -0,0 +1,135 @@
+PATH
+  remote: .
+  specs:
+    greentable (0.9.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (3.2.17)
+      actionpack (= 3.2.17)
+      mail (~> 2.5.4)
+    actionpack (3.2.17)
+      activemodel (= 3.2.17)
+      activesupport (= 3.2.17)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.5)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.17)
+      activesupport (= 3.2.17)
+      builder (~> 3.0.0)
+    activerecord (3.2.17)
+      activemodel (= 3.2.17)
+      activesupport (= 3.2.17)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.17)
+      activemodel (= 3.2.17)
+      activesupport (= 3.2.17)
+    activesupport (3.2.17)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.3)
+    builder (3.0.4)
+    coderay (1.0.9)
+    erubis (2.7.0)
+    fastercsv (1.5.5)
+    ffi (1.9.0)
+    formatador (0.2.4)
+    guard (1.8.2)
+      formatador (>= 0.2.4)
+      listen (>= 1.0.0)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-test (1.0.0)
+      guard (>= 1.8)
+      test-unit (~> 2.2)
+    hike (1.2.3)
+    i18n (0.6.9)
+    journey (1.0.4)
+    jquery-rails (3.1.0)
+      railties (>= 3.0, < 5.0)
+      thor (>= 0.14, < 2.0)
+    json (1.8.1)
+    listen (1.3.0)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      rb-kqueue (>= 0.2)
+    lumberjack (1.0.4)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    method_source (0.8.2)
+    mime-types (1.25.1)
+    mini_portile (0.5.2)
+    multi_json (1.9.2)
+    nokogiri (1.6.1)
+      mini_portile (~> 0.5.0)
+    polyglot (0.3.4)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rack (1.4.5)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.4)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (3.2.17)
+      actionmailer (= 3.2.17)
+      actionpack (= 3.2.17)
+      activerecord (= 3.2.17)
+      activeresource (= 3.2.17)
+      activesupport (= 3.2.17)
+      bundler (~> 1.0)
+      railties (= 3.2.17)
+    railties (3.2.17)
+      actionpack (= 3.2.17)
+      activesupport (= 3.2.17)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (10.2.2)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.1)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.0)
+      ffi (>= 0.5.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    slop (3.4.6)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.9)
+    test-unit (2.5.5)
+    thor (0.19.1)
+    tilt (1.4.1)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.39)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fastercsv
+  greentable!
+  guard-test
+  jquery-rails
+  nokogiri
+  rack-test
+  rails (~> 3.2.17)
+  sqlite3
+  test-unit

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :test, :drb => false, :all_on_start => true do
+  watch(%r{^test/.+_test\.rb$})
+end
+
+

data/README.md

@@ -1,12 +1,8 @@
+[![Build Status](https://travis-ci.org/waelchatila/greentable.svg?branch=master)](https://travis-ci.org/waelchatila/greentable)
 Greentable
 ==========
-
 Greentable produces HTML tables from an array without you having to deal with any HTML elements.
-Greentable is an declarative approach to HTML tables and adds additional export (csv,xls,pdf,xml) features.
-
-Please note that the export module is still under development.
-
-Tested on rails 3.2, using ruby 1.9.3
+Greentable is an declarative approach to HTML tables and adds additional export features.
 
 ## Installation
 ```ruby
@@ -14,7 +10,7 @@ gem 'greentable'
 ```
 
 ## Usage
-The Greentable gem provides two methods only. To produce a table from an array of elements, do the following in a view:
+To produce a table from an array of elements, do the following in a view:
 
 ```haml
 =greentable(users) do |gt,user|
@@ -47,38 +43,67 @@ which will produce the following html:
 </table>
 ```
 
-## Optional Options
+## Options
 
 Both greentable and greentable.col may be called with an optional hash
 
 ```haml
-=greentable(array, class: 'a', style: 'b:c', tr: {class: 'd'}, th: {onclick: 'e();'}, td: {'data-target' => 'f'} ) do |gt, el|
-  -gt.col('Col 1', class: 'g', th: {class: 'h'}) do
-    = el.col1
-  -gt.col('Col 2') do
-    = el.col2
+=greentable(array, class: 'table_class') do |gt, el|
+  -gt.col('col0', th: {class: 'th_class'}) do
+    =el.col0
+  -gt.col('col1', td: {class: 'td_class'}) do
+    =el.col1
+```
+
+will produce
+
+```html
+<table class="table_class"">
+    <thead>
+        <tr>
+            <th class="th_class">col0</th>
+            <th>col1</th>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td>...</td>
+            <td class="td_class">...</td>
+        </tr>
+    </tbody>
+</table>
+```
+
+A comprehensive example:
+
+```haml
+=greentable(array, class: 'a aa', style: 'b:c', tr: {class: 'd'}, th: {onclick: 'e();'}, td: {class: 'f', 'data-target' => 'g'} ) do |gt, el|
+  -gt.col('col0', class: 'h', th: {class: 'i'}) do
+    =el.col0
+  -gt.col('col1', td: {class: 'j'}) do
+    =el.col1
 ```
 
 will produce
 
 ```html
-<table class='a' style='b:c'>
+<table class="a aa" style="b:c">
     <thead>
-        <tr class='d'>
-          <th class='h' onclick='e();'>Col 1</th>
-          <th onclick='e();'>Col 2</th>
+        <tr class="d">
+            <th onclick="e();" class="h i ee">col0</th>
+            <th onclick="e();" class="ee">col1</th>
         </tr>
     </thead>
     <tbody>
-        <tr class='d'>
-            <td class='g' data-target='f'>...</td>
-            <td data-target='f'>...</td>
+        <tr class="d">
+            <td data-target="f" class="h ff">0</td>
+            <td data-target="f" class="j ff">0</td>
         </tr>
     </tbody>
 </table>
 ```
 
-If you need column names or options to be a little more dynamic, you can use procs:
+If you need column names or options to be dynamic, you can use procs:
 
 ```haml
 =greentable(years) do |gt,year|
@@ -160,11 +185,39 @@ will produce
 </table>
 ```
 
-## Green Export
+## Green Export &amp; Green Printing
+
+Greentable enables you to export or print your greentable data for download in various formats seamlessly by a rack middleware.
+Add a couple of http query parameters in your view and your done:
+
+```erb
+<a href="/?greentable_export=csv&greentable_id=greentable_id">Export CSV</a>
+|
+<a href="/?greentable_export=print&greentable_id=greentable_id">Print</a>
+
+<%= greentable([0], :id => 'greentable_id') do |gt, el| %>
+    <% gt.col('i') do %>
+        <%= el %>
+    <% end %>
+    <% gt.col('i+1') do %>
+        <%= el + 1 %>
+    <% end %>
+<% end %>
+```
+
+### Available Query Parameters
 
-Greentable enables you to export your greentable data for download in various formats seamlessly by a rack middleware.
+* **greentable_id**=*any string* [REQUIRED]. A unique html tag id to tell the rack middleware which greentable to extract.
+* **greentable_export**=**csv** | **print** [REQUIRED].
+  **csv** will produce a CSV file. Headers will be the table headers. Colspans are honored (row spans are not).
+  **print** will extract the green table by id and insert a javascript snippet to print the doc
+  ```javascript
+    window.onload = function() { window.focus(); window.print(); }
+  ```
+  Any css styling done within the html *HEAD* will remain. Anything within the *BODY* will be replaced with the greentable content.
+* **greentable_export_filename**=*any string* [OPTIONAL]. *default: 'export.csv'*.
+  Specifies the filename in the *Content-Disposition* header. Only used if *greentable_export=csv*
 
 
-[export still under development. more soon]
 
 

data/Rakefile

@@ -1 +1,38 @@
-require "bundler/gem_tasks"
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Greentable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/greentable.gemspec

@@ -1,18 +1,33 @@
-Gem::Specification.new do |s|
-  s.name        = "greentable"
-  s.version     = "0.0.9"
-  s.author      = "Wael Chatila"
-  s.homepage    = "https://github.com/waelchatila/greentable"
-  s.summary     = "Rails declarative html tables with export features"
-  s.description = "Greentable produces HTML tables from an array without you having to deal with any HTML elements."
-  s.license = 'LGPLv3+'
+$:.push File.expand_path("../lib", __FILE__)
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  #s.add_dependency 'name', 'version'
+require "greentable/version"
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'testunit'
+Gem::Specification.new do |spec|
+  spec.name          = "greentable"
+  spec.version     = Greentable::VERSION
+  spec.authors       = ["Wael Chatila"]
+  spec.description = "Greentable produces HTML tables from an array without you having to deal with any HTML elements."
+  spec.summary     = "Rails declarative html tables with export features"
+  spec.homepage    = "https://github.com/waelchatila/greentable"
+  spec.license = 'LGPLv3+'
+
+  spec.files = Dir["{app,config,db,lib}/**/*"] + ["Rakefile", "README.md"]
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  #spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.test_files = Dir["test/**/*"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rails", "~> 3.2.17"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency 'test-unit'
+  spec.add_development_dependency "nokogiri"
+  spec.add_development_dependency "fastercsv"
+  spec.add_development_dependency "guard-test"
+  spec.add_development_dependency "rack-test"
+  #spec.add_development_dependency 'simplecov'
+  #spec.add_development_dependency 'coveralls'
 end
+
+
+

data/lib/greentable/export.rb

@@ -1,3 +1,6 @@
+require 'csv'
+require 'nokogiri'
+
 module Greentable
   class Export
     def initialize(app, *args, &block)
@@ -10,44 +13,51 @@ module Greentable
     end
 
     def _call(env)
-      @status, @headers, @response = @app.call(env) rescue nil
-      @ret = nil
-      if env['QUERY_STRING'] =~ /greentable_export=([csv|rtf|xml]+)/i
+      status, headers, response = @app.call(env) rescue nil
+      greentable_export = (env['QUERY_STRING'] || '').scan(/greentable_export=([csv|print]+)/i)[0][0] rescue nil
+      if greentable_export
         request    = Rack::Request.new(env)
         greentable_id = request.params['greentable_id']
         if greentable_id
-          format = $1
-          body = @response.respond_to?(:body) ? @response.body : @response.join
-          doc = Hpricot(body.to_s)
-          @ret= ""
-          (doc/"##{greentable_id}//tr").each do |tr|
-            row = []
-            col = 0
-            (tr/"/th | /td").each do |x|
-              colspan = [(x.attributes['colspan'] || 1).to_i, 1].max
-              row[col] = x.to_plain_text
-              col += colspan
+          body = response.respond_to?(:body) ? response.body : response.join
+          doc = Nokogiri(body.to_s)
+          if greentable_export == 'csv'
+            ret= ""
+            (doc/"##{greentable_id}//tr").each do |tr|
+              row = []
+              col = 0
+              (tr/"./th | ./td").each do |x|
+                colspan = (x.attributes['colspan'] || 1).to_i
+                colspan = [colspan,1].max
+                row[col] = (x.inner_text || '').strip
+                col += colspan
+              end
+              CSV.generate(ret, :encoding => 'UTF-8'){ |csv| csv << row }
             end
-            CSV.generate_row(row, row.length, @ret)
+            filename = request.params['greentable_export_filename'] || "export"
+            headers["Content-Length"] = ret.length.to_s
+            headers["Content-Type"] = "text/csv"
+            headers["Content-Disposition"] = "attachment; filename=#{filename}.#{greentable_export}"
+            headers.delete('ETag')
+            headers.delete('Cache-Control')
+            response = [ret]
+          elsif greentable_export == 'print'
+            table_node = doc.css("##{greentable_id}").remove
+            body = doc.css('body')[0]
+            js_print = "<script>window.onload = function() { window.focus(); window.print(); }</script>"
+            body.inner_html = table_node.to_html + js_print
+            response = [doc.to_html]
           end
-
-          filename = request.params['greentable_export_filename'] || "export"
-
-          @headers["Content-Length"] = @ret.length.to_s
-          @headers["Content-Type"] = "text/csv"
-          @headers["Content-Disposition"] = "attachment; filename=#{filename}.#{format}"
-          @headers.delete('ETag')
-          @headers.delete('Cache-Control')
         end
       end
 
-      [@status, @headers, self]
+      [status, headers, response]
     end
 
-    def each(&block)
-      block.call(@ret) if @ret
-      @response.each(&block)
-    end
+    #def each(&block)
+    #  block.call(ret) if ret
+    #  response.each(&block)
+    #end
 
   end
 end

data/lib/greentable/greentable_table.rb

@@ -7,11 +7,11 @@ module Greentable
     def initialize(parent, records, opts)
       @parent = parent
       @records = records
-      defaults = Greentable.configuration.defaults.clone rescue {}
-      @defaults_tr = (defaults.delete(:tr) || {}).deep_merge(opts.delete(:tr) || {})
-      @defaults_th = (defaults.delete(:th) || {}).deep_merge(opts.delete(:th) || {})
-      @defaults_td = (defaults.delete(:td) || {}).deep_merge(opts.delete(:td) || {})
-      @opts = defaults.deep_merge(opts)
+      defaults = Greentable.configuration.defaults.dup rescue {}
+      @defaults_tr = deep_merge(defaults.delete(:tr), opts.delete(:tr))
+      @defaults_th = deep_merge(defaults.delete(:th), opts.delete(:th))
+      @defaults_td = deep_merge(defaults.delete(:td), opts.delete(:td))
+      @opts = deep_merge(defaults, opts)
 
       #rows
       @tr_attributes = []
@@ -32,8 +32,10 @@ module Greentable
 
     def col(th = nil, opts = {}, &block)
       @th_html[@current_col] = th
-      @th_attributes[@current_col] = opts.delete(:th) || {}
-      @td_attributes[@current_col] = opts
+      th_opts = opts.delete(:th) || {}
+      td_opts = opts.delete(:td) || {}
+      @th_attributes[@current_col] = deep_merge(th_opts, opts)
+      @td_attributes[@current_col] = deep_merge(td_opts, opts)
 
       @td_html[@row_counter.i] ||= []
       @td_html[@row_counter.i][@current_col] = @parent.capture(&block)
@@ -50,6 +52,8 @@ module Greentable
         block.call(self, record)
         @row_counter.inc
       end
+
+      self
     end
 
     def to_s
@@ -58,9 +62,9 @@ module Greentable
       ret << "<table#{do_attributes(nil,@opts)}>"
       unless @th_html.compact.empty?
         ret << "<thead>"
-        ret << "<tr>"
+        ret << "<tr#{do_attributes(nil, @defaults_tr)}>"
         @th_html.each_with_index do |th,col|
-          ret << "<th#{do_attributes(nil,@th_attributes[col])}>#{th.is_a?(Proc) ? th.call.to_s : th}</th>"
+          ret << "<th#{do_attributes(nil, deep_merge(@defaults_th, @th_attributes[col]))}>#{th.is_a?(Proc) ? th.call.to_s : th}</th>"
         end
         ret << "</tr>"
         ret << "</thead>"
@@ -68,14 +72,15 @@ module Greentable
       ret << "<tbody>"
 
       @row_counter.i.times do |row|
-        ret << "<tr#{do_attributes(row,@defaults_tr.deep_merge(@tr_attributes[row]||{}))}>"
+        ret << "<tr#{do_attributes(row, deep_merge(@defaults_tr, @tr_attributes[row]))}>"
         @td_html[row].each_with_index do |td,col|
-          ret << "<td#{do_attributes(row,@defaults_td.deep_merge(@td_attributes[col]||{}))}>#{td}</td>"
+          ret << "<td#{do_attributes(row, deep_merge(@defaults_td, @td_attributes[col]))}>#{td}</td>"
         end
         ret << "</tr>"
       end
       ret << "</tbody>"
       ret << "</table>"
+      ret.html_safe
     end
 
     private
@@ -87,5 +92,29 @@ module Greentable
       return ret
     end
 
+    def deep_merge(source_hash, specialized_hash)
+      deep_merge!((source_hash||{}).dup, (specialized_hash||{}).dup)
+    end
+
+    def deep_merge!(source_hash, specialized_hash)
+      #this code is originally from the gem hash-deep-merge, but has been modified slightly
+      specialized_hash.each_pair do |rkey, rval|
+        if source_hash.has_key?(rkey) then
+          lval = source_hash[rkey]
+          if rval.is_a?(Hash) and lval.is_a?(Hash) then
+            deep_merge(source_hash[rkey], rval)
+          elsif rval == source_hash[rkey] then
+          elsif rval.is_a?(String) and lval.is_a?(String)
+            source_hash[rkey] = "#{rval} #{lval}"
+          else
+            source_hash[rkey] = rval
+          end
+        else
+          source_hash[rkey] = rval
+        end
+      end
+      return source_hash
+    end
+
   end
 end

data/lib/greentable/railtie.rb

@@ -7,8 +7,8 @@ module Greentable
       ActionView::Base.send :include, ViewHelpers
     end
 
-    #initializer "greentable.rackexport" do |app|
-    #  app.middleware.use Greentable::Export
-    #end
+    initializer "greentable.rackexport" do |app|
+      app.middleware.use Greentable::Export
+    end
   end
 end

data/lib/greentable/version.rb

@@ -0,0 +1,3 @@
+module Greentable
+  VERSION = "0.9.0"
+end

data/lib/greentable/view_helpers.rb

@@ -5,7 +5,6 @@ module Greentable
     def greentable(records, opts = {}, &block)
       gt = Table.new(self,records, opts)
       gt.process(&block)
-      gt.to_s.html_safe
     end
   end
 end

data/lib/greentable.rb

@@ -1,5 +1,5 @@
-
 module Greentable
   require 'greentable/railtie' if defined?(Rails)
   require 'greentable/configuration'
+  require 'greentable/greentable_table'
 end

data/lib/tasks/greentable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :greentable do
+#   # Task goes here
+# end

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .