table_display 1.0.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba8622f69a321f9bf5642f544c08f8cec21c8173
+  data.tar.gz: 87a83652fd7ca20ed437b44bb2ce88c9235d5a94
+SHA512:
+  metadata.gz: bc1f6b943a1be7442744c1cdec0b484b10c45847391ab9e331c132bd9a242eac13f118f5bfd0b2d062e22482ed7862d68b25a70c637399a4fb610832aa7751af
+  data.tar.gz: 22de4f2301b19d812d54de2484df9f2856cc525a0c42f3943990904a93cc9ebeb1cb95f63caddc0622514b6a09a761ed80d06f7d37528aab30a0563edebe345c

data/README

@@ -4,13 +4,13 @@ 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
+Enumerable#to_table_display returns the printable strings; Object#pt calls #to_table_display 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
+Both #to_table_display 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
@@ -21,8 +21,8 @@ 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
+# You can call the to_table_display method:
+>> puts Project.find(31).tasks.to_table_display
 +----+------------+------------------------+------------------+--------------------------------+--------------------------------+--------------------------------+
 | id | project_id | description            | due_on           | completed_at                   | created_at                     | updated_at                     |
 +----+------------+------------------------+------------------+--------------------------------+--------------------------------+--------------------------------+
@@ -42,7 +42,7 @@ Example
 
 # 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?])
+>> puts Customer.find(31).purchases.to_table_display(:only => [:id, :description], :methods => [:met_due_date?])
 +----+------------------------+---------------+
 | id | description            | met_due_date? |
 +----+------------------------+---------------+
@@ -60,7 +60,7 @@ Example
 +----+------------------------+---------------+
 
 # 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?
+>> puts Customer.find(31).purchases.to_table_display :id, :description, :met_due_date?
 # which provides:
 >> pt Customer.find(31).purchases, :id, :description, :met_due_date?
 # resulting in the same output as above.

data/lib/table_display.rb

@@ -1,5 +1,5 @@
 module TableDisplay
-  def to_table(*args)
+  def to_table_display(*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]
@@ -8,7 +8,7 @@ module TableDisplay
     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?
+    raise "unknown options passed to to_table_display: #{options.keys.to_sentence}" unless options.blank?
     
     column_lengths = ActiveSupport::OrderedHash.new
     
@@ -100,7 +100,7 @@ end
 
 module Kernel
   def pt(target, *options)
-    puts target.to_table(*options)
+    puts target.respond_to?(:to_table_display) ? target.to_table_display(*options) : target
   end
 end
 

data/lib/table_display/version.rb

@@ -1,3 +1,3 @@
 module TableDisplay
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/table_display.gemspec

@@ -9,13 +9,13 @@ spec = Gem::Specification.new do |gem|
 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
+Enumerable#to_table_display returns the printable strings; Object#pt calls #to_table_display 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
+Both #to_table_display 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
@@ -35,4 +35,5 @@ EOF
   gem.add_development_dependency "rake"
   gem.add_development_dependency "sqlite3"
   gem.add_development_dependency "activerecord"
+  gem.add_development_dependency "test-unit"
 end

data/test/table_display_test.rb

@@ -39,40 +39,40 @@ class TableDisplayTest < ActiveSupport::TestCase
     @project = projects(:this_project)
   end
   
-  test "#to_table is available on arrays" do
+  test "#to_table_display is available on arrays" do
     assert_nothing_raised do
-      [].to_table
+      [].to_table_display
     end
   end
   
-  test "#to_table is available on ActiveRecord find results" do # which should be arrays, in fact
+  test "#to_table_display is available on ActiveRecord find results" do # which should be arrays, in fact
     assert_nothing_raised do
-      Task.find(:all).to_table
+      Task.find(:all).to_table_display
     end
   end
   
-  test "#to_table is available on ActiveRecord named_scopes" do
+  test "#to_table_display is available on ActiveRecord named_scopes" do
     assert_nothing_raised do
-      Task.completed.to_table
+      Task.completed.to_table_display
     end      
   end
   
-  test "#to_table is available on ActiveRecord association collections" do
+  test "#to_table_display is available on ActiveRecord association collections" do
     assert_nothing_raised do
-      @project.tasks.to_table
+      @project.tasks.to_table_display
     end      
   end
   
-  test "#to_table is available on named scopes in ActiveRecord association collections" do
+  test "#to_table_display is available on named scopes in ActiveRecord association collections" do
     assert_nothing_raised do
-      @project.tasks.completed.to_table
+      @project.tasks.completed.to_table_display
     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")
+  test "#to_table_display by default includes all the database columns in database order" do
+    assert_equal <<END.strip, @project.tasks.to_table_display.join("\n")
 +----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
 | id | project_id | description            | due_on           | completed_at              | created_at                | updated_at                |
 +----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
@@ -82,8 +82,8 @@ class TableDisplayTest < ActiveSupport::TestCase
 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")
+  test "#to_table_display 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_display.join("\n")
 +----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
 | id | project_id | description            | due_on           | completed_at              | created_at                | updated_at                |
 +----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+
@@ -93,8 +93,8 @@ END
 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")
+  test "#to_table_display leaves out any attributes not loaded" do
+    assert_equal <<END.strip, @project.tasks.find(:all, :select => "id, project_id, completed_at").to_table_display.join("\n")
 +----+------------+---------------------------+
 | id | project_id | completed_at              |
 +----+------------+---------------------------+
@@ -104,8 +104,8 @@ END
 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")
+  test "#to_table_display 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_display.join("\n")
 +----+------------+-----------------------------------------------------------------------------------------------------+
 | id | project_id | BigProjectDescription                                                                               |
 +----+------------+-----------------------------------------------------------------------------------------------------+
@@ -115,8 +115,8 @@ END
 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")
+  test "#to_table_display excludes any columns named in :except" do
+    assert_equal <<END.strip, @project.tasks.to_table_display(:except => ['created_at', :completed_at]).join("\n")
 +----+------------+------------------------+------------------+---------------------------+
 | id | project_id | description            | due_on           | updated_at                |
 +----+------------+------------------------+------------------+---------------------------+
@@ -126,8 +126,8 @@ END
 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")
+  test "#to_table_display excludes all columns except those named in :only" do
+    assert_equal <<END.strip, @project.tasks.to_table_display(:only => ['id', :due_on]).join("\n")
 +----+------------------+
 | id | due_on           |
 +----+------------------+
@@ -137,8 +137,8 @@ END
 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")
+  test "#to_table_display keeps the columns in the order given in :only" do
+    assert_equal <<END.strip, @project.tasks.to_table_display(:only => [:due_on, 'id']).join("\n")
 +------------------+----+
 | due_on           | id |
 +------------------+----+
@@ -146,7 +146,7 @@ END
 | Sun, 05 Apr 2009 |  2 |
 +------------------+----+
 END
-    assert_equal <<END.strip, @project.tasks.to_table(:only => [:due_on, :id]).join("\n")
+    assert_equal <<END.strip, @project.tasks.to_table_display(:only => [:due_on, :id]).join("\n")
 +------------------+----+
 | due_on           | id |
 +------------------+----+
@@ -156,8 +156,8 @@ END
 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")
+  test "#to_table_display accepts an unnamed list of arguments for column names" do
+    assert_equal <<END.strip, @project.tasks.to_table_display('id', :due_on, :completed?).join("\n")
 +----+------------------+------------+
 | id | due_on           | completed? |
 +----+------------------+------------+
@@ -167,8 +167,8 @@ END
 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")
+  test "#to_table_display allows auxiliary named arguments with the array format" do
+    assert_equal <<END.strip, @project.tasks.to_table_display('id', :due_on, :completed?, :inspect => false).join("\n")
 +----+------------+------------+
 | id | due_on     | completed? |
 +----+------------+------------+
@@ -178,8 +178,8 @@ END
 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")
+  test "#to_table_display also shows any :methods given as columns" do
+    assert_equal <<END.strip, @project.tasks.to_table_display(:methods => [:completed?, 'project_name']).join("\n")
 +----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+------------+------------------------+
 | id | project_id | description            | due_on           | completed_at              | created_at                | updated_at                | completed? | project_name           |
 +----+------------+------------------------+------------------+---------------------------+---------------------------+---------------------------+------------+------------------------+
@@ -189,8 +189,8 @@ END
 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")
+  test "#to_table_display shows the #to_s format rather than the #inspect format when :inspect => false is set" do
+    assert_equal <<END.strip, @project.tasks.to_table_display(:inspect => false).join("\n")
 +----+------------+----------------------+------------+---------------------------+---------------------------+---------------------------+
 | id | project_id | description          | due_on     | completed_at              | created_at                | updated_at                |
 +----+------------+----------------------+------------+---------------------------+---------------------------+---------------------------+
@@ -201,9 +201,9 @@ 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
+  test "#to_table_display 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")
+    assert_equal <<END.strip, @project.tasks.to_table_display(:only => [:id, :description], :inspect => false).join("\n")
 +----+--------------------------------------------+
 | id | description                                |
 +----+--------------------------------------------+
@@ -213,9 +213,9 @@ END
 END
   end
 
-  test "#to_table correctly pads out short values with utf-8 sequences" do
+  test "#to_table_display 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")
+    assert_equal <<END.strip, @project.tasks.to_table_display(:only => [:id, :description], :inspect => false).join("\n")
 +----+----------------------+
 | id | description          |
 +----+----------------------+
@@ -225,18 +225,18 @@ END
 END
   end
 
-  test "#to_table on an empty array returns an empty result" do
-    assert_equal [], [].to_table
+  test "#to_table_display on an empty array returns an empty result" do
+    assert_equal [], [].to_table_display
   end
   
-  test "#to_table can extract data out of raw hashes" do
+  test "#to_table_display can extract data out of raw hashes" do
     @records = [{:foo => 1234, :bar => "test"},
                 {:bar => "text", :baz => 5678}]
-    results = @records.to_table.join("\n")
+    results = @records.to_table_display.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")
+    assert_equal <<END.strip, @records.to_table_display(:only => [:foo, :bar, :baz]).join("\n")
 +------+--------+------+
 | foo  | bar    | baz  |
 +------+--------+------+
@@ -244,7 +244,7 @@ END
 | nil  | "text" | 5678 |
 +------+--------+------+
 END
-    assert_equal <<END.strip, @records.to_table(:only => [:bar, :baz]).join("\n")
+    assert_equal <<END.strip, @records.to_table_display(:only => [:bar, :baz]).join("\n")
 +--------+------+
 | bar    | baz  |
 +--------+------+
@@ -252,7 +252,7 @@ END
 | "text" | 5678 |
 +--------+------+
 END
-    assert_equal <<END.strip, @records.to_table(:except => [:bar]).join("\n")
+    assert_equal <<END.strip, @records.to_table_display(:except => [:bar]).join("\n")
 +------+------+
 | foo  | baz  |
 +------+------+
@@ -262,14 +262,14 @@ END
 END
   end
   
-  test "#to_table can extract data out of OpenStruct records" do
+  test "#to_table_display 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")
+    results = @records.to_table_display.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")
+    assert_equal <<END.strip, @records.to_table_display(:only => [:foo, :bar, :baz]).join("\n")
 +------+--------+------+
 | foo  | bar    | baz  |
 +------+--------+------+
@@ -277,7 +277,7 @@ END
 | nil  | "text" | 5678 |
 +------+--------+------+
 END
-    assert_equal <<END.strip, @records.to_table(:only => [:bar, :baz]).join("\n")
+    assert_equal <<END.strip, @records.to_table_display(:only => [:bar, :baz]).join("\n")
 +--------+------+
 | bar    | baz  |
 +--------+------+
@@ -285,7 +285,7 @@ END
 | "text" | 5678 |
 +--------+------+
 END
-    assert_equal <<END.strip, @records.to_table(:except => [:bar]).join("\n")
+    assert_equal <<END.strip, @records.to_table_display(:except => [:bar]).join("\n")
 +------+------+
 | foo  | baz  |
 +------+------+

metadata

@@ -1,90 +1,93 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: table_display
-version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 0
-  version: 1.0.0
+version: !ruby/object:Gem::Version
+  version: 2.0.0
 platform: ruby
-authors: 
+authors:
 - Will Bryant
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-04-21 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2016-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: sqlite3
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 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
+
+  Enumerable#to_table_display returns the printable strings; Object#pt calls #to_table_display 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
+
+  Both #to_table_display 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
+files:
+- ".gitignore"
 - Gemfile
 - MIT-LICENSE
 - README
@@ -101,38 +104,30 @@ files:
 - test/test_helper.rb
 homepage: http://github.com/willbryant/table_display
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  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
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 2.5.1
 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: 
+specification_version: 4
+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