table_print 0.2.3 → 1.0.0.rc3

data/test/helper.rb

@@ -1,56 +0,0 @@
-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 'test/unit'
-require 'shoulda'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'table_print'
-
-class Test::Unit::TestCase
-end
-
-class MyNestedClass
-  attr_accessor :title, :name, :summary, :captions
-
-  def initialize(title, name, summary, captions)
-    self.title = title
-    self.name = name
-    self.summary = summary
-    self.captions = captions.collect{|c| Caption.new(c[:text], c[:photo_url])}
-  end
-
-  class Caption
-    attr_accessor :text, :photo_url
-
-    def initialize(text, photo_url)
-      self.text = text
-      self.photo_url = photo_url
-    end
-  end
-
-  def self.setup
-    [["how to", "bert", "bertto", [{:text => "no, really, how to", :photo_url => "http://www.123.com/456.jpg"}]],
-     ["enemies", "ernie", "ernieenemies", [{:text => "no, really, enemies", :photo_url => "http://www.234.com/567.jpg"}]],
-     ["a walk to forget", "big bird", "bigbirdforget", [{:text => "no, really, a walk to forget", :photo_url => "http://www.345.com/678.jpg"}]],
-     ["cookies", "cookie monster", "cookiemonstercookies", [{:text => "no, really, cookies", :photo_url => "http://www.456.com/789.jpg"}]],
-     ["your mom", "the count", "thecountmom", [{:text => "no, really, your mom", :photo_url => "http://www.789.com/1011.jpg"}]],
-     ["fire!", "elmo", "elmofire!", [{:text => "no, really, fire!", :photo_url => "http://www.8910.com/1112.jpg"}]],
-     ["eat your veggies", "michelle obama", "michelleobamaveggies", [{:text => "no, really, eat your veggies", :photo_url => "http://www.91011.com/1213.jpg"}]],
-     ["wakka wakka", "ellen degeneres", "ellendegenereswakka", [{:text => "no, really, wakka wakka", :photo_url => "http://www.101112.com/1314.jpg"}]],
-     ["peas and carrots", "the hulk", "thehulkcarrots", [{:text => "no, really, peas and carrots", :photo_url => "http://www.abc.com/def.jpg"}]],
-     ["juan valdez", "camaro", "camaravaldez", [{:text => "no, really, juan valdez", :photo_url => "http://www.bcd.com/efg.jpg"}]],
-     ["fish fish fish", "alaska", "alaskafish", [{:text => "no, really, fish fish fish", :photo_url => "http://www.cde.com/fgh.jpg"}]],
-     ["tracks", "sir toppem hat", "sirtoppemhattracks", [{:text => "no, really, tracks", :photo_url => "http://www.def.com/ghi.jpg"}]],
-     ["smoking stacked", "thomas", "thomasstacked", [{:text => "no, really, smoking stacked", :photo_url => "http://www.efg.com/hij.jpg"}]],
-     ["cannes", "alpo", "alpocannes", [{:text => "no, really, cannes", :photo_url => "http://www.fgh.com/ijk.jpg"}]],
-    ].collect { |a| MyNestedClass.new(a[0], a[1], a[2], a[3]) }
-  end
-end

data/test/test_column.rb

@@ -1,379 +0,0 @@
-require 'helper'
-
-class TablePrint
-  class ColumnHelper
-    def _truncate(field_value)
-      truncate(field_value)
-    end
-
-    def _get_current_method(method_chain)
-      get_current_method(method_chain)
-    end
-
-    def _add_to_stack?(method_chain, method_hash)
-      add_to_stack?(method_chain, method_hash)
-    end
-
-    def _formatted_cell_value(data_obj, method_chain)
-      formatted_cell_value(data_obj, method_chain)
-    end
-
-    def _find_data_length(data, method_chain, start)
-      find_data_length(data, method_chain, start)
-    end
-
-    def _add_stack_objects(stack, data_obj, method_chain, start)
-      add_stack_objects(stack, data_obj, method_chain, start)
-    end
-  end
-end
-
-class TestTablePrint < Test::Unit::TestCase
-
-  # TODO: active record tests if defined?(ActiveRecord)
-
-  # Ordered to match method order in the Column class
-
-  # attr_accessor :field_length, :max_field_length, :method, :name, :options
-  context 'A column object' do
-    setup do
-      @column = TablePrint::ColumnHelper.new([], "to_s")
-      @column.field_length = 0
-      @column.max_field_length = 0
-      @column.method = 0
-      @column.name = 0
-      @column.options = 0
-    end
-    should 'allow writes to and reads from its attributes' do
-      assert_equal 0, @column.field_length
-      assert_equal 0, @column.max_field_length
-      assert_equal 0, @column.method
-      assert_equal 0, @column.name
-      assert_equal 0, @column.options
-    end
-  end
-
-  # def initialize(data, method, options = {})
-  context 'Instantiating a Column' do
-    context 'with a display_method' do
-      setup do
-        @column = TablePrint::ColumnHelper.new([], "to_s")
-      end
-      should 'remember the display method' do
-        assert_equal "to_s", @column.method
-      end
-      should 'set the name' do
-        assert_equal "to s", @column.name
-      end
-    end
-
-    context 'with options including' do
-      context 'name' do
-        setup do
-          @column = TablePrint::ColumnHelper.new([], "first", {:name => "test_tube"})
-        end
-
-        should 'set the name according to the options' do
-          assert_equal "test_tube", @column.name
-        end
-
-        context 'when the method name contains dots' do
-          setup do
-            @column = TablePrint::ColumnHelper.new(["short"], "method1.method2", {:name => "test_tube"})
-          end
-          should 'use the option' do
-            assert_equal "TEST_TUBE", @column.formatted_header
-          end
-        end
-      end
-
-      context 'a field_length' do
-        context 'that is valid' do
-          setup do
-            @column = TablePrint::ColumnHelper.new(["short"], "first", {:field_length => 20})
-          end
-
-          should 'set the field length according to the options' do
-            assert_equal 20, @column.field_length
-          end
-        end
-
-        context 'that is less than 1' do
-          setup do
-            @column = TablePrint::ColumnHelper.new(["short"], "first", {:field_length => 0})
-          end
-
-          should 'ignore the field_length' do
-            assert_equal 5, @column.field_length
-          end
-        end
-
-        context 'that is bigger than the max' do
-          setup do
-            @column = TablePrint::ColumnHelper.new(["short"], "first", {:field_length => 20, :max_field_length => 10})
-          end
-
-          should 'respect the max_field_length' do
-            assert_equal 10, @column.field_length
-          end
-        end
-      end
-    end
-  end
-
-  # def formatted_header
-  context 'The formatted header function' do
-    context 'when the method name contains no special characters and is shorter than the max field length' do
-      setup do
-        @column = TablePrint::ColumnHelper.new(["short"], "first", {:field_length => 10})
-      end
-      should 'uppercase the method name and pad with spaces' do
-        assert_equal "FIRST     ", @column.formatted_header
-      end
-    end
-
-    context 'when the method name contains no special characters and is longer than the max field length' do
-      setup do
-        @column = TablePrint::ColumnHelper.new(["short"], "longMethodName", {:field_length => 10})
-      end
-      should 'uppercase and truncate the method name' do
-        assert_equal "LONGMET...", @column.formatted_header
-      end
-    end
-
-    context 'when the method name contains underscores' do
-      setup do
-        @column = TablePrint::ColumnHelper.new(["short"], "method_name")
-      end
-      should 'replace underscores with spaces' do
-        assert_equal "METHOD NAME", @column.formatted_header
-      end
-    end
-
-    context 'when the method name contains dots' do
-      setup do
-        @column = TablePrint::ColumnHelper.new(["short"], "method1.method2")
-      end
-      should 'replace dots with greater-thans' do
-        assert_equal "METHOD1 > METHOD2", @column.formatted_header
-      end
-    end
-
-    context 'when the user passes a name in the column options' do
-      setup do
-        @column = TablePrint::ColumnHelper.new(["short"], "method1.method2", {:name => "whoop"})
-      end
-      should 'use that name instead of the method name' do
-        assert_equal "WHOOP", @column.formatted_header
-      end
-    end
-  end
-
-  # def formatted_cell_value(data_obj, method_chain)
-  context 'The formatted_cell_value method' do
-    should 'return whitespace if the method chain does not exactly match the column definition method' do
-      assert_equal "               ", TablePrint::ColumnHelper.new([], "captions.text")._formatted_cell_value("test", "id")
-      assert_equal "               ", TablePrint::ColumnHelper.new([], "captions.text")._formatted_cell_value("test", "captions")
-    end
-
-    should 'return whitespace if the method chain begins the ' do
-      assert_equal "no, really, ...", TablePrint::ColumnHelper.new([], "captions.text")._formatted_cell_value(MyNestedClass.setup.first.captions.first, "captions")
-    end
-  end
-
-  # def add_stack_objects(stack, data_obj, method_chain, method_hash)
-  context 'The add_stack_objects method' do
-    context 'when objects need to be added to the stack' do
-      setup do
-        @tp = TablePrint::ColumnHelper.new(MyNestedClass.setup, "captions.text")
-        @stack = [1, 2, 3]
-        @tp._add_stack_objects(@stack, MyNestedClass.setup.first, "", {})
-      end
-      should 'increase stack size' do
-        assert_equal 4, @stack.size
-      end
-      should 'push the new objects on the front of the stack' do
-        assert_equal MyNestedClass::Caption, @stack.first.first.class
-      end
-      should 'include the updated method_chain in the stack' do
-        assert_equal "captions", @stack.first.last
-      end
-    end
-  end
-
-
-  # def add_to_stack?(method_chain, method_hash = {})
-  context 'The add_to_stack? method' do
-    should 'appropriately respond to its arguments' do
-
-      # our first method produces an array, so yes, stack 'em up
-      assert TablePrint::ColumnHelper.new(MyNestedClass.setup, "captions.text")._add_to_stack?("", {})
-
-      # captions has already been called, so it gets popped off our method chain. text is the final method, so no, don't stack
-      assert !TablePrint::ColumnHelper.new(MyNestedClass.setup, "captions.text")._add_to_stack?("captions", {})
-
-      # the method isn't one of ours, so there's nothing for us to do
-      assert !TablePrint::ColumnHelper.new(MyNestedClass.setup, "captions.text")._add_to_stack?("id", {})
-
-      # another column has already added the captions to the stack, so there's no need for us to do it
-      assert !TablePrint::ColumnHelper.new(MyNestedClass.setup, "captions.text")._add_to_stack?("", {"captions" => {}})
-    end
-  end
-
-  # def wrap(object)
-
-  # def truncate(field_value)
-  context 'The truncate function' do
-    should 'let short strings pass through' do
-      assert_equal "asdf", TablePrint::ColumnHelper.new(["a long long long string"], "first")._truncate("asdf")
-    end
-
-    should 'truncate long strings with ellipses' do
-      # have to put long data in the data set to field_length is pushed out to the default max_field_length
-      assert_equal "123456789012345678901234567...", TablePrint::ColumnHelper.new([["1234567890123456789012345678901234567890"]], "first")._truncate("1234567890123456789012345678901234567890")
-    end
-
-    context 'with a non-default field length' do
-      should 'truncate long strings with ellipses' do
-        tp = TablePrint::ColumnHelper.new([], "")
-        tp.field_length = 10
-        assert_equal "1234567...", tp._truncate("1234567890123456789012345678901234567890")
-      end
-    end
-
-    context 'when the max length is tiny' do
-      should 'truncate long strings without ellipses' do
-        assert_equal "123456789012345678901234567...", TablePrint::ColumnHelper.new([["1234567890123456789012345678901234567890"]], "first", :field_length => -10)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "123456789012345678901234567...", TablePrint::ColumnHelper.new([["1234567890123456789012345678901234567890"]], "first", :field_length => 0)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "1", TablePrint::ColumnHelper.new([], "", :field_length => 1)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "12", TablePrint::ColumnHelper.new([], "", :field_length => 2)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "123", TablePrint::ColumnHelper.new([], "", :field_length => 3)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "1...", TablePrint::ColumnHelper.new([], "", :field_length => 4)._truncate("1234567890123456789012345678901234567890")
-      end
-    end
-  end
-
-  # def initialize_field_length(data)
-  context 'The field length function' do
-    should 'honor the field_length options' do
-      assert_equal 5, TablePrint::ColumnHelper.new(["hello there madam"], "to_s", :field_length => 5).field_length
-      assert_equal 30, TablePrint::ColumnHelper.new(["hello there madam"], "to_s", :field_length => 5).max_field_length
-    end
-
-    should 'honor the max_length option' do
-      assert_equal 5, TablePrint::ColumnHelper.new(["hello there madam"], "to_s", :max_field_length => 5).field_length
-      assert_equal 5, TablePrint::ColumnHelper.new(["hello there madam"], "to_s", :max_field_length => 5).max_field_length
-    end
-
-    should 'honor the max_length option over the field_length option' do
-      assert_equal 5, TablePrint::ColumnHelper.new(["hello there madam"], "to_s", :max_field_length => 5, :field_length => 10).field_length
-      assert_equal 5, TablePrint::ColumnHelper.new(["hello there madam"], "to_s", :max_field_length => 5, :field_length => 10).max_field_length
-    end
-
-    should 'find the maximum width of the data' do
-      assert_equal 11, TablePrint::ColumnHelper.new(["hello there"], "to_s").field_length
-    end
-
-    context 'when the data is longer than the max_field_length' do
-      should 'equal the max field length' do
-        assert_equal 5, TablePrint::ColumnHelper.new(["hello there"], "to_s", :max_field_length => 5).field_length
-      end
-    end
-
-    context 'when the column name is longer than the data' do
-      should 'reflect the column name length' do
-        assert_equal 4, TablePrint::ColumnHelper.new(["he"], "to_s", :max_field_length => 5).field_length
-        assert_equal 12, TablePrint::ColumnHelper.new(["hello"], "to_s", :name => "foobar THIS!").field_length
-      end
-    end
-
-    context 'when the method is recursive' do
-      should 'find the maximum width of the data' do
-        assert_equal 30, TablePrint::ColumnHelper.new(MyNestedClass.setup, "captions.photo_url", :max_field_length => 50).field_length
-      end
-    end
-  end
-
-  # def find_data_length(data, method, start)
-  context 'The find_data_length method' do
-    context 'when method_chain is a top level method' do
-      setup do
-        @tp = TablePrint::ColumnHelper.new([], "")
-        @tp._find_data_length(MyNestedClass.setup, "title", Time.now)
-      end
-      should 'set field_length to the longest value in the data set' do
-        assert_equal 16, @tp.field_length
-      end
-    end
-
-    context 'when method_chain is not a top level method' do
-      setup do
-        @tp = TablePrint::ColumnHelper.new([], "")
-        @tp._find_data_length(MyNestedClass.setup, "captions.text", Time.now)
-      end
-      should 'set field_length to the longest value in the data set' do
-        assert_equal 28, @tp.field_length
-      end
-    end
-
-    context 'when the data value is longer than max_field_length' do
-      setup do
-        @tp = TablePrint::ColumnHelper.new([], "", :max_field_length => 10)
-        @tp._find_data_length(MyNestedClass.setup, "captions.photo_url", Time.now)
-      end
-      should 'ignore max_field_length (initialize_field_length handles that - this method is just about the data)' do
-        assert_equal 26, @tp.field_length
-      end
-    end
-  end
-
-  # def get_current_method(method_chain)
-  context 'get_current_method' do
-    context 'with a simple method signature' do
-      context 'and no method chain' do
-        should 'return the method itself' do
-          assert_equal "m1", TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1")._get_current_method("")
-        end
-      end
-      context 'and a method chain that does not match' do
-        should 'return nil' do
-          assert_equal nil, TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1")._get_current_method("m2")
-        end
-      end
-      context 'and an overly long method chain' do
-        should 'return nil' do
-          assert_equal nil, TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1")._get_current_method("m1.m2")
-        end
-      end
-    end
-
-    context 'with a compound method signature' do
-      context 'and no method chain' do
-        should 'return the first method in the chain' do
-          assert_equal "m1", TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1.m2.m3")._get_current_method("")
-        end
-      end
-      context 'and a method chain that does not match' do
-        should 'return nil' do
-          assert_equal nil, TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1.m2.m3")._get_current_method("m2")
-        end
-      end
-      context 'and a valid method chain' do
-        should 'return the next method in the chain' do
-          assert_equal "m2", TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1.m2.m3")._get_current_method("m1")
-          assert_equal "m3", TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1.m2.m3")._get_current_method("m1.m2")
-        end
-      end
-      context 'and an overly long method chain' do
-        should 'return nil' do
-          assert_equal nil, TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1.m2.m3")._get_current_method("m1.m2.m3.m4")
-        end
-      end
-      context 'and a method chain matching our method signature' do
-        should 'return nil' do
-          assert_equal nil, TablePrint::ColumnHelper.new(MyNestedClass.setup, "m1.m2.m3")._get_current_method("m1.m2.m3")
-        end
-      end
-    end
-  end
-end

data/test/test_table_print.rb

@@ -1,162 +0,0 @@
-require 'helper'
-
-class MyClass
-  attr_accessor :title, :name, :summary
-
-  def initialize(title, name, summary)
-    self.title = title
-    self.name = name
-    self.summary = summary
-  end
-
-  def self.setup
-    [["how to", "bert", "bertto"],
-     ["enemies", "ernie", "ernieenemies"],
-     ["a walk to forget", "big bird", "bigbirdforget"],
-     ["cookies", "cookie monster", "cookiemonstercookies"],
-     ["your mom", "the count", "thecountmom"],
-     ["fire!", "elmo", "elmofire!"],
-     ["eat your veggies", "michelle obama", "michelleobamaveggies"],
-     ["wakka wakka", "ellen degeneres", "ellendegenereswakka"],
-     ["peas and carrots", "the hulk", "thehulkcarrots"],
-     ["juan valdez", "camaro", "camaravaldez"],
-     ["fish fish fish", "alaska", "alaskafish"],
-     ["tracks", "sir toppem hat", "sirtoppemhattracks"],
-     ["smoking stacked", "thomas", "thomasstacked"],
-     ["cannes", "alpo", "alpocannes"],
-    ].collect { |a| MyClass.new(a[0], a[1], a[2]) }
-  end
-end
-
-
-class TablePrint
-  def _get_display_methods(data_obj, options)
-    get_display_methods(data_obj, options)
-  end
-
-  def _get_default_display_methods(data_obj)
-    get_default_display_methods(data_obj)
-  end
-
-  def _sort_display_methods(display_methods)
-    sort_display_methods(display_methods)
-  end
-end
-
-class OneMethod
-  def title
-  end
-end
-
-class OneAttrAccessor
-  attr_accessor :title
-end
-
-class ManyMethods
-  def title
-  end
-  def author
-  end
-  def summary
-  end
-end
-
-class StringInheritor < String
-  attr_accessor :title
-end
-
-class ArrayInheritor < Array
-  attr_accessor :title
-end
-
-class HashInheritor < Hash
-  attr_accessor :title
-end
-
-class TestTablePrint < Test::Unit::TestCase
-
-  # TODO: active record tests if defined?(ActiveRecord)
-
-  # Vaguely ordered from most to least granular
-
-  context '' do
-    setup do
-      @tp = TablePrint.new
-    end
-
-    context 'The default display methods for ruby base types' do
-      should 'be empty' do
-        #assert_equal [], @tp._get_default_display_methods([])
-        #assert_equal [], @tp._get_default_display_methods("")
-        #assert_equal [], @tp._get_default_display_methods({})
-        #assert_equal [], @tp._get_default_display_methods(10)
-        #assert_equal [], @tp._get_default_display_methods(1.0)
-      end
-    end
-
-    context 'The default display methods for a custom class with one method' do
-      should 'be that method' do
-        assert_equal ["title"], @tp._get_default_display_methods(OneMethod.new)
-      end
-    end
-
-    context 'The default display methods for a custom class with one attr_accessor' do
-      should 'only be the attr setter' do
-        assert_equal ["title"], @tp._get_default_display_methods(OneAttrAccessor.new)
-      end
-      
-      context 'that subclasses Hash' do
-        should 'only be the attr setter' do
-          assert_equal ["title"], @tp._get_default_display_methods(HashInheritor.new)
-        end
-      end
-      context 'that subclasses Array' do
-        should 'only be the attr setter' do
-          assert_equal ["title"], @tp._get_default_display_methods(ArrayInheritor.new)
-        end
-      end
-      context 'that subclasses String' do
-        should 'only be the attr setter' do
-          assert_equal ["title"], @tp._get_default_display_methods(StringInheritor.new)
-        end
-      end
-    end
-
-    context 'The display methods for a custom class using the :only option' do
-      should 'be an array containing the methods specified in the :only option' do
-        assert_equal ["title"], @tp._get_display_methods(ManyMethods.new, {:only => :title})
-        assert_equal ["title"], @tp._get_display_methods(ManyMethods.new, {:only => "title"})
-        assert_equal ["title"], @tp._get_display_methods(ManyMethods.new, {:only => [:title]})
-        assert_equal ["title"], @tp._get_display_methods(ManyMethods.new, {:only => ["title"]})
-      end
-    end
-
-    # The :include option is more for ActiveRecord. It will only affect custom classes once multi-level methods are implemented.
-    context 'The display methods for a custom class using the :include option' do
-      should "be the same as if it weren't used" do
-        assert_equal ["author", "summary", "title"], @tp._get_display_methods(ManyMethods.new, {:include => :title}).sort
-        assert_equal ["author", "summary", "title"], @tp._get_display_methods(ManyMethods.new, {:include => "title"}).sort
-        assert_equal ["author", "summary", "title"], @tp._get_display_methods(ManyMethods.new, {:include => [:title]}).sort
-        assert_equal ["author", "summary", "title"], @tp._get_display_methods(ManyMethods.new, {:include => ["title"]}).sort
-      end
-    end
-
-    context 'The display methods for a custom class using the :except option' do
-      should "not include any specified methods" do
-        assert_equal ["author", "summary"], @tp._get_display_methods(ManyMethods.new, {:except => :title}).sort
-        assert_equal ["author", "summary"], @tp._get_display_methods(ManyMethods.new, {:except => "title"}).sort
-        assert_equal ["author", "summary"], @tp._get_display_methods(ManyMethods.new, {:except => [:title]}).sort
-        assert_equal ["summary"], @tp._get_display_methods(ManyMethods.new, {:except => ["title", :author]}).sort
-      end
-    end
-
-    context 'An empty input' do
-      should 'say as much in the output' do
-        assert_equal "No data.", @tp.tp(nil)
-        assert_equal "No data.", @tp.tp([])
-        assert_equal "No data.", @tp.tp([nil])
-      end
-    end
-  end
-end
-