thamble 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 151f04c20fd4fb3d9bc6d0d014abe94424beaa13
+  data.tar.gz: ebf84e54eb74d67aa190d7799a5f7d2359bbef6d
+SHA512:
+  metadata.gz: 8f18301bfd0ceffe9e2fdafd6f9f4f66c7b40b7c8ad72023906820061bfca39fd79f5ef52d709fd10642386cf9add244ee876789bc16b481d24f9c1111aa1843
+  data.tar.gz: ec63ac38947321bf99a5452da6c248248f1bcab1744b4b80391a5b07da0342c23a8d7f95889c474a5d775e75a801bb5c3ed20f23c5b6798a37ca8913c85ac831

data/CHANGELOG

@@ -0,0 +1,3 @@
+=== 1.0.0 (2014-01-07)
+
+* Initial Public Release

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2013 Jeremy Evans
+
+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 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.rdoc

@@ -0,0 +1,100 @@
+= Thamble
+
+Thamble exposes a single method, table, for easily creating HTML
+tables from enumerable objects.
+
+= Installation
+
+  sudo gem install thamble
+
+= Source Code
+
+Source code is available on GitHub at https://github.com/jeremyevans/thamble
+
+= Examples
+
+The default behavior just expects an enumerable of arrays (such as an array of
+arrays), and returns a string containing the HTML TABLE output:
+
+  puts Thamble.table([[1, 2]])
+
+    <table>
+    <tbody>
+    <tr>
+    <td>1</td>
+    <td>2</td>
+    </tr>
+    </tbody>
+    </table>
+
+If a block is passed to the method, all items in the enumerable are yielded to
+the block, and the block should return an array with the data to use in the table:
+
+  puts Thamble.table([{:a=>1, :b=>2}, {:a=>3, :b=>4}]){|l| [l[:b], l[:a] + 10]}
+
+    <table>
+    <tbody>
+    <tr>
+    <td>2</td>
+    <td>11</td>
+    </tr>
+    <tr>
+    <td>4</td>
+    <td>13</td>
+    </tr>
+    </tbody>
+    </table>
+
+You can use the :headers option to set custom headers:
+
+  puts Thamble.table([[1, 2], [3, 4]], :headers=>['A', 'B'])
+
+    <table>
+    <thead>
+    <tr>
+    <th>A</th>
+    <th>B</th>
+    </tr>
+    </thead>
+    <tbody>
+    <tr>
+    <td>1</td>
+    <td>2</td>
+    </tr>
+    <tr>
+    <td>3</td>
+    <td>4</td>
+    </tr>
+    </tbody>
+    </table>
+
+Other options supported are:
+
+:caption :: A caption for the table
+:table :: HTML attribute hash for the table itself
+:td :: HTML attribute hash for the table data cells, can be a proc called
+       with the data value, row position, and row that returns a hash
+:th :: HTML attribute hash for the table header cells, can be a proc called
+       with the header that returns a hash
+:tr :: HTML attribute hash for the table rows, can be a proc called with
+       the row that returns a hash
+:widths :: Array of widths for each column
+
+= Rails Support
+
+Thamble comes with basic rails support via:
+
+  require 'thamble/rails'
+  ApplicationController.helper Thamble::RailsHelper
+
+This allows you to use the following style in your templates:
+
+  <%= thamble([[1, 2], [3, 4]], :headers=>['A', 'B']) %>
+
+= License
+
+MIT
+
+= Author
+
+Jeremy Evans <code@jeremyevans.net>

data/Rakefile

@@ -0,0 +1,69 @@
+require "rake"
+require "rake/clean"
+
+CLEAN.include ["thamble-*.gem", "rdoc", "coverage"]
+
+desc "Build thamble gem"
+task :package=>[:clean] do |p|
+  sh %{#{FileUtils::RUBY} -S gem build thamble.gemspec}
+end
+
+### Specs
+
+begin
+  begin
+    # RSpec 1
+    require "spec/rake/spectask"
+    spec_class = Spec::Rake::SpecTask
+    spec_files_meth = :spec_files=
+  rescue LoadError
+    # RSpec 2
+    require "rspec/core/rake_task"
+    spec_class = RSpec::Core::RakeTask
+    spec_files_meth = :pattern=
+  end
+
+  spec = lambda do |name, files, d|
+    lib_dir = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
+    ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
+    desc d
+    spec_class.new(name) do |t|
+      t.send(spec_files_meth, files)
+    end
+  end
+
+  task :default => [:spec]
+  spec.call("spec", Dir["spec/*_spec.rb"], "Run specs")
+rescue LoadError
+  task :default do
+    puts "Must install rspec to run the default task (which runs specs)"
+  end
+end
+
+### RDoc
+
+RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Thamble: Create HTML Tables from Enumerables']
+
+begin
+  gem 'rdoc', '= 3.12.2'
+  gem 'hanna-nouveau'
+  RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
+rescue Gem::LoadError
+end
+
+rdoc_task_class = begin
+  require "rdoc/task"
+  RDoc::Task
+rescue LoadError
+  require "rake/rdoctask"
+  Rake::RDocTask
+end
+
+RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
+
+rdoc_task_class.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb"
+end
+

data/lib/thamble.rb

@@ -0,0 +1,207 @@
+require 'rack/utils'
+
+# Thamble exposes a single method named table to make it easy to generate
+# an HTML table from an enumerable.
+module Thamble
+  # Empty frozen hash used for default option hashes
+  OPTS = {}.freeze
+
+  # Return a string containing an HTML table representing the data from the
+  # enumerable.  +enum+ should be an enumerable containing the data.  If a block
+  # is given, it is yielded each element in +enum+, and should return an array
+  # representing the table data to use for that row.
+  #
+  # Options:
+  #
+  # :headers :: The headers to use for the table, as an array of strings or a
+  #             single string using commas as the separtor.
+  # :caption :: A caption for the table
+  # :table :: HTML attribute hash for the table itself
+  # :td :: HTML attribute hash for the table data cells, can be a proc called
+  #        with the data value, row position, and row that returns a hash
+  # :th :: HTML attribute hash for the table header cells, can be a proc called
+  #        with the header that returns a hash
+  # :tr :: HTML attribute hash for the table rows, can be a proc called with
+  #        the row that returns a hash
+  # :widths :: An array of widths to use for each column
+  def table(enum, opts=OPTS)
+    t = Table.new(opts)
+    enum.each do |row|
+      row = yield(row, t) if block_given?
+      t << row
+    end
+    t.to_s
+  end
+  module_function :table
+
+  # The Table class stores the rows and attributes to use for the HTML tags,
+  # and contains helper methods for common formatting.
+  class Table
+    # Create a new Table instance.  Usually not called directly,
+    # but through Thamble.table.
+    def initialize(opts=OPTS)
+      @opts = opts
+      @rows = []
+    end
+
+    # Add a row to the table.
+    def <<(row)
+      @rows << row
+    end
+
+    # Return a string containing the HTML table.
+    def to_s
+      empty = ''.freeze
+      tr = 'tr'.freeze
+      th = 'th'.freeze
+      td = 'td'.freeze
+      nl = "\n".freeze
+      tr_attr = @opts[:tr]
+      th_attr = @opts[:th]
+      td_attr = @opts[:td]
+
+      t = tag('table', empty, @opts[:table])
+      s = t.open
+      s << nl
+
+      if caption = @opts[:caption]
+        s << tag(:caption, caption).to_s
+      end
+
+      if widths = @opts[:widths]
+        s << "<colgroup>\n"
+        widths.each do |w|
+          s << "<col width=\"#{w.to_i}\" />\n"
+        end
+        s << "</colgroup>\n"
+      end
+
+      if headers = @opts[:headers]
+        s << "<thead>\n"
+        headers = headers.split(',') if headers.is_a?(String)
+        trh = tag(tr, empty, handle_proc(tr_attr, headers))
+        s << trh.open
+        s << nl
+        headers.each_with_index do |header, i|
+          s << tag(th, header, handle_proc(th_attr, header)).to_s
+        end
+        s << trh.close
+        s << "</thead>\n"
+      end
+
+      s << "<tbody>\n"
+      @rows.each do |row|
+        trh = tag(tr, empty, handle_proc(tr_attr, row))
+        s << trh.open
+        s << nl
+        row.each_with_index do |col, i|
+          s << tag(td, col, handle_proc(td_attr, col, i, row)).to_s
+        end
+        s << trh.close
+      end
+      s << "</tbody>\n"
+      s << t.close
+    end
+
+    # Create a Tag object from the arguments.
+    def tag(*a)
+      Tag.tag(*a)
+    end
+
+    # Create an a tag with the given text and href.
+    def a(text, href, opts=OPTS)
+      tag('a', text, opts.merge(:href=>href))
+    end
+
+    # Return a Raw string, which won't be HTML escaped.
+    def raw(s)
+      RawString.new(s)
+    end
+
+    private
+
+    # If pr is a Proc or Method, call it with the given arguments,
+    # otherwise return it directly.
+    def handle_proc(pr, *a)
+      case pr
+      when Proc, Method
+        pr.call(*a)
+      else
+        pr
+      end
+    end
+  end
+
+  # Module that can be included into other String subclasses so
+  # that the instances are not HTML escaped
+  module Raw
+  end
+
+  # Simple subclass of string, where instances are not HTML
+  # escaped.
+  class RawString < String
+    include Raw
+  end
+
+  # Tags represent an individual HTML tag.
+  class Tag
+    # The type of the tag
+    attr_reader :type
+
+    # If the given content is already a Tag instance with the
+    # same type, return it directly, otherwise create a new
+    # Tag instance with the given arguments.
+    def self.tag(type, content='', attr=nil)
+      if content.is_a?(Tag) && content.type.to_s == type.to_s 
+        content
+      else
+        new(type, content, attr)
+      end
+    end
+
+    # Create a new instance.  Usually not called
+    # directly, but through Tag.tag. 
+    def initialize(type, content='', attr=nil)
+      @type, @content, @attr = type, content, attr||OPTS
+    end
+
+    # A string for the HTML to use for this tag.
+    def to_s
+      "#{open}#{content}#{close}"
+    end
+
+    # A string for the opening HTML for the tag.
+    def open
+      "<#{@type}#{' ' unless @attr.empty?}#{attr}>"
+    end
+
+    # A string for the inner HTML for the tag.
+    def content
+      h @content
+    end
+
+    # A string for the closing HTML for the tag.
+    def close
+      "</#{@type}>\n"
+    end
+
+    private
+
+    # A string for the html attributes for the tag.
+    def attr
+      @attr.map{|k,v| "#{k}=\"#{h v}\""}.sort.join(' ')
+    end
+    
+    # A HTML-escaped version of the given argument.
+    def h(s)
+      case s
+      when Raw
+        s
+      when Tag
+        s.to_s
+      else
+        Rack::Utils.escape_html(s.to_s)
+      end
+    end
+  end
+end

data/lib/thamble/rails.rb

@@ -0,0 +1,11 @@
+require 'thamble'
+require 'active_support/core_ext/string/output_safety'
+ActiveSupport::SafeBuffer.send(:include, Thamble::Raw)
+
+module Thamble
+  module RailsHelper
+    def thamble(*a, &block)
+      raw Thamble.table(*a, &block)
+    end
+  end
+end

data/spec/thamble_spec.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+require File.join(File.dirname(File.expand_path(__FILE__)), '../lib/thamble')
+
+if defined?(RSpec)
+  require 'rspec/version'
+  if RSpec::Version::STRING >= '2.11.0'
+    RSpec.configure do |config|
+      config.expect_with :rspec do |c|
+        c.syntax = :should
+      end
+    end
+  end
+end
+
+describe "Thamble.table" do
+  def table(*a, &block)
+    Thamble.table(*a, &block).gsub(/\s+\n/m, '').gsub("\n", '')
+  end
+
+  it 'should return string with HTML table for enumerable' do
+    table([[1, 2]]).should == '<table><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should support :headers option for the headers' do
+    table([[1, 2]], :headers=>%w'a b').should == '<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should support :headers option as a string with comma separators' do
+    table([[1, 2]], :headers=>'a,b').should == '<table><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should support :widths option for setting width for each column' do
+    table([[1, 2]], :widths=>[3,4]).should == '<table><colgroup><col width="3" /><col width="4" /></colgroup><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should yield each object in enumerable to block to return data row to use' do
+    table([[1, 2]]){|l, t| l.map{|i| i*2}}.should == '<table><tbody><tr><td>2</td><td>4</td></tr></tbody></table>'
+  end
+
+  it 'should be able to create tags using the table.tag method' do
+    table([[1, 2]]){|l, t| l.map{|i| t.tag(:b, i*2)}}.should == '<table><tbody><tr><td><b>2</b></td><td><b>4</b></td></tr></tbody></table>'
+    table([[1, 2]]){|l, t| l.map{|i| t.tag(:b, i*2, i=>i)}}.should == '<table><tbody><tr><td><b 1="1">2</b></td><td><b 2="2">4</b></td></tr></tbody></table>'
+  end
+
+  it 'should be able to create links using the table.a method' do
+    table([[1, 2]]){|l, t| l.map{|i| t.a(i*2, 'foo')}}.should == '<table><tbody><tr><td><a href="foo">2</a></td><td><a href="foo">4</a></td></tr></tbody></table>'
+    table([[1, 2]]){|l, t| l.map{|i| t.a(i*2, 'foo', i=>i)}}.should == '<table><tbody><tr><td><a 1="1" href="foo">2</a></td><td><a 2="2" href="foo">4</a></td></tr></tbody></table>'
+  end
+
+  it 'should support :table option for the table attribtues' do
+    table([[1, 2]], :table=>{:class=>'foo'}).should == '<table class="foo"><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should support :tr option for the tr attributes' do
+    table([[1, 2]], :tr=>{:class=>'foo'}).should == '<table><tbody><tr class="foo"><td>1</td><td>2</td></tr></tbody></table>'
+    table([[1, 2]], :headers=>%w'a b', :tr=>{:class=>'foo'}).should == '<table><thead><tr class="foo"><th>a</th><th>b</th></tr></thead><tbody><tr class="foo"><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should support :td option for the td attributes' do
+    table([[1, 2]], :td=>{:class=>'foo'}).should == '<table><tbody><tr><td class="foo">1</td><td class="foo">2</td></tr></tbody></table>'
+  end
+
+  it 'should support :th option for the th attributes' do
+    table([[1, 2]], :headers=>%w'a b', :th=>{:class=>'foo'}).should == '<table><thead><tr><th class="foo">a</th><th class="foo">b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should support a proc for the :tr option' do
+    table([[1, 2]], :tr=>proc{|row| {:class=>"foo#{row.join}"}}).should == '<table><tbody><tr class="foo12"><td>1</td><td>2</td></tr></tbody></table>'
+    table([[1, 2]], :headers=>%w'a b', :tr=>proc{|row| {:class=>"foo#{row.join}"}}).should == '<table><thead><tr class="fooab"><th>a</th><th>b</th></tr></thead><tbody><tr class="foo12"><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should support a proc for the :td option' do
+    table([[1, 2]], :td=>proc{|v, i, row| {:class=>"foo#{row.join}-#{v}-#{i}"}}).should == '<table><tbody><tr><td class="foo12-1-0">1</td><td class="foo12-2-1">2</td></tr></tbody></table>'
+  end
+
+  it 'should support a proc for the :th option' do
+    table([[1, 2]], :headers=>%w'a b', :th=>proc{|v| {:class=>"foo#{v}"}}).should == '<table><thead><tr><th class="fooa">a</th><th class="foob">b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should support :caption option for the table caption' do
+    table([[1, 2]], :headers=>%w'a b', :caption=>'Foo').should == '<table><caption>Foo</caption><thead><tr><th>a</th><th>b</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+
+  it 'should be callable as a method if including the module' do
+    Class.new{include Thamble}.new.send(:table, [[1, 2]]).gsub(/\s+\n/m, '').gsub("\n", '').should == '<table><tbody><tr><td>1</td><td>2</td></tr></tbody></table>'
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: thamble
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jeremy Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Thamble exposes a single method, table, for easily creating HTML
+  tables from enumerable objects.
+email: code@jeremyevans.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- CHANGELOG
+- MIT-LICENSE
+files:
+- MIT-LICENSE
+- CHANGELOG
+- README.rdoc
+- Rakefile
+- spec/thamble_spec.rb
+- lib/thamble.rb
+- lib/thamble/rails.rb
+homepage: http://gihub.com/jeremyevans/thamble
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --quiet
+- --line-numbers
+- --inline-source
+- --title
+- 'Thamble: Create HTML Tables from Enumerables'
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Create HTML Tables from Enumerables
+test_files: []