tabl 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gem 'activesupport'
+gem 'fastercsv'
+
+group :development do
+  gem "rspec", "~> 2.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+
+  gem 'libnotify'
+  gem 'guard-rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,40 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.10)
+    diff-lcs (1.1.3)
+    fastercsv (1.5.4)
+    ffi (1.0.9)
+    git (1.2.5)
+    guard (0.6.3)
+      thor (~> 0.14.6)
+    guard-rspec (0.4.5)
+      guard (>= 0.4.0)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    libnotify (0.5.7)
+      ffi (= 1.0.9)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler (~> 1.0.0)
+  fastercsv
+  guard-rspec
+  jeweler (~> 1.6.4)
+  libnotify
+  rspec (~> 2.6.0)

data/Guardfile

@@ -0,0 +1,21 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  # watch(%r{^spec/.+_spec\\.rb$})
+  # watch(%r{^app/(.+)\\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^lib/(.+)\\.rb$})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
+  # watch(%r{^app/controllers/(.+)_(controller)\\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  # watch(%r{^spec/support/(.+)\\.rb$})                  { "spec" }
+  # watch('spec/spec_helper.rb')                        { "spec" }
+  # watch('config/routes.rb')                           { "spec/routing" }
+  # watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # # Capybara request specs
+  # watch(%r{^app/views/(.+)/.*\\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Liehann Loots
+
+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,150 @@
+# Tabl - Creating Tables and Reports the Easy Way
+
+## Table Definitions
+
+Create a table definition:
+    class UserTables
+      table :table do |config|
+        config.columns = [
+          :name,
+          :email,
+          :phone_number
+        ]
+      end
+    end
+
+By default this creates a table with the columns specified. The column labels are the symbols titleized. Eg:
+* Name
+* Email
+* Phone Number
+
+The values will evaluate to calling column method on the record:
+* `user.name`
+* `user.email`
+* `user.phone_number`
+
+Both of these can be overridden:
+    class UserTables
+      table :table do |config|
+        config.columns = [
+          :name,
+          :email,
+          :phone_number
+        ]
+
+        config.labels[:name] = 'Full Name'
+
+        config.values[:name] = lambda { |user| user.name.upcase }
+      end
+    end
+
+
+## Outputting
+
+Tabl outputs to CSV:
+    users = Users.all
+    UserTables.table.to_csv(users)
+
+Currently html output needs to be done manually:
+    %table
+      %thead
+        %tr
+          - UserTables.table.labels.each do |label|
+            %th&= label
+      %tbody
+        - users.each do |user|
+          %tr
+            - UserTables.table.values.each do |value|
+              %td&= value
+
+## Default Value
+
+A default value can be used if values are null. For example it may be preferable to display a dash instead of an empty column.
+    fmt = UserTables.table.format do |config|
+      config.default_value = '-'
+    end
+
+
+## Formatting
+
+Different formats can be defined for the same table definition. This allows the values to be computed differently. For example for html by default values should be escaped.
+    fmt = UserTables.table.format do |config|
+      config.default_format = lambda { |v| h(v) }
+    end
+
+This can be overridden per column, allowing some columns to be formatted as links.
+    fmt = UserTables.table.format do |config|
+      # The second parameter is optional.
+      config.format[:name] = lambda { |name, line| link_to v, line }
+    end
+
+## Shared Definitions
+
+Sometimes definitions are common over several tables. In this case a definition can be configured in a module and included into table definitions.
+    module UserColumns
+      # Specify what part of the record is required. This is typically an association.
+      record :user
+
+      # Columns can be configured using a hash.
+      column :name, :label => 'User', :value => lambda {|v| user.name.upcase}
+
+      # Or using a block.
+      column :name do |config|
+        config.label = 'User'
+        config.value = lambda { |user| user.name.upcase }
+        config.format.html = lambda { |name, user| link_to name, user }
+      end
+    end
+
+This shared definition can then be used in other tables. The shared definition is only invoked if the record returns a non-nil object. If the record is not defined the base object is assumed to be the record.
+    module JobTables
+      include UserColumns
+
+      table :jobs_report do |config|
+        config.records[:user] = lambda { |job| job.user }
+      end
+    end
+    
+    module UserTables
+      table :users_report do |config|
+        # Implicitly equivalent to:
+        # config.records[:user] => lambda { |user| user }
+      end
+    end
+
+## More Formatting
+
+Default format objects can be created. HTML is a default built in format.
+    module UserTables
+      table :user_report do |config|
+        config.format(:html) do |format|
+          format.format[:name] = lambda { |name, line| link_to v, line }
+        end
+      end
+    end
+
+This format can be accessed from the table.
+    fmt = UserTables.user_report.format(:html)
+
+To define formatting on shared definitions:
+    module UserColumns
+      column :name do |config|
+        config.format[:html] = lambda { |name, line| link_to v, line }
+      end
+    end
+
+To create a custom built in format:
+    class HtmlFormatter
+      Tabl::Formatters.register(:html, HtmlFormatter)
+
+      def default_value
+        '-'
+      end
+
+      def default_format(value)
+        h(value)
+      end
+    end
+    
+    UserTables.user_report.html.formatted_values(user)
+

data/Rakefile

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "tabl"
+  gem.homepage = "http://github.com/liehann/tabl"
+  gem.license = "MIT"
+  gem.summary = %Q{Gem for creating tables in Rails or any other system.}
+  gem.description = %Q{Gem for creating tables in Rails or any other system.}
+  gem.email = "liehannl@gmail.com"
+  gem.authors = ["Liehann Loots"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/tabl/column.rb

@@ -0,0 +1,63 @@
+module Tabl
+  class Column
+    attr_reader :name
+    attr_accessor :label
+    attr_writer :value
+
+    def initialize(name, args = {})
+      @name = name
+      @label = args[:label] || @name.to_s.titleize
+      @value = args[:value] || lambda { |record| record.send(@name) }
+      @formats = Formats.new
+      yield self if block_given?
+    end
+
+    def value(record)
+      @value.call(record)
+    end
+
+    def format(name = nil)
+      @formats
+    end
+
+    class Formats
+      def initialize
+        @formats = {}
+      end
+
+      def [](name)
+        @formats[name]
+      end
+
+      def method_missing(name, *args)
+        name = name.to_s
+        assign = (name =~ /=$/)
+        key = name.gsub(/=$/, '').to_sym
+
+        # super unless Tabl.formats.include?(key)
+
+        if (assign)
+          write(key, *args)
+        else
+          read(key, *args)
+        end
+      end
+
+      def write(key, proc)
+        @formats[key] = proc
+      end
+
+      def read(key, value = nil, record = nil)
+        format = @formats[key]
+        return format unless value
+        if (format.arity == 1)
+          return format.call(value)
+        else
+          return format.call(value, record)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/tabl/definition.rb

@@ -0,0 +1,56 @@
+module Tabl
+  class Definition
+    attr_reader :columns
+    attr_reader :labels
+    attr_reader :values
+
+    attr_reader :format
+    attr_accessor :default_format
+    attr_accessor :default_value
+
+    def initialize(values_override = nil, &block)
+      @columns = []
+      @labels = {}
+      @values = {}
+      @format = {}
+      @values_override = values_override
+      @default_format = lambda { |v| v }
+      @default_value = nil
+      configure(&block)
+      format = Hash.new { Format.new }
+    end
+
+    def configure(&block)
+      yield(self) if block_given?
+    end
+
+    def columns=(columns)
+      @columns = columns.clone
+      @columns.each do |key|
+        @values[key] ||= default_value_proc(key)
+        @labels[key] ||= key.to_s.titleize
+      end
+    end
+
+    def clone
+      other = super
+      other.instance_variable_set(:@columns, @columns.clone)
+      other.instance_variable_set(:@labels, @labels.clone)
+      other.instance_variable_set(:@values, @values.clone)
+      other.instance_variable_set(:@format, @format.clone)
+      other
+    end
+
+    private
+
+    def default_value_proc(key)
+      if @values_override && @values_override.respond_to?(key)
+        @values_override.method(key)
+      else
+        lambda { |row| row.send(key) }
+      end
+    end
+
+  end
+end
+

data/lib/tabl/deref_column.rb

@@ -0,0 +1,29 @@
+module Tabl
+  class DerefColumn
+    attr_reader :column
+
+    def initialize(column, deref)
+      @column = column
+      @callback = deref
+      @callback = lambda { |record| record.send(deref) } if Symbol === deref
+    end
+
+    def value(record)
+      super(deref(record))
+    end
+
+    def deref(record)
+      @callback.call(record)
+    end
+
+    def method_missing(name, *args)
+      @column.send(name, *args)
+    end
+
+    def clone
+      DerefColumn.new(@column.clone, @callback.clone)
+    end
+  end
+end
+
+

data/lib/tabl/dsl.rb

@@ -0,0 +1,64 @@
+module Tabl
+  module Dsl
+    def Dsl.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    # Defines a dsl to create tables.
+    module ClassMethods
+
+      def column(name, args = {}, &block)
+        columns_hash[name] = column = Column.new(name, args, &block)
+        self.send(:define_method, name) { return column }
+        singleton_class.send(:define_method, name) { return column }
+      end
+
+      def columns
+        columns_hash.values
+      end
+
+      # Define a new table.
+      #   module UserTables
+      #     include Tabl::Dsl
+      #     
+      #     table :users, [:name, :email, :phone]
+      #   end
+      #   
+      #   MyTables.foo
+      #     # => <Table name:foo>
+      def table(name, args = {}, &block)
+        args[:base_columns] ||= columns
+        table = Table.new(args, &block)
+        tables << table
+        singleton_class.send(:define_method, name) { return table }
+      end
+
+      def tables
+        @tables ||= []
+      end
+
+      # Includes column definitions. These column definitions will be available
+      # to any tables defined in the module.
+      #
+      #   module UserTables
+      #     include Tabl::Dsl
+      #     
+      #     include_columns(UserColumns)
+      #   end
+      def include_columns(mod, args = {})
+        mod.columns.each do |column|
+          column = args[:record] ? DerefColumn.new(column, args[:record]) : column
+          columns_hash[column.name] = column
+        end
+      end
+
+      private
+
+      def columns_hash
+        @columns_hash ||= {}
+      end
+
+    end
+  end
+end
+

data/lib/tabl/formats/html.rb

@@ -0,0 +1,17 @@
+module Tabl
+  module Formats
+    module Html
+      Formats.register(:html, Html)
+
+      def self.default_value
+        '-'
+      end
+
+      def self.format(value)
+        ERB::Util.h(value)
+      end
+
+    end
+  end
+end
+

data/lib/tabl/formats.rb

@@ -0,0 +1,22 @@
+module Tabl
+  module Formats
+    @@formats = {}
+
+    def self.register(key, mod)
+      @@formats[key] = mod
+    end
+
+    def self.exist?(key)
+      @@formats.exist?(key)
+    end
+
+    def self.method_missing(key, *args)
+      @@formats[key] || super
+    end
+
+    def self.[](key)
+      @@formats[key]
+    end
+  end
+end
+

data/lib/tabl/table.rb

@@ -0,0 +1,109 @@
+module Tabl
+  class Table
+    attr_reader :keys
+    attr_reader :columns
+
+    def initialize(args = {})
+      @base_columns = {}
+      add_base_columns(args[:base_columns] || {})
+      @formats = {}
+      @columns = {}
+      self.columns=(args[:columns] || [])
+      yield self if block_given?
+    end
+
+    def add_base_columns(columns)
+      columns.each do |column|
+        @base_columns[column.name] = column
+      end
+    end
+
+    def columns
+      @columns_cache ||= @keys.map { |key| column(key) }
+    end
+
+    def base_columns
+      @base_columns.values
+    end
+
+    def columns=(keys)
+      @keys = keys
+      @columns_cache = nil
+      @keys.each do |key|
+        @columns[key] ||= Column.new(key) unless @base_columns.include?(key)
+      end
+    end
+
+    def labels
+      @keys.map { |key| column(key).label }
+    end
+
+    def values(record)
+      @keys.map { |key| value(key, record) }
+    end
+
+    def value(key, record)
+      column(key).value(record)
+    end
+
+    def column(key)
+      @columns[key] || @base_columns[key]
+    end
+
+    def method_missing(name, *args)
+      # Check columns first, creating an override if one doesn't exist already.
+      column = @columns[name] || (@base_columns.include?(name) && @columns[name] = @base_columns[name].clone)
+      if column
+        yield column if block_given?
+        return column
+      end
+
+      # Check formats next
+      format = @formats[name]
+      return format if format
+
+      # Create a new format object
+      format_base = Formats.send(name) || super
+      @formats[name] = Format.new(name, self, format_base)
+    end
+
+    def to_csv(records)
+      FasterCSV.generate do |csv|
+        csv << labels
+        records.each do |record|
+          csv << values(record)
+        end
+      end
+    end
+
+    class Format
+      def initialize(name, table, base)
+        @name = name
+        @table = table
+        @base = base
+      end
+
+      def values(record)
+        @table.keys.map do |key|
+          value = @table.value(key, record)
+          if value
+            format(key, value, record)
+          else
+            @base.default_value unless value
+          end
+        end
+      end
+
+      def format(key, value, record)
+        column = @table.column(key)
+
+        if column.format[@name]
+          column.format.read(@name, value, record)
+        else
+          @base.format(value)
+        end
+      end
+    end
+  end
+end
+

data/lib/tabl.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'active_support/inflector'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/string/output_safety'
+require 'fastercsv'
+
+require 'tabl/formats'
+require 'tabl/formats/html'
+
+require 'tabl/column'
+require 'tabl/deref_column'
+require 'tabl/table'
+
+require 'tabl/dsl'
+
+# require 'tabl/definition'
+# require 'tabl/format'
+# require 'tabl/table'
+# require 'tabl/base'
+

data/spec/integration_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'lib/user_columns'
+require 'lib/post_tables'
+
+describe PostTables do
+  it 'should return csv' do
+    post = OpenStruct.new(:post => 'foo', :user => OpenStruct.new(:first_name => 'John', :last_name => 'Smith'))
+    PostTables.posts.to_csv([post]).should == <<CSV
+Post,User
+foo,John Smith
+CSV
+  end
+end
+
+

data/spec/lib/post_tables.rb

@@ -0,0 +1,11 @@
+module PostTables
+  include Tabl::Dsl
+
+  include_columns UserColumns, :record => :user
+
+  table :posts do |table|
+    table.columns = [ :post, :user ]
+  end
+
+end
+

data/spec/lib/user_columns.rb

@@ -0,0 +1,8 @@
+class UserColumns
+  include Tabl::Dsl
+
+  column :user do |column|
+    column.value = lambda { |user| [ user.first_name, user.last_name ].join(' ') }
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+require 'tabl'
+require 'ostruct'
+
+$: << File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
+
+RSpec.configure do |config|
+end
+

data/spec/tabl/column_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Tabl::Column do
+  it 'should have a label' do
+    column = Tabl::Column.new(:foo)
+    column.label.should == 'Foo'
+  end
+
+  it 'should product a value' do
+    foo = OpenStruct.new(:foo => 'foo')
+    column = Tabl::Column.new(:foo)
+    column.value(foo).should == 'foo'
+  end
+
+  it 'should allow setting the label' do
+    column = Tabl::Column.new(:foo)
+    column.label = 'Bar'
+    column.label.should == 'Bar'
+  end
+
+  it 'should allow overriding the value function' do
+    foo = OpenStruct.new(:bar => 'bar')
+    column = Tabl::Column.new(:foo)
+    column.value = lambda { |foo| foo.bar }
+    column.value(foo).should == 'bar'
+  end
+
+  it 'should allow setting the format' do
+    foo = OpenStruct.new(:foo => 'foo')
+    column = Tabl::Column.new(:foo)
+    column.format.html = lambda { |v| v.upcase }
+    column.format.html('foo', foo).should == 'FOO'
+  end
+
+  it 'should yield a configuration block' do
+    column = Tabl::Column.new(:foo) do |config|
+      config.label = 'Foo'
+      config.value = lambda { |foo| foo.bar }
+      config.format.html = lambda { |v| v.upcase }
+    end
+
+    foo = OpenStruct.new(:bar => 'bar')
+
+    column.label.should == 'Foo'
+    column.value(foo).should == 'bar'
+    column.format.html('bar').should == 'BAR'
+  end
+end
+

data/spec/tabl/deref_column_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Tabl::DerefColumn do
+  before do
+    @column = Tabl::Column.new(:foo)
+    @deref_column = Tabl::DerefColumn.new(@column, :bar)
+    @bar = OpenStruct.new(:bar => OpenStruct.new(:foo => 'foo'))
+  end
+
+  it 'should dereference the object' do
+    @deref_column.value(@bar).should == 'foo'
+  end
+
+  it 'should delegate the label' do
+    @column.label = 'FOO'
+    @deref_column.label.should == 'FOO'
+  end
+
+  it 'should delegate the value' do
+    @column.value = lambda { |o| o.foo.upcase }
+    @deref_column.value(@bar).should == 'FOO'
+  end
+end
+

data/spec/tabl/dsl_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Tabl::Dsl do
+  before do
+    @module = Module.new
+    @module.send(:include, Tabl::Dsl)
+  end
+
+  it 'should define a column method' do
+    @module.should respond_to(:column)
+  end
+
+  it 'should define a table method' do
+    @module.should respond_to(:table)
+  end
+  
+  it 'should define a columns method' do
+    @module.should respond_to(:columns)
+  end
+
+  it 'should define a tables method' do
+    @module.should respond_to(:tables)
+  end
+
+  it 'should define columns' do
+    @module.column :foo
+    @module.columns[0].name.should == :foo
+  end
+
+  it 'should define an include_columns method' do
+    @module.should respond_to(:include_columns)
+  end
+
+  describe '.table' do
+    it 'should define a table' do
+      @module.table :foo
+      @module.foo.should be_a(Tabl::Table)
+    end
+
+    it 'should set base columns' do
+      @module.column :foo
+
+      @module.table :foo
+      @module.foo.base_columns.should == @module.columns
+    end
+  end
+
+  describe '.include_columns' do
+    before do
+      @columns_mod = Module.new
+      @columns_mod.send(:include, Tabl::Dsl)
+      @columns_mod.column(:foo)
+    end
+
+    it 'should include columns' do
+      @module.include_columns @columns_mod
+      @module.columns.should == @columns_mod.columns
+    end
+
+    it 'should take a a deref parameter' do
+      @module.include_columns @columns_mod, :record => :bar
+      @module.columns[0].should be_a Tabl::DerefColumn
+      @module.columns[0].column.should == @columns_mod.columns[0]
+    end
+  end
+end
+

data/spec/tabl/formats/html_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Tabl::Formats::Html do
+  it 'should register under :html' do
+    Tabl::Formats.html.should == Tabl::Formats::Html
+  end
+
+  it 'should escape html' do
+    Tabl::Formats::Html.format('<').should == '&lt;'
+  end
+end

data/spec/tabl/table_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Tabl::Table do
+  it 'should yield a configure block' do
+    yielded = false
+    table = Tabl::Table.new do |config|
+      yielded = true
+    end
+    yielded.should == true
+  end
+
+  it 'should return labels' do
+    table = Tabl::Table.new do |config|
+      config.columns = [ :user, :email, :phone_number ]
+    end
+    table.labels.should == ['User', 'Email', 'Phone Number']
+  end
+
+  it 'should return values' do
+    table = Tabl::Table.new do |config|
+      config.columns = [ :user, :email, :phone_number ]
+    end
+    user = OpenStruct.new(:user => 'fred', :email => 'fred@foo.com', :phone_number => '12345678')
+    table.values(user).should == ['fred', 'fred@foo.com', '12345678']
+  end
+
+  it 'should format values' do
+    table = Tabl::Table.new do |config|
+      config.columns = [ :user, :email, :phone_number ]
+    end
+    user = OpenStruct.new(:user => '<>', :email => 'fred@foo.com', :phone_number => '12345678')
+    table.html.values(user).should == ['&lt;&gt;', 'fred@foo.com', '12345678']
+  end
+
+  it 'should override formats' do
+    table = Tabl::Table.new do |config|
+      config.columns = [ :user, :email, :phone_number ]
+      config.email.format.html = lambda { |v| v.upcase }
+    end
+    user = OpenStruct.new(:user => '<>', :email => 'fred@foo.com', :phone_number => '12345678')
+    table.html.values(user).should == ['&lt;&gt;', 'FRED@FOO.COM', '12345678']
+  end
+
+  it 'should have base columns' do
+    base_columns = [ Tabl::Column.new(:foo, :value => lambda { |record| record.foo.bar }) ]
+    table = Tabl::Table.new(:base_columns => base_columns, :columns => [:foo])
+    foo = OpenStruct.new(:foo => OpenStruct.new(:bar => 'bar'))
+    table.values(foo).should == ['bar']
+  end
+end
+
+

data/tabl.gemspec

@@ -0,0 +1,84 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{tabl}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Liehann Loots}]
+  s.date = %q{2011-09-16}
+  s.description = %q{Gem for creating tables in Rails or any other system.}
+  s.email = %q{liehannl@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "Guardfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/tabl.rb",
+    "lib/tabl/column.rb",
+    "lib/tabl/definition.rb",
+    "lib/tabl/deref_column.rb",
+    "lib/tabl/dsl.rb",
+    "lib/tabl/formats.rb",
+    "lib/tabl/formats/html.rb",
+    "lib/tabl/table.rb",
+    "spec/integration_spec.rb",
+    "spec/lib/post_tables.rb",
+    "spec/lib/user_columns.rb",
+    "spec/spec_helper.rb",
+    "spec/tabl/column_spec.rb",
+    "spec/tabl/deref_column_spec.rb",
+    "spec/tabl/dsl_spec.rb",
+    "spec/tabl/formats/html_spec.rb",
+    "spec/tabl/table_spec.rb",
+    "tabl.gemspec"
+  ]
+  s.homepage = %q{http://github.com/liehann/tabl}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{Gem for creating tables in Rails or any other system.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+      s.add_runtime_dependency(%q<fastercsv>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<libnotify>, [">= 0"])
+      s.add_development_dependency(%q<guard-rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<fastercsv>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<libnotify>, [">= 0"])
+      s.add_dependency(%q<guard-rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<fastercsv>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<libnotify>, [">= 0"])
+    s.add_dependency(%q<guard-rspec>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification 
+name: tabl
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Liehann Loots
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id001
+  name: activesupport
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id002
+  name: fastercsv
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  version_requirements: *id003
+  name: rspec
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  version_requirements: *id004
+  name: bundler
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 6
+        - 4
+        version: 1.6.4
+  version_requirements: *id005
+  name: jeweler
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id006
+  name: libnotify
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id007
+  name: guard-rspec
+  prerelease: false
+description: Gem for creating tables in Rails or any other system.
+email: liehannl@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/tabl.rb
+- lib/tabl/column.rb
+- lib/tabl/definition.rb
+- lib/tabl/deref_column.rb
+- lib/tabl/dsl.rb
+- lib/tabl/formats.rb
+- lib/tabl/formats/html.rb
+- lib/tabl/table.rb
+- spec/integration_spec.rb
+- spec/lib/post_tables.rb
+- spec/lib/user_columns.rb
+- spec/spec_helper.rb
+- spec/tabl/column_spec.rb
+- spec/tabl/deref_column_spec.rb
+- spec/tabl/dsl_spec.rb
+- spec/tabl/formats/html_spec.rb
+- spec/tabl/table_spec.rb
+- tabl.gemspec
+homepage: http://github.com/liehann/tabl
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Gem for creating tables in Rails or any other system.
+test_files: []
+