RubyGems - tablinate - Versions diffs - 1.2.3 - Mend

tablinate 1.2.3

Files changed (27) hide show

checksums.yaml +7 -0
data/.gitignore +18 -0
data/Gemfile +6 -0
data/LICENSE.txt +22 -0
data/README.md +171 -0
data/Rakefile +1 -0
data/lib/tablinate.rb +30 -0
data/lib/tablinate/adapters/active_record.rb +12 -0
data/lib/tablinate/adapters/array.rb +5 -0
data/lib/tablinate/railtie.rb +10 -0
data/lib/tablinate/table.rb +19 -0
data/lib/tablinate/table/tbody.rb +28 -0
data/lib/tablinate/table/thead.rb +18 -0
data/lib/tablinate/tag.rb +61 -0
data/lib/tablinate/version.rb +3 -0
data/spec/spec_functions.rb +26 -0
data/spec/spec_helper.rb +9 -0
data/spec/table/tbody_spec.rb +48 -0
data/spec/table/thead_spec.rb +49 -0
data/spec/table_spec.rb +11 -0
data/spec/tablinate/active_record_spec.rb +17 -0
data/spec/tablinate/array_spec.rb +24 -0
data/spec/tablinate_spec.rb +67 -0
data/spec/tag_spec.rb +59 -0
data/tablinate.gemspec +21 -0
data/views/index.haml +2 -0
metadata +97 -0

checksums.yaml ADDED

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a09c49e4cb9191e805d0bd10005bc72bbb7332e5
+  data.tar.gz: a7b0ff95339764772d95252f9f7288cae2f8a522
+SHA512:
+  metadata.gz: c9e1df452921b1a6d3d0b8b0d9eaf70dfe2558a9a5b6ee33bbb1241096b32120ec3a45e9d75795fc2907617828220581809eb2992c209d49a149dba69fc13de8
+  data.tar.gz: 74b550e824bb56a226e59a62012ab175983db2798d51a6656978a42d2ccf741729850b0546d1aead05affd0404b604aa20a5caa4b7740e444ef167321cc2699d

data/.gitignore ADDED

@@ -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
+.rspec

data/Gemfile ADDED

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in tablinate.gemspec
+gem 'bundler', '~> 1.3'
+gem 'rake'
+gemspec

data/LICENSE.txt ADDED

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kevin Collette and Isabelle Carter
+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 ADDED

@@ -0,0 +1,171 @@
+# Tablinate
+## Author(s)
+* [Isabelle Carter](http://github.com/ibnc)
+* [Kevin Collette](http://github.com/collettiquette)
+## Note
+This project is dead. It was something I made years ago with friends when we were still not great programmers. It was never a good idea, but it was fun to write none the less. This is still up because I see no reason to take it down, and I occasionally use this repo as a test repo on other projects.
+## Description
+Tablinate is a ruby gem that takes arrays of hashes, ActiveRecord::Relation objects, or a JSON array of hashes, and converts them into html tables. It is intended for use in small projects or applications whose schemas are closely related to standard table formats.
+## Install
+    gem install tablinate
+## Sample Sinatra Code:
+### 1) app.rb
+    require 'sinatra'
+    require 'tablinate'
+    get '/' do
+      @employees = [
+        { :id => '1', :first_name => "Matt", :last_name => "Smith", :title => "Time Lord" },
+        { :id => '2', :first_name => "Jack", :last_name => "Harkness", :title => "Time Agent" },
+        { :id => '3', :first_name => "Tom", :last_name => "Baker", :title => "Time Lord" },
+        { :id => '4', :first_name => "David", :last_name => "Tennant", :title => "Time Lord" },
+        { :id => '5', :first_name => "Christopher", :last_name => "Eccleston", :title => "Time Lord" }
+      ]
+      haml :index
+    end
+### 2) views/index.haml
+    %body
+      = @employees.tablinate()
+### 3) view-source:http://localhost:4567/
+    <body>
+      <table>
+      <thead>
+      <tr>
+        <th>id</th>
+        <th>first_name</th>
+        <th>last_name</th>
+        <th>title</th>
+      </thead>
+      <tbody>
+      <tr>
+        <td>1</td>
+        <td>Matt</td>
+        <td>Smith</td>
+        <td>Time Lord</td>
+      </tr>
+      <tr>
+        <td>2</td>
+        <td>Jack</td>
+        <td>Harkness</td>
+        <td>Time Agent</td>
+      </tr>
+      <tr>
+        <td>3</td>
+        <td>Tom</td>
+        <td>Baker</td>
+        <td>Time Lord</td>
+      </tr>
+      <tr>
+        <td>4</td>
+        <td>David</td>
+        <td>Tennant</td>
+        <td>Time Lord</td>
+      </tr>
+      <tr>
+        <td>5</td>
+        <td>Christopher</td>
+        <td>Eccleston</td>
+        <td>Time Lord</td>
+      </tr>
+      </tbody>
+      </table>
+    </body>
+## Options
+Because it uses normal html markup, tablinated tables are easily styled using CSS, Sass, etc. That being said, tablinate is configurable via an options hash. The hash can style the table or add classes to it. For example:
+### views/index.haml
+    %body
+      =@employees.tablinate( { :table => { :border => 1, :class => 'fluid' }, :tbody => { :class => 'foo' } } )
+### view-source:http://localhost:4567/
+    <body>
+      <table border='1' class='fluid'>
+      <thead>
+      <tr>
+        <th>id</th>
+        <th>first_name</th>
+        <th>last_name</th>
+        <th>title</th>
+      </thead>
+      <tbody class='foo'>
+      <tr>
+        <td>1</td>
+        <td>Matt</td>
+        ...
+        ...
+### Further notes on options
+Options are highly expandable, and support many useful notations. For example:
+    @table_params = {
+      :table => { :class => "table" },
+      :tbody => {
+        :tr => { :class => [ 'class1', 'class2', 'class3' ], :id => 'meow' },
+        :td => { :class => 'row', :id => [1,2,3] }
+      }
+    }
+    @table = [
+      { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+      { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+      { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+      { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' }
+    ]
+    @table.tablinate(@table_params)
+    <table class='table'>
+    <thead>
+      <tr>
+        <th>column1</th>
+        <th>column2</th>
+        <th>column3</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr class='class1' id='meow'>
+        <td class='row' id='1'>value1</td>
+        <td class='row' id='2'>value2</td>
+        <td class='row' id='3'>value3</td>
+      </tr>
+        <tr class='class2' id='meow'>
+        <td class='row' id='1'>value1</td>
+        <td class='row' id='2'>value2</td>
+        <td class='row' id='3'>value3</td>
+      </tr>
+      <tr class='class3' id='meow'>
+        <td class='row' id='1'>value1</td>
+        <td class='row' id='2'>value2</td>
+        <td class='row' id='3'>value3</td>
+      </tr>
+      <tr class='class1' id='meow'>
+        <td class='row' id='1'>value1</td>
+        <td class='row' id='2'>value2</td>
+        <td class='row' id='3'>value3</td>
+      </tr>
+    </tbody>
+    </table>
+### Haml note
+When using haml, you may need to unescape html tags by:
+    %body
+      != [ { ... }, ... ].tablinate(...)

data/Rakefile ADDED

	@@ -0,0 +1 @@
1	+ require "bundler/gem_tasks"

data/lib/tablinate.rb ADDED

@@ -0,0 +1,30 @@
+require 'json'
+require 'tablinate/tag'
+require 'tablinate/table/thead'
+require 'tablinate/table/tbody'
+require 'tablinate/table'
+require 'tablinate/adapters/array'
+## Thoughts:
+# Support column summing?
+# TODO: Support hidden columns?
+module Tablinate
+  #turns an ActiveRecord::Relation into an array of hashes.
+  def self.generate_table(objects, params={})
+    Table.new(self.parse_objects(objects), params)
+  end
+  private
+    def self.parse_objects(objects)
+      if objects.class == String then
+        return JSON.parse(objects)
+      elsif objects.class.to_s == "ActiveRecord::Relation"
+          return objects.collect{ |x| x.attributes }
+      else
+        return objects
+      end
+    end
+end
+if defined?(Rails::Railtie)
+  require 'tablinate/railtie'
+end

data/lib/tablinate/adapters/active_record.rb ADDED

@@ -0,0 +1,12 @@
+module Tablinate
+  module ActiveRecord
+    module Tablination
+      def tablinate(params={})
+        rel = to_a()
+        Tablinate.generate_table(rel, params)
+      end
+    end
+    ::ActiveRecord::Relation.extend Tablination
+  end
+end

data/lib/tablinate/adapters/array.rb ADDED

@@ -0,0 +1,5 @@
+class Array
+  def tablinate(params={})
+    Tablinate.generate_table(self, params)
+  end
+end

data/lib/tablinate/railtie.rb ADDED

@@ -0,0 +1,10 @@
+module Tablinate
+  class Railtie < Rails::Railtie
+    initializer "tablinate" do |app|
+      ActiveSupport.on_load :active_record do
+        require 'tablinate/active_record'
+      end
+    end
+  end
+end

data/lib/tablinate/table.rb ADDED

@@ -0,0 +1,19 @@
+class Table < Tag
+  include Thead
+  include Tbody
+  def initialize(values, params={})
+    thead = build_head(values[0].keys, thead_params(params))
+    tbody = build_body(values, tbody_params(params))
+    super("table", "", params, [thead, tbody])
+  end
+  private
+    def thead_params params
+      params ? params.delete(:thead) : {}
+    end
+    def tbody_params params
+      params ? params.delete(:tbody) : {}
+    end
+end

data/lib/tablinate/table/tbody.rb ADDED

@@ -0,0 +1,28 @@
+module Tbody
+  def build_body(values, params={})
+    tr_params = params ? params.delete(:tr) : {}
+    tbody = Tag.new("tbody", "", params)
+    tbody.children.concat build_body_rows(values, tr_params)
+    return tbody
+  end
+  def build_body_rows(rows, params={})
+    td_params = params ? params.delete(:td) : {}
+    trs = []
+    rows.each do |row|
+      tr = Tag.new("tr", "", params)
+      tr.children.concat build_row_entries(row, td_params)
+      trs << tr
+    end
+    trs
+  end
+  def build_row_entries(row, params={})
+    tds = []
+    row.each do |key, value|
+      td = Tag.new("td", value, params)
+      tds << td
+    end
+    return tds
+  end
+end

data/lib/tablinate/table/thead.rb ADDED

@@ -0,0 +1,18 @@
+module Thead
+  def build_head(columns, params={})
+    tr_params = params ? params.delete(:tr) : {}
+    thead = Tag.new("thead", "", params)
+    thead.children << build_head_rows(columns, tr_params)
+    thead
+  end
+  def build_head_rows(columns, params={})
+    th_params = params ? params.delete(:th) : {}
+    tr = Tag.new("tr", "", params)
+    columns.each do |column|
+      th = Tag.new("th", column, th_params)
+      tr.children << th
+    end
+    tr
+  end
+end

data/lib/tablinate/tag.rb ADDED

@@ -0,0 +1,61 @@
+class Tag
+  attr_reader :name
+  attr_accessor :children, :text, :attributes
+  def initialize(name, text="", attributes={}, children=[])
+    @name = name.to_sym
+    @attributes = attributes || {}
+    @children = children || []
+    @text = text.to_s
+  end
+  def to_s(offset=0)
+    build_open_tag(offset) + text + add_sub_tags + build_close_tag
+  end
+  def to_html
+    format_html(to_s)
+  end
+  private
+    def build_close_tag
+      "</#{name}>"
+    end
+    def add_sub_tags
+      children.map.with_index {|tag, i| tag.to_s(i) }.join("")
+    end
+    def build_open_tag offset
+      attributes = attributes_to_html(offset)
+      "<#{name}#{attributes.empty? ? '' : ' '}" + attributes + ">"
+    end
+    def attributes_to_html(offset)
+      attributes.map do |key,value|
+        case value
+        when String
+          "#{key}='#{value}'"
+        when Symbol
+          "#{key}='#{value}'"
+        when Array
+          "#{key}='#{value[offset % value.count]}'"
+        end
+      end.join(" ")
+    end
+    def format_html(html)
+      #Finds html tags via regex and adds whitespace so
+      #that the table doesn't look disgusting in the
+      #source code.
+      tags = html.scan(%r{</?[^>]+?>}).uniq
+      tags.each do |tag|
+        if tag.length > 5 || tag.include?("/") || tag.include?("tr>") then
+          html.gsub!(tag,"#{tag}\n")
+        else
+          html.gsub!(tag,"\s\s#{tag}")
+        end
+      end
+      return html
+    end
+end

data/lib/tablinate/version.rb ADDED

@@ -0,0 +1,3 @@
+module Tablinate
+  VERSION = "1.2.3"
+end

data/spec/spec_functions.rb ADDED

@@ -0,0 +1,26 @@
+def objects
+  [
+    { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+    { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+    { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+    { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' }
+  ]
+end
+def params
+   {
+    :class => "eek", :id => 'rawr',
+    :thead => {
+      :class => "head",
+      :id => 2,
+      :th => { :class => "1",
+        :tr => { :class => "class1", :id => [1,2] }
+      }
+    },
+    :tbody => {
+      :tr => { :class => [ 'class1', 'class2', 'class3' ], :id => 'id-2',
+        :td => { :class => 'rawr', :id => [1,2,3], :foo => :bar }
+      }
+    }
+  }
+end

data/spec/spec_helper.rb ADDED

@@ -0,0 +1,9 @@
+require 'rspec'
+require 'nokogiri'
+require File.dirname(__FILE__)+'/../lib/tablinate.rb'
+require 'spec_functions'
+module ActiveRecord
+  class Relation
+  end
+end

data/spec/table/tbody_spec.rb ADDED

@@ -0,0 +1,48 @@
+require 'spec_helper'
+class DummyClass
+  extend Tbody
+end
+describe "table", Tbody do
+  subject { DummyClass }
+  context "given params" do
+    #TODO rewrite this test it sucks, but it ensures we keep building it right.
+    it "should construct the table body" do
+      body = subject.build_body(objects, params[:tbody])
+      body.to_s.should eq(
+        "<tbody><tr class='class1' id='id-2'><td class='rawr' id='1' foo='bar'>value1</td><td class='rawr' id='2' foo='bar'>value2</td><td class='rawr' id='3' foo='bar'>value3</td></tr><tr class='class2' id='id-2'><td class='rawr' id='1' foo='bar'>value1</td><td class='rawr' id='2' foo='bar'>value2</td><td class='rawr' id='3' foo='bar'>value3</td></tr><tr class='class3' id='id-2'><td class='rawr' id='1' foo='bar'>value1</td><td class='rawr' id='2' foo='bar'>value2</td><td class='rawr' id='3' foo='bar'>value3</td></tr><tr class='class1' id='id-2'><td class='rawr' id='1' foo='bar'>value1</td><td class='rawr' id='2' foo='bar'>value2</td><td class='rawr' id='3' foo='bar'>value3</td></tr></tbody>")
+    end
+    it "should construct the table rows" do
+      rows = subject.build_body_rows(objects, params[:tbody])
+      rows.class.should == Array
+      rows.each { |row| row.class.should == Tag }
+    end
+    it "shoulid construct the entries for a row" do
+      entries = subject.build_row_entries(objects[0], params[:tbody])
+      entries.class.should == Array
+      entries.each { |entry| entry.class.should == Tag }
+    end
+  end
+  context "without params" do
+    it "should construct the table body" do
+      subject.build_body(objects).class.should == Tag
+    end
+    it "should construct the table rows" do
+      rows = subject.build_body_rows(objects)
+      rows.class.should == Array
+      rows.each { |row| row.class.should == Tag }
+    end
+    it "shoulid construct the entries for a row" do
+      entries = subject.build_row_entries(objects[0])
+      entries.class.should == Array
+      entries.each { |entry| entry.class.should == Tag }
+    end
+  end
+end

data/spec/table/thead_spec.rb ADDED

@@ -0,0 +1,49 @@
+require 'spec_helper'
+class DummyClass
+  extend Thead
+end
+describe "table", Thead do
+  subject { DummyClass }
+  context "given params" do
+    it "should construct the table head" do
+      thead = subject.build_head(objects[0].keys, params)
+      thead.class.should == Tag
+      thead.to_html.scan(/<([a-zA-Z]+) ([a-zA-Z]+=\'.*?\'+)>/).each do |tag|
+        name = tag[0]
+        next if name == "thead"
+        params[:thead][name.to_sym].each do |param, value|
+          if value.class == Array then
+            value.map do |v|
+              tag[1].include?("#{param.to_s}=\'#{v}\'")
+            end.include?(true).should be_true
+          else
+            tag[1].include?("#{param.to_s}=\'#{value}\'").should == true
+          end
+        end
+      end
+    end
+    it "should construct the table head rows" do
+      head_rows = subject.build_head_rows(objects[0], params[:thead])
+      head_rows.class.should == Tag
+      head_rows.name.should == :tr
+    end
+  end
+  context "without params" do
+    it "should construct the table head" do
+      head = subject.build_head(objects[0])
+      head.class.should == Tag
+      head.name.should == :thead
+    end
+    it "should construct the table head rows" do
+      head_rows = subject.build_head_rows(objects[0])
+      head_rows.class.should == Tag
+      head_rows.name.should == :tr
+    end
+  end
+end

data/spec/table_spec.rb ADDED

@@ -0,0 +1,11 @@
+require 'spec_helper'
+describe "An instance of", Table do
+  let(:values) { [{foo: "bar", bar: "baz"}] }
+  subject { Table.new(values, {thead: {tr: {th: {bar: ["t4", "t5"]}}},tbody: {tr: {td: { foo: ["t1", "t2"]}}}}) }
+  it "should build the table with children elements" do
+    subject.to_s.should eq "<table><thead><tr><th bar='t4'>foo</th><th bar='t5'>bar</th></tr></thead><tbody><tr><td foo='t1'>bar</td><td foo='t2'>baz</td></tr></tbody></table>"
+  end
+end

data/spec/tablinate/active_record_spec.rb ADDED

@@ -0,0 +1,17 @@
+require 'rails/railtie'
+require 'active_record'
+require 'spec_helper'
+require File.dirname(__FILE__)+"/../../lib/tablinate/adapters/active_record"
+describe "An instance of", ActiveRecord::Relation do
+  #subject { need to stub out ActiveRecord::Relation somehow }
+  describe "#tablinate" do
+    before do
+      subject.should_receive(:to_a)
+      Tablinate.should_receive(:generate_table)
+    end
+    it "should call tablinate and pass itself" do
+      subject.tablinate
+    end
+  end
+end

data/spec/tablinate/array_spec.rb ADDED

@@ -0,0 +1,24 @@
+require 'spec_helper'
+describe "An instance of", Array do
+  subject do
+    [
+      { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+      { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+      { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' },
+      { :column1 => 'value1', :column2 => 'value2', :column3 => 'value3' }
+    ]
+  end
+  describe "#tablinate" do
+    before do
+      Tablinate.should_receive(:generate_table)  do |objects, params|
+        objects.should == subject
+      end
+    end
+    it "should call generate_table and pass itself and pass the params" do
+      subject.tablinate
+    end
+  end
+end

data/spec/tablinate_spec.rb ADDED

@@ -0,0 +1,67 @@
+require 'spec_helper'
+describe Tablinate do
+  subject { Tablinate }
+  context "given an array of hashes" do
+    context "and a params hash" do
+      it "should genderate an html table" do
+        table =  subject.generate_table(objects, params)
+        #using nokogiri to ensure the markup is correct
+        doc = Nokogiri::XML(table.to_s)
+        doc.errors.should == []
+      end
+    end
+    context "and no a params hash" do
+      it "should generate an html table" do
+        table = subject.generate_table(objects)
+        doc = Nokogiri::XML(table.to_s)
+        doc.errors.should == []
+      end
+    end
+  end
+  context "given an ActiveRecord::Relation" do
+    let(:ar_objects) { ActiveRecord::Relation.new }
+    before do
+      ActiveRecord::Relation.any_instance.stub(:collect) { objects }
+    end
+    context "and a params hash" do
+      it "should genderate an html table" do
+        table = subject.generate_table(ar_objects, params)
+        #using nokogiri to ensure the markup is correct
+        doc = Nokogiri::XML(table.to_s)
+        doc.errors.should == []
+      end
+    end
+    context "and no a params hash" do
+      it "should generate an html table" do
+        table = subject.generate_table(ar_objects)
+        doc = Nokogiri::XML(table.to_s)
+        doc.errors.should == []
+      end
+    end
+  end
+  context "given a JSON hash" do
+    context "and a params hash" do
+      it "should generate an html table" do
+        table = subject.generate_table(objects.to_json, params)
+        doc = Nokogiri::XML(table.to_s)
+        doc.errors.should == []
+      end
+    end
+    context "and no params" do
+      it "should generate an html table" do
+        table = subject.generate_table(objects.to_json)
+        doc = Nokogiri::XML(table.to_s)
+        doc.errors.should == []
+      end
+    end
+  end
+end

data/spec/tag_spec.rb ADDED

@@ -0,0 +1,59 @@
+require 'spec_helper'
+describe Tag do
+  subject{ Tag.new("table") }
+  describe ".new" do
+    it "should assign all instance variables" do
+      subject.instance_variable_get(:@name).should eq :table
+      subject.instance_variable_get(:@attributes).should eq Hash.new
+      subject.instance_variable_get(:@children).should eq Array.new
+      subject.instance_variable_get(:@text).should eq ""
+    end
+  end
+  describe ".to_s" do
+    it "should return tag and sub tags as string" do
+      subject.children << Tag.new("thead")
+      subject.to_s.should eq "<table><thead></thead></table>"
+    end
+    it "should insert text in between open and close tags." do
+      subject.text = "testing"
+      subject.to_s.should eq "<table>testing</table>"
+    end
+    context "when an attribute's value is a string" do
+      it "should insert attributes in opening tag" do
+        subject.attributes = { foo: "bar" }
+        subject.to_s.should eq "<table foo='bar'></table>"
+      end
+    end
+    context "when an attribute's value is an array" do
+      subject { Tag.new("tr") }
+      let(:attributes) { { foo: ["bar", "barz"] } }
+      it "should iteratively assign the corresponding value" do
+        tbody = Tag.new("tbody")
+        attributes[:foo].length.times do
+          tr = subject
+          tr.attributes = attributes
+          tbody.children << tr
+        end
+        attributes[:foo].each do |value|
+          tbody.to_s.include?("<tr foo='#{value}'>").should be_true
+        end
+      end
+    end
+  end
+  describe ".html" do
+    it "should return tag and sub tags as formatted string" do
+      subject.children << Tag.new("thead")
+      subject.to_html.should eq "<table>\n<thead>\n</thead>\n</table>\n"
+    end
+  end
+end

data/tablinate.gemspec ADDED

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tablinate/version'
+Gem::Specification.new do |spec|
+  spec.name          = 'tablinate'
+  spec.date          = '2016-12-02'
+  spec.version       = Tablinate::VERSION
+  spec.summary       = "Generate html tables with activerecord objects!"
+  spec.description   = "Tablinate is a ruby gem that takes arrays of hashes, ActiveRecord::Relation objects, or a JSON array of hashes, and converts them into html tables. It is intended for use in small projects or applications whose schemas are closely related to what a table's output should be."
+  spec.authors       = [ "Isabelle Carter", "Kevin Collette" ]
+  spec.email         = [ 'isabellenataliecarter@gmail.com', 'kevcollette@gmail.com' ]
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.homepage      = 'http://rubygems.org/gems/tablinate'
+  spec.add_dependency('json')
+  spec.license       = "MIT"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/views/index.haml ADDED

	@@ -0,0 +1,2 @@
1	+ %body
2	+ = @employees.tablinate({border: "1", thead: {class: ["test", "test2"], tr: {class: "testing", th: { class: "testing again"}}}, tbody: {class: "thing", tr: {class: "thingy it", td: {class: "hello"}}}})

metadata ADDED

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: tablinate
+version: !ruby/object:Gem::Version
+  version: 1.2.3
+platform: ruby
+authors:
+- Isabelle Carter
+- Kevin Collette
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  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: Tablinate is a ruby gem that takes arrays of hashes, ActiveRecord::Relation
+  objects, or a JSON array of hashes, and converts them into html tables. It is intended
+  for use in small projects or applications whose schemas are closely related to what
+  a table's output should be.
+email:
+- isabellenataliecarter@gmail.com
+- kevcollette@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tablinate.rb
+- lib/tablinate/adapters/active_record.rb
+- lib/tablinate/adapters/array.rb
+- lib/tablinate/railtie.rb
+- lib/tablinate/table.rb
+- lib/tablinate/table/tbody.rb
+- lib/tablinate/table/thead.rb
+- lib/tablinate/tag.rb
+- lib/tablinate/version.rb
+- spec/spec_functions.rb
+- spec/spec_helper.rb
+- spec/table/tbody_spec.rb
+- spec/table/thead_spec.rb
+- spec/table_spec.rb
+- spec/tablinate/active_record_spec.rb
+- spec/tablinate/array_spec.rb
+- spec/tablinate_spec.rb
+- spec/tag_spec.rb
+- tablinate.gemspec
+- views/index.haml
+homepage: http://rubygems.org/gems/tablinate
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+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.5.1
+signing_key:
+specification_version: 4
+summary: Generate html tables with activerecord objects!
+test_files:
+- spec/spec_functions.rb
+- spec/spec_helper.rb
+- spec/table/tbody_spec.rb
+- spec/table/thead_spec.rb
+- spec/table_spec.rb
+- spec/tablinate/active_record_spec.rb
+- spec/tablinate/array_spec.rb
+- spec/tablinate_spec.rb
+- spec/tag_spec.rb