table_display 0.5.0

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+table_display-*.gem
+Gemfile.lock
+table_display_test.db
+test/log/test.log

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+# Declare your gem's dependencies in transaction_isolation_level.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# 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 'ruby-debug19', :require => 'ruby-debug'
+# gem 'ruby-debug'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Will Bryant, Sekuda Ltd
+
+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

@@ -0,0 +1,82 @@
+Table Display
+=============
+
+Adds support for displaying your ActiveRecord tables, named scopes, collections, or
+plain arrays in a table view when working in rails console, shell, or email template.
+
+Enumerable#to_table returns the printable strings; Object#pt calls #to_table on its
+first argument and puts out the result.
+
+Columns you haven't loaded (eg. from using :select) are omitted, and derived/calculated
+columns (eg. again, from using :select) are added.
+
+Both #to_table and Object#pt methods take :only, :except, and :methods which work like
+the #to_xml method to change what attributes/methods are output.
+
+The normal output uses #inspect on the data values to make them printable, so you can
+see what type the values had.  When that's inconvenient or you'd prefer direct display,
+you can pass the option :inspect => false to disable inspection.
+
+
+Example
+=======
+
+# You can call the to_table method:
+>> puts Project.find(31).tasks.to_table
++----+------------+------------------------+------------------+--------------------------------+--------------------------------+--------------------------------+
+| id | project_id | description            | due_on           | completed_at                   | created_at                     | updated_at                     |
++----+------------+------------------------+------------------+--------------------------------+--------------------------------+--------------------------------+
+|  1 |         31 | "Write a handy plugin" | Wed, 25 Mar 2009 | Tue Mar 24 23:17:05 +1300 2009 | Mon Mar 23 09:11:02 +1300 2009 | Tue Mar 24 23:17:05 +1300 2009 |
+|  2 |         31 | "Blog the plugin"      | Sun, 05 Apr 2009 | nil                            | Mon Mar 23 09:11:46 +1300 2009 | Mon Mar 23 09:11:46 +1300 2009 |
++----+------------+------------------------+------------------+--------------------------------+--------------------------------+--------------------------------+
+
+# Or equivalently, use "pt" (like pp, but in a table):
+>> pt Customer.find(31).purchases
++----+------------+------------------------+------------------+--------------------------------+--------------------------------+--------------------------------+
+| id | project_id | description            | due_on           | completed_at                   | created_at                     | updated_at                     |
++----+------------+------------------------+------------------+--------------------------------+--------------------------------+--------------------------------+
+|  1 |         31 | "Write a handy plugin" | Wed, 25 Mar 2009 | Tue Mar 24 23:17:05 +1300 2009 | Mon Mar 23 09:11:02 +1300 2009 | Tue Mar 24 23:17:05 +1300 2009 |
+|  2 |         31 | "Blog the plugin"      | Sun, 05 Apr 2009 | nil                            | Mon Mar 23 09:11:46 +1300 2009 | Mon Mar 23 09:11:46 +1300 2009 |
++----+------------+------------------------+------------------+--------------------------------+--------------------------------+--------------------------------+
+
+
+# Like to_xml, you can pass a :methods option to add the output methods on your models, and you can pass :only or :except
+# to (respectively) show only certain columns or show all except certain columns:
+>> puts Customer.find(31).purchases.to_table(:only => [:id, :description], :methods => [:met_due_date?])
++----+------------------------+---------------+
+| id | description            | met_due_date? |
++----+------------------------+---------------+
+|  1 | "Write a handy plugin" | true          |
+|  2 | "Blog the plugin"      | nil           |
++----+------------------------+---------------+
+
+# pt accepts and passes on all options as well:
+>> pt Customer.find(31).purchases, :only => [:id, :description], :methods => [:met_due_date?]
++----+------------------------+---------------+
+| id | description            | met_due_date? |
++----+------------------------+---------------+
+|  1 | "Write a handy plugin" | true          |
+|  2 | "Blog the plugin"      | nil           |
++----+------------------------+---------------+
+
+# There's a convenient equivalent syntax for displaying an ordered list of columns, like :only and :methods:
+>> puts Customer.find(31).purchases.to_table :id, :description, :met_due_date?
+# which provides:
+>> pt Customer.find(31).purchases, :id, :description, :met_due_date?
+# resulting in the same output as above.
+
+
+# If :inspect => false is used, the values will be shown in #to_s form rather than #inspect form:
+>> pt Customer.find(31).purchases, :only => [:id, :description, :due_on, :completed_at]
++----+----------------------+------------+--------------------------------+
+| id | description          | due_on     | completed_at                   |
++----+----------------------+------------+--------------------------------+
+|  1 | Write a handy plugin | 2009-03-25 | Tue Mar 24 23:17:05 +1300 2009 |
+|  2 | Blog the plugin      | 2009-04-05 |                                |
++----+----------------------+------------+--------------------------------+
+
+
+# Note that in all cases, values descending from Numeric are right-aligned, while all other values are left-aligned.
+
+
+Copyright (c) 2009 Will Bryant, Sekuda Ltd, released under the MIT license

data/Rakefile

@@ -0,0 +1,16 @@
+#!/usr/bin/env rake
+
+require 'bundler/gem_tasks'
+require 'rake'
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the table_display plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end

data/init.rb

@@ -0,0 +1,15 @@
+require 'table_display'
+
+# all Enumerable classes should get TableDisplay functionality...
+Enumerable.send(:include, TableDisplay)
+
+# including those that have already included Enumerable by the time this plugin is loaded.
+# Ruby doesn't recursively update through the module tree, so although any new classes/modules
+# that include Enumerable will get TableDisplay, we have to do it ourself for older ones.
+ObjectSpace.each_object(Module) {|o| o.send(:include, TableDisplay) if o.ancestors.include?(Enumerable)}
+ObjectSpace.each_object(Class)  {|o| o.send(:include, TableDisplay) if o.ancestors.include?(Enumerable)}
+
+# Rails 2.3 named_scopes certainly quack like enumerables, but surprisingly they don't themself include Enumerable.
+if ActiveRecord.const_defined?(:NamedScope) && ActiveRecord::NamedScope.const_defined?(:Scope)
+  ActiveRecord::NamedScope::Scope.send(:include, TableDisplay)
+end

data/lib/table_display.rb

@@ -0,0 +1,105 @@
+module TableDisplay
+  def to_table(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    extra_methods = args.length > 0 ? args.collect(&:to_s) : []
+    extra_methods += Array(options.delete(:methods)) if options[:methods]
+    only_attributes = Array(options.delete(:only)) if options[:only]
+    only_attributes ||= [] if args.length > 0
+    except_attributes = Array(options.delete(:except)) if options[:except]
+    except_attributes = (except_attributes + except_attributes.collect(&:to_s)).uniq if except_attributes.present? # we have to keep string and symbol arguments separate for hashes, which may not have 'indifferent access'
+    display_inspect = options.nil? || !options.has_key?(:inspect) || options.delete(:inspect)
+    raise "unknown options passed to to_table: #{options.keys.to_sentence}" unless options.blank?
+    
+    column_lengths = ActiveSupport::OrderedHash.new
+    
+    data = []
+    if only_attributes
+      # we've been given an explicit list of attributes to display
+      only_attributes.each {|attribute| column_lengths[attribute] = 0}
+    else
+      # find all the attribute names
+      each do |record|
+        next if record.nil?
+      
+        # ActiveRecord's #attributes implementation iterates over #attribute_names adding a duped value to the output hash for each entry, so
+        # it's actually more expensive to get the keys and values in one go using #attributes than it is for us to work off #attribute_names ourselves.
+        if record.respond_to?(:attribute_names)
+          # an ActiveModel instance
+          attribute_names = record.attribute_names
+        elsif Object.const_defined?(:OpenStruct) && record.is_a?(OpenStruct)
+          # OpenStruct has a crappy API, #inspect will show the attributes but there's no public way to get a list of them!
+          record = record.instance_variable_get("@table")
+          attribute_names = record.keys
+        elsif record.respond_to?(:attributes)
+          # something like an ActiveResource, which doesn't implement attribute_names but does implement attributes
+          attribute_names = record.attributes.keys
+        else
+          # hopefully something like a hash
+          attribute_names = record.keys
+        end
+      
+        if attribute_names.any? {|name| column_lengths[name].nil?} # optimisation, in most use cases all records will have the same type and the same attributes, so we needn't run this for each - but we do handle varying attribute lists, and attributes that are not columns on the model (calculated columns etc.)
+          # for ActiveRecord classes, we look at the .columns explicitly so we can keep them in the right order
+          columns_to_check = record.is_a?(ActiveRecord::Base) ? ((record.class.columns.collect(&:name) & attribute_names) + attribute_names).uniq : attribute_names
+          columns_to_check.each do |name|
+            next if (only_attributes && !only_attributes.include?(name)) || (except_attributes && except_attributes.include?(name))
+            column_lengths[name] = 0 # the values of columns are the maximum width of value seen; when we come to print out, if the max seen is zero then the attribute has never actually been seen (eg. when a find(:all, :select => ...) has been used to exclude some of the database columns from the resultset), and we hide the column.
+          end
+        end
+      end
+    end
+
+    # also add any :methods given to the list
+    extra_methods.each {|name| column_lengths[name] = 0}
+    
+    each do |record|
+      # add the values for all the columns in our list in order they are
+      data << column_lengths.collect do |attribute, max_width|
+        value = record.is_a?(Hash) ? record[attribute] : record.send(attribute)
+        string_value = display_inspect ? value.inspect : (value.is_a?(String) ? value : value.to_s)
+        column_lengths[attribute] = string_value.mb_chars.length if string_value.mb_chars.length > max_width
+        value.is_a?(Numeric) ? value : string_value # keep Numeric values as-is for now, so we can handle them specially in the output below
+      end
+    end
+    
+    return [] if data.empty?
+    
+    # build the table header
+    separator_string = "+"
+    heading_string   = "|"
+    column_lengths.each do |attribute, max_width|
+      next unless max_width > 0 # skip any columns we never actually saw
+      name = attribute.to_s
+      
+      # the column needs to fit the column header as well as the values
+      if name.mb_chars.length > max_width
+        column_lengths[attribute] = max_width = name.mb_chars.length
+      end
+      
+      separator_string << '-'*(max_width + 2) << '+'
+      heading_string   << ' ' << name.ljust(max_width) << ' |'
+    end
+    
+    rows = [separator_string, heading_string, separator_string]
+    data.each do |data_row|
+      data_string = "|"
+      column_lengths.each_with_index do |(attribute, max_width), index|
+        next unless max_width > 0 # skip any columns we never actually saw
+        value = data_row[index]
+        if value.is_a?(Numeric)
+          data_string << ' ' << (display_inspect ? value.inspect : value.to_s).mb_chars.rjust(max_width) << ' |'
+        else
+          data_string << ' ' << value.mb_chars.ljust(max_width) << ' |'
+        end
+      end
+      rows << data_string
+    end
+    rows << separator_string
+  end
+end
+
+module Kernel
+  def pt(target, *options)
+    puts target.to_table(*options)
+  end
+end

data/lib/table_display/version.rb

@@ -0,0 +1,3 @@
+module TableDisplay
+  VERSION = '0.5.0'
+end

data/table_display.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/table_display/version', __FILE__)
+
+spec = Gem::Specification.new do |gem|
+  gem.name         = 'table_display'
+  gem.version      = TableDisplay::VERSION
+  gem.summary      = "Adds support for displaying your ActiveRecord tables, named scopes, collections, or plain arrays in a table view when working in script/console, shell, or email template."
+  gem.description  = <<-EOF
+Adds support for displaying your ActiveRecord tables, named scopes, collections, or
+plain arrays in a table view when working in rails console, shell, or email template.
+
+Enumerable#to_table returns the printable strings; Object#pt calls #to_table on its
+first argument and puts out the result.
+
+Columns you haven't loaded (eg. from using :select) are omitted, and derived/calculated
+columns (eg. again, from using :select) are added.
+
+Both #to_table and Object#pt methods take :only, :except, and :methods which work like
+the #to_xml method to change what attributes/methods are output.
+
+The normal output uses #inspect on the data values to make them printable, so you can
+see what type the values had.  When that's inconvenient or you'd prefer direct display,
+you can pass the option :inspect => false to disable inspection.
+EOF
+  gem.has_rdoc     = false
+  gem.author       = "Will Bryant"
+  gem.email        = "will.bryant@gmail.com"
+  gem.homepage     = "http://github.com/willbryant/table_display"
+  
+  gem.executables  = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files        = `git ls-files`.split("\n")
+  gem.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_path = "lib"
+  
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "activerecord"
+end

data/test/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: table_display_test.db

data/test/fixtures/projects.yml

@@ -0,0 +1,4 @@
+this_project:
+  id: 31
+  name: table_display plugin
+  description: "A handy plugin for displaying sets of records in a table format, for easy reading at the console."

data/test/fixtures/tasks.yml

@@ -0,0 +1,16 @@
+write_a_handy_plugin:
+  id: 1
+  project_id: 31
+  description: "Write a handy plugin"
+  due_on: 2009-03-25
+  completed_at: 2009-03-24 23:17:05
+  created_at: 2009-03-23 09:11:02
+  updated_at: 2009-03-24 23:17:05
+
+blog_the_plugin:
+  id: 2
+  project_id: 31
+  description: "Blog the plugin"
+  due_on: 2009-04-05
+  created_at: 2009-03-23 09:11:46
+  updated_at: 2009-03-23 09:11:46

data/test/schema.rb

@@ -0,0 +1,15 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :projects, :force => true do |t|
+    t.string   :name,        :null => false
+    t.text     :description
+    t.timestamps
+  end
+  
+  create_table :tasks, :force => true do |t|
+    t.integer  :project_id,  :null => false
+    t.string   :description, :null => false
+    t.date     :due_on
+    t.datetime :completed_at
+    t.timestamps
+  end
+end

data/test/table_display_test.rb

@@ -0,0 +1,297 @@
+# coding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'schema'))
+require 'ostruct'
+
+class Time
+  def to_s(*args)
+    return to_formatted_s(*args) unless args.empty?
+    strftime("%Y-%m-%d %H:%M:%S %z")
+  end
+  
+  def inspect
+    to_s
+  end
+end
+
+class Project < ActiveRecord::Base
+  has_many :tasks
+end
+
+class Task < ActiveRecord::Base
+  belongs_to :project
+  
+  scope :completed, :conditions => 'completed_at IS NOT NULL'
+  
+  def completed?
+    !completed_at.nil?
+  end
+  
+  def project_name
+    project.name
+  end
+end
+
+class TableDisplayTest < ActiveSupport::TestCase
+  fixtures :all
+  
+  def setup
+    @project = projects(:this_project)
+  end
+  
+  test "#to_table is available on arrays" do
+    assert_nothing_raised do
+      [].to_table
+    end
+  end
+  
+  test "#to_table is available on ActiveRecord find results" do # which should be arrays, in fact
+    assert_nothing_raised do
+      Task.find(:all).to_table
+    end
+  end
+  
+  test "#to_table is available on ActiveRecord named_scopes" do
+    assert_nothing_raised do
+      Task.completed.to_table
+    end      
+  end
+  
+  test "#to_table is available on ActiveRecord association collections" do
+    assert_nothing_raised do
+      @project.tasks.to_table
+    end      
+  end
+  
+  test "#to_table is available on named scopes in ActiveRecord association collections" do
+    assert_nothing_raised do
+      @project.tasks.completed.to_table
+    end      
+  end
+  
+  # we run some simple regression tests to check that everything works as expected
+  
+  test "#to_table by default includes all the database columns in database order" do
+    assert_equal <<END.strip, @project.tasks.to_table.join("\n")
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
+| id | project_id | description            | due_on           | completed_at              | created_at                | updated_at                |
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
+|  1 |         31 | "Write a handy plugin" | Wed, 25 Mar 2009 | 2009-03-24 23:17:05 +1300 | 2009-03-23 09:11:02 +1300 | 2009-03-24 23:17:05 +1300 |
+|  2 |         31 | "Blog the plugin"      | Sun, 05 Apr 2009 | nil                       | 2009-03-23 09:11:46 +1300 | 2009-03-23 09:11:46 +1300 |
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
+END
+  end
+  
+  test "#to_table by default includes all the database columns in database order even when not called on a typeless array" do
+    assert_equal <<END.strip, @project.tasks.find(:all).to_table.join("\n")
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
+| id | project_id | description            | due_on           | completed_at              | created_at                | updated_at                |
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
+|  1 |         31 | "Write a handy plugin" | Wed, 25 Mar 2009 | 2009-03-24 23:17:05 +1300 | 2009-03-23 09:11:02 +1300 | 2009-03-24 23:17:05 +1300 |
+|  2 |         31 | "Blog the plugin"      | Sun, 05 Apr 2009 | nil                       | 2009-03-23 09:11:46 +1300 | 2009-03-23 09:11:46 +1300 |
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
+END
+  end
+  
+  test "#to_table leaves out any attributes not loaded" do
+    assert_equal <<END.strip, @project.tasks.find(:all, :select => "id, project_id, completed_at").to_table.join("\n")
++----+------------+---------------------------+
+| id | project_id | completed_at              |
++----+------------+---------------------------+
+|  1 |         31 | 2009-03-24 23:17:05 +1300 |
+|  2 |         31 | nil                       |
++----+------------+---------------------------+
+END
+  end
+
+  test "#to_table also shows any attributes that are not columns on the underlying table" do
+    assert_equal <<END.strip, @project.tasks.find(:all, :joins => :project, :select => "tasks.id, project_id, projects.description AS BigProjectDescription").to_table.join("\n")
++----+------------+-----------------------------------------------------------------------------------------------------+
+| id | project_id | BigProjectDescription                                                                               |
++----+------------+-----------------------------------------------------------------------------------------------------+
+|  1 |         31 | "A handy plugin for displaying sets of records in a table format, for easy reading at the console." |
+|  2 |         31 | "A handy plugin for displaying sets of records in a table format, for easy reading at the console." |
++----+------------+-----------------------------------------------------------------------------------------------------+
+END
+  end
+  
+  test "#to_table excludes any columns named in :except" do
+    assert_equal <<END.strip, @project.tasks.to_table(:except => ['created_at', :completed_at]).join("\n")
++----+------------+------------------------+------------------+---------------------------+
+| id | project_id | description            | due_on           | updated_at                |
++----+------------+------------------------+------------------+---------------------------+
+|  1 |         31 | "Write a handy plugin" | Wed, 25 Mar 2009 | 2009-03-24 23:17:05 +1300 |
+|  2 |         31 | "Blog the plugin"      | Sun, 05 Apr 2009 | 2009-03-23 09:11:46 +1300 |
++----+------------+------------------------+------------------+---------------------------+
+END
+  end
+  
+  test "#to_table excludes all columns except those named in :only" do
+    assert_equal <<END.strip, @project.tasks.to_table(:only => ['id', :due_on]).join("\n")
++----+------------------+
+| id | due_on           |
++----+------------------+
+|  1 | Wed, 25 Mar 2009 |
+|  2 | Sun, 05 Apr 2009 |
++----+------------------+
+END
+  end
+  
+  test "#to_table keeps the columns in the order given in :only" do
+    assert_equal <<END.strip, @project.tasks.to_table(:only => [:due_on, 'id']).join("\n")
++------------------+----+
+| due_on           | id |
++------------------+----+
+| Wed, 25 Mar 2009 |  1 |
+| Sun, 05 Apr 2009 |  2 |
++------------------+----+
+END
+    assert_equal <<END.strip, @project.tasks.to_table(:only => [:due_on, :id]).join("\n")
++------------------+----+
+| due_on           | id |
++------------------+----+
+| Wed, 25 Mar 2009 |  1 |
+| Sun, 05 Apr 2009 |  2 |
++------------------+----+
+END
+  end
+  
+  test "#to_table accepts an unnamed list of arguments for column names" do
+    assert_equal <<END.strip, @project.tasks.to_table('id', :due_on, :completed?).join("\n")
++----+------------------+------------+
+| id | due_on           | completed? |
++----+------------------+------------+
+|  1 | Wed, 25 Mar 2009 | true       |
+|  2 | Sun, 05 Apr 2009 | false      |
++----+------------------+------------+
+END
+  end
+  
+  test "#to_table allows auxiliary named arguments with the array format" do
+    assert_equal <<END.strip, @project.tasks.to_table('id', :due_on, :completed?, :inspect => false).join("\n")
++----+------------+------------+
+| id | due_on     | completed? |
++----+------------+------------+
+|  1 | 2009-03-25 | true       |
+|  2 | 2009-04-05 | false      |
++----+------------+------------+
+END
+  end
+  
+  test "#to_table also shows any :methods given as columns" do
+    assert_equal <<END.strip, @project.tasks.to_table(:methods => [:completed?, 'project_name']).join("\n")
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+------------+------------------------+
+| id | project_id | description            | due_on           | completed_at              | created_at                | updated_at                | completed? | project_name           |
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+------------+------------------------+
+|  1 |         31 | "Write a handy plugin" | Wed, 25 Mar 2009 | 2009-03-24 23:17:05 +1300 | 2009-03-23 09:11:02 +1300 | 2009-03-24 23:17:05 +1300 | true       | "table_display plugin" |
+|  2 |         31 | "Blog the plugin"      | Sun, 05 Apr 2009 | nil                       | 2009-03-23 09:11:46 +1300 | 2009-03-23 09:11:46 +1300 | false      | "table_display plugin" |
++----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+------------+------------------------+
+END
+  end
+  
+  test "#to_table shows the #to_s format rather than the #inspect format when :inspect => false is set" do
+    assert_equal <<END.strip, @project.tasks.to_table(:inspect => false).join("\n")
++----+------------+----------------------+------------+---------------------------+---------------------------+---------------------------+
+| id | project_id | description          | due_on     | completed_at              | created_at                | updated_at                |
++----+------------+----------------------+------------+---------------------------+---------------------------+---------------------------+
+|  1 |         31 | Write a handy plugin | 2009-03-25 | 2009-03-24 23:17:05 +1300 | 2009-03-23 09:11:02 +1300 | 2009-03-24 23:17:05 +1300 |
+|  2 |         31 | Blog the plugin      | 2009-04-05 |                           | 2009-03-23 09:11:46 +1300 | 2009-03-23 09:11:46 +1300 |
++----+------------+----------------------+------------+---------------------------+---------------------------+---------------------------+
+END
+    # note the strings no longer have quotes, the nil is not shown, and the date format happens to be different
+  end
+  
+  test "#to_table correctly pads out to match the length in characters of long values with utf-8 sequences" do
+    tasks(:write_a_handy_plugin).update_attribute(:description, "Write a handy plugin \342\200\223 with UTF-8 handling")
+    assert_equal <<END.strip, @project.tasks.to_table(:only => [:id, :description], :inspect => false).join("\n")
++----+--------------------------------------------+
+| id | description                                |
++----+--------------------------------------------+
+|  1 | Write a handy plugin – with UTF-8 handling |
+|  2 | Blog the plugin                            |
++----+--------------------------------------------+
+END
+  end
+
+  test "#to_table correctly pads out short values with utf-8 sequences" do
+    tasks(:blog_the_plugin).update_attribute(:description, "Blog \342\200\223 plugin")
+    assert_equal <<END.strip, @project.tasks.to_table(:only => [:id, :description], :inspect => false).join("\n")
++----+----------------------+
+| id | description          |
++----+----------------------+
+|  1 | Write a handy plugin |
+|  2 | Blog – plugin        |
++----+----------------------+
+END
+  end
+
+  test "#to_table on an empty array returns an empty result" do
+    assert_equal [], [].to_table
+  end
+  
+  test "#to_table can extract data out of raw hashes" do
+    @records = [{:foo => 1234, :bar => "test"},
+                {:bar => "text", :baz => 5678}]
+    results = @records.to_table.join("\n")
+    assert results.include?('| foo  |')
+    assert results.include?('| bar    |')
+    assert results.include?('| baz  |')
+    assert_equal <<END.strip, @records.to_table(:only => [:foo, :bar, :baz]).join("\n")
++------+--------+------+
+| foo  | bar    | baz  |
++------+--------+------+
+| 1234 | "test" | nil  |
+| nil  | "text" | 5678 |
++------+--------+------+
+END
+    assert_equal <<END.strip, @records.to_table(:only => [:bar, :baz]).join("\n")
++--------+------+
+| bar    | baz  |
++--------+------+
+| "test" | nil  |
+| "text" | 5678 |
++--------+------+
+END
+    assert_equal <<END.strip, @records.to_table(:except => [:bar]).join("\n")
++------+------+
+| foo  | baz  |
++------+------+
+| 1234 | nil  |
+| nil  | 5678 |
++------+------+
+END
+  end
+  
+  test "#to_table can extract data out of OpenStruct records" do
+    @records = [OpenStruct.new(:foo => 1234, :bar => "test"),
+                OpenStruct.new(:bar => "text", :baz => 5678)]
+    results = @records.to_table.join("\n")
+    assert results.include?('| foo  |')
+    assert results.include?('| bar    |')
+    assert results.include?('| baz  |')
+    assert_equal <<END.strip, @records.to_table(:only => [:foo, :bar, :baz]).join("\n")
++------+--------+------+
+| foo  | bar    | baz  |
++------+--------+------+
+| 1234 | "test" | nil  |
+| nil  | "text" | 5678 |
++------+--------+------+
+END
+    assert_equal <<END.strip, @records.to_table(:only => [:bar, :baz]).join("\n")
++--------+------+
+| bar    | baz  |
++--------+------+
+| "test" | nil  |
+| "text" | 5678 |
++--------+------+
+END
+    assert_equal <<END.strip, @records.to_table(:except => [:bar]).join("\n")
++------+------+
+| foo  | baz  |
++------+------+
+| 1234 | nil  |
+| nil  | 5678 |
++------+------+
+END
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require "../../../config/boot.rb" if File.exist?("../../../config/boot.rb")
+
+$KCODE = 'u' if RUBY_VERSION < '1.9' # as per railties initializer.rb: set unicode mode for Ruby 1.8 (Ruby 1.9 just works)
+
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'active_record'
+require 'active_record/fixtures'
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+  # ruby-debug not installed, no debugging for you
+end
+
+ENV['RAILS_ENV'] ||= 'test'
+FileUtils.mkdir File.join(File.dirname(__FILE__), "log") rescue nil
+RAILS_DEFAULT_LOGGER = ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "log", "#{ENV['RAILS_ENV']}.log"))
+
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.join(File.dirname(__FILE__), "database.yml")))
+ActiveRecord::Base.establish_connection ActiveRecord::Base.configurations[ENV['RAILS_ENV']]
+ActiveSupport::TestCase.send(:include, ActiveRecord::TestFixtures) if ActiveRecord.const_defined?('TestFixtures')
+ActiveSupport::TestCase.fixture_path = File.join(File.dirname(__FILE__), "fixtures")
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../init')) # load table_display

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: table_display
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: 
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Will Bryant
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: |
+  Adds support for displaying your ActiveRecord tables, named scopes, collections, or
+  plain arrays in a table view when working in rails console, shell, or email template.
+  
+  Enumerable#to_table returns the printable strings; Object#pt calls #to_table on its
+  first argument and puts out the result.
+  
+  Columns you haven't loaded (eg. from using :select) are omitted, and derived/calculated
+  columns (eg. again, from using :select) are added.
+  
+  Both #to_table and Object#pt methods take :only, :except, and :methods which work like
+  the #to_xml method to change what attributes/methods are output.
+  
+  The normal output uses #inspect on the data values to make them printable, so you can
+  see what type the values had.  When that's inconvenient or you'd prefer direct display,
+  you can pass the option :inspect => false to disable inspection.
+
+email: will.bryant@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README
+- Rakefile
+- init.rb
+- lib/table_display.rb
+- lib/table_display/version.rb
+- table_display.gemspec
+- test/database.yml
+- test/fixtures/projects.yml
+- test/fixtures/tasks.yml
+- test/schema.rb
+- test/table_display_test.rb
+- test/test_helper.rb
+homepage: http://github.com/willbryant/table_display
+licenses: []
+
+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.15
+signing_key: 
+specification_version: 3
+summary: Adds support for displaying your ActiveRecord tables, named scopes, collections, or plain arrays in a table view when working in script/console, shell, or email template.
+test_files: 
+- test/database.yml
+- test/fixtures/projects.yml
+- test/fixtures/tasks.yml
+- test/schema.rb
+- test/table_display_test.rb
+- test/test_helper.rb