table_print 0.1.2 → 0.2.0

data/README.rdoc

@@ -25,7 +25,7 @@ it assumes the objects in your array all respond to the same methods.
   $ rails c
   > tp array_of_objects, options = {}
 
-And you should see something like this:
+You should see something like this:
 
   NAME              | SUMMARY                         | TITLE
   -----------------------------------------------------------------------
@@ -44,7 +44,33 @@ on your model.
   > tp User.limit(30), {:only => [:address, :city, :state, :zip]}
 
 If you're not using ActiveRecord, the TablePrint default is to show all the methods on your object. Thus, the <b>:include</b>
-option is useless at the moment. You are still able to use <b>:only</b> and <b>:include</b>.
+option is useless at the moment. You are still able to use <b>:only</b> and <b>:except</b>.
+
+You can reference nested objects with the method chain required to reach them. Say you had some users who wrote books, and those
+books had photos.
+
+  > tp array_of_objects, :only => ["name", "books.title", "books.photos.caption"]
+
+  NAME              | BOOKS > TITLE     | BOOKS > PHOTOS > CAPTION
+  -------------------------------------------------------------------------
+  Michael Connelly  |                   |
+                    | The Fifth Witness |
+                    |                   | Susan was running, fast, away...
+                    |                   | Along came a spider.
+                    | Malcolm X         |
+                    | Bossypants        |
+                    |                   | Yes! Yes! A thousand times ye...
+                    |                   | Don't see many like you aroun...
+  Carrot Top        |                   |
+  Milton Greene     |                   |
+                    | How I Learned     |
+                    |                   | Once upon a time, I was a sma...
+                    |                   | Lemons are yellow, limes are ...
+                    |                   | Never as a woman her age. I l...
+                    | Desperados        |
+                    |                   | Avast.
+                    |                   | Giraffes lived a peaceful exi...
+
 
 === Column options
 
@@ -61,7 +87,7 @@ Columns have other options, including:
 will ensure that the column is as skinny as possible, but never above the number you provide.
 
 <b>field_length:</b> Useful for very large data sets, this option will explicitly set the column width regardless of the data
-it contains.
+it contains. The max_field_length option takes precedence over field_length - ie, field_length can't be longer than max_field_length.
 
 
 == Contributing to table_print

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/lib/table_print.rb

@@ -6,6 +6,7 @@
 #   on-the-fly column definitions (pass a proc as an include, eg 'tp User.all, :include => {:column_name => "Zodiac", :display_method => lambda {|u| find_zodiac_sign(u.birthday)}}')
 #   allow user to pass ActiveRelation instead of a data array? That could open up so many options!
 #   a :short_booleans method could save a little space (replace true/false with T/F or 1/0)
+#   we could do some really smart stuff with polymorphic relationships, eg reusing photo column for blogs AND books!
 #
 # bugs
 #
@@ -13,6 +14,7 @@
 
 class TablePrint
 
+  # We need this set of built-in types when we determine the default display methods for a given object
   OBJECT_CLASSES = [String, Bignum, Regexp, ThreadError, Numeric, SystemStackError, IndexError,
                     SecurityError, SizedQueue, IO, Range, Object, Exception, NoMethodError, TypeError, Integer, Dir,
                     ZeroDivisionError, Kernel, RegexpError, SystemExit, NotImplementedError, Hash,
@@ -23,56 +25,49 @@ class TablePrint
                     StandardError, EOFError, LoadError, NameError, NilClass, TrueClass, MatchingData,
                     LocalJumpError, Binding, SignalException, SystemCallError, File, ScriptError, Module, Symbol]
 
-  # TODO: make options for things like MAX_FIELD_LENGTH
-  # TODO: make options for things like separator
-  # TODO: make options for things like column order
+  attr_accessor :columns, :display_methods, :separator
+
   def initialize(options = {})
+    # TODO: make options for things like column order
   end
 
-  # TODO: show documentation if invoked with no arguments
-  # TODO: use *args instead of options
   def tp(data, options = {})
-    data = wrap(data).compact
+    # TODO: show documentation if invoked with no arguments
+    # TODO: use *args instead of options
 
-    # nothing to see here
-    if data.empty?
-      return "No data."
-    end
+    self.separator = options[:separator] || " | "
 
-    separator = "  | "
+    stack = wrap(data).compact
 
-    display_methods = get_display_methods(data.first, options)
-    unless display_methods.length > 0
-      return data.inspect.to_s
+    if stack.empty?
+      return "No data."
     end
 
-    # we're going to load all the data into memory so we can calculate field lengths.
-    # TODO: there has to be a better way than loading everything into memory
-    # TODO: stop checking field length once we hit the max
-    # TODO: don't check field length on fixed-width columns
+    self.display_methods = get_display_methods(data.first, options) # these are all strings now
+    unless self.display_methods.length > 0
+      return stack.inspect.to_s
+    end
 
     # make columns for all the display methods
-    columns = display_methods.collect { |m| Column.new(data, m, options[m] || options[m.to_sym]) }
+    self.columns = {}
+    self.display_methods.each do |m|
+      self.columns[m] = ColumnHelper.new(data, m, options[m] || options[m.to_sym])
+    end
 
     output = [] # a list of rows.  we'll join this with newlines when we're done
 
     # column headers
     row = []
-    columns.each do |column|
-      row << column.formatted_header
+    self.display_methods.each do |m|
+      row << self.columns[m].formatted_header
     end
-    output << row.join(separator)
+    output << row.join(self.separator)
 
     # a row of hyphens to separate the headers from the data
-    output << ("-" * row.join(separator).length)
+    output << ("-" * output.first.length)
 
-    # the data!
-    data.each do |data_obj|
-      row = []
-      columns.each do |column|
-        row << column.formatted_field_value(data_obj)
-      end
-      output << row.join(separator)
+    while stack.length > 0
+      format_row(stack, output)
     end
 
     output.join("\n")
@@ -80,6 +75,42 @@ class TablePrint
 
   private
 
+  def format_row(stack, output)
+
+    # method_chain is a dot-delimited list of methods, eg "user.blogs.url". It represents the path from the top-level
+    # objects to the data_obj.
+    data_obj, method_chain = stack.shift
+
+    # top level objects don't have a method_chain, give them one so we don't have to null-check everywhere
+    method_chain ||= ""
+
+    # represent method_chain strings we've seen for this row as a tree of hash keys.
+    # eg, if we have columns for "user.blogs.url" and "user.blogs.title", we only want to add one set of user.blogs to the stack
+    method_hash = {}
+
+    # if no columns in this row produce any data, we don't want to append it to the output. eg, if our only columns are
+    # ["id", "blogs.title"] we don't want to print a blank row for every blog we iterate over. We want to entirely skip
+    # printing a row for that level of the hierarchy.
+    found_data = false
+
+    # dive right in!
+    row = []
+    self.display_methods.each do |m|
+      column = self.columns[m]
+
+      # If this column happens to begin a recursion, get those objects on the stack. Pass in the stack-tracking info
+      # we've saved: method_chain and method_hash.
+      column.add_stack_objects(stack, data_obj, method_chain, method_hash)
+
+      # all rows show all cells. Even if there's no data we still have to generate an empty cell of the proper width
+      row << column.formatted_cell_value(data_obj, method_chain)
+      found_data = true unless row[-1].strip.empty?
+    end
+
+    output << row.join(self.separator) if found_data
+  end
+
+  # Sort out the user options into a set of display methods we're going to show. This always returns strings.
   def get_display_methods(data_obj, options)
     # determine what methods we're going to use
 
@@ -88,60 +119,30 @@ class TablePrint
     #   :except - use the default set of methods but NOT the ones passed here
     #   :include - use the default set of methods AND the ones passed here
     #   :only - discard the default set of methods in favor of this list
-    #   :cascade -
-    #
-    # eg
-    #
-    # tp User.limit(30) # default to using AR columns
-    # tp User.limit(30) :except => :display_name
-    # tp User.limit(30) :except => [:display_name, :created_at]
-    # tp User.limit(30) :except => [:display_name, :timestamps] # a rails convention - but this could just be a type-based filter instead of method-based?
-    # tp User.limit(30) :include => :status     # not an AR column
-    # tp User.limit(30) :except => :display_name
-    # tp User.limit(30) :except => :display_name
-    # tp User.limit(30) :except => :display_name
-    # tp User.limit(30) :except => :display_name
-    #
-    # tp User.include(:blogs).limit(30) :cascade => :blog
-    # tp User.limit(30) :include => "blog.title"  # use dot notation to traverse children
-    # TODO: how to handle multiple children? eg, a user has fifteen blogs
-    #
-    # tp [myClassInstance1, ...]  # default to using non-base methods
-    # tp [myClassInstance1, ...] :except => :blah
-    # tp [myClassInstance1, ...] :except => [:blah, :blow]
-    # tp [myClassInstance1, ...] :include => :blah
-    # tp [myClassInstance1, ...] :include => [:blah, :blow]
-    # tp [myClassInstance1, ...] :include => :blah, :except => :blow
-    # tp [myClassInstance1, ...] :only => [:one, :two, :three]
-
-    if options.has_key? :only or options.has_key? "only"
-      display_methods = clean_display_methods(data_obj, wrap(options[:only]))
+    #   :cascade - show all methods in child objects
+
+    if options.has_key? :only
+      display_methods = wrap(options[:only]).map { |m| m.to_s }
       return display_methods if display_methods.length > 0
+    else
+      display_methods = get_default_display_methods(data_obj) # start with what we can deduce
+      display_methods.concat(wrap(options[:include])).map! { |m| m.to_s } # add the includes
+      display_methods = (display_methods - wrap(options[:except]).map! { |m| m.to_s }) # remove the excepts
     end
 
-    # make all the options into arrays
-    methods_to_include = clean_display_methods(data_obj, wrap(options[:include]))
-    methods_to_except = clean_display_methods(data_obj, wrap(options[:except]))
-
-    # add/remove the includes/excludes from the defaults
-    display_methods = get_default_display_methods(data_obj)
-    display_methods.concat(methods_to_include).uniq!
-    display_methods - methods_to_except
+    display_methods.uniq.compact
   end
 
+  # Sniff the data class for non-standard methods to use as a baseline for display
   def get_default_display_methods(data_obj)
     # ActiveRecord
     return data_obj.class.columns.collect { |c| c.name } if defined?(ActiveRecord) and data_obj.is_a? ActiveRecord::Base
 
-    # base types
-    # TODO: fill out this list. any way to get this programatically? do we actually want to filter out all base ruby types? important question for custom classes inheriting from base types
-    return [] if [Float, Fixnum, String, Numeric, Array, Hash].include? data_obj.class
-
     # custom class
     methods = data_obj.class.instance_methods
     OBJECT_CLASSES.each do |oclass|
       if data_obj.is_a? oclass
-        methods = methods - oclass.instance_methods  # we're only interested in custom methods, not ruby core methods
+        methods = methods - oclass.instance_methods # we're only interested in custom methods, not ruby core methods
       end
     end
 
@@ -150,19 +151,9 @@ class TablePrint
     methods
   end
 
-  def clean_display_methods(data_obj, display_methods)
-    # TODO: this should probably be inside Column
-    clean_methods = []
-    display_methods.each do |m|
-      next if m.nil?
-      next if m == ""
-      next unless data_obj.respond_to? m
-      clean_methods << m.to_s
-    end
-    clean_methods.uniq
-  end
-
   # borrowed from rails
+  # turn objects into an array
+  # TODO: this method is duped, put it someplace everyone can see it
   def wrap(object)
     if object.nil?
       []
@@ -173,69 +164,174 @@ class TablePrint
     end
   end
 
-  class Column
-    attr_accessor :name, :display_method, :options, :data, :field_length, :max_field_length
+  class ColumnHelper
+    attr_accessor :field_length, :max_field_length, :method, :name, :options
+
+    # method is a string
+    def initialize(data, method, options = {})
+      self.method = method
+      self.options = options || {} # could have been passed an explicit nil
+
+      self.name = self.options[:name] || method.gsub("_", " ").gsub(".", " > ")
 
-    def initialize(data, display_method, options = {})
-      self.options = options || {}    # could have been passed an explicit nil
-      self.display_method = display_method
-      self.name = self.options[:name] || display_method.gsub("_", " ")
       self.max_field_length = self.options[:max_field_length] || 30
-      self.max_field_length = [self.max_field_length, 1].max  # numbers less than one are meaningless
+      self.max_field_length = [self.max_field_length, 1].max # numbers less than one are meaningless
 
-      # initialization
-      self.initialize_field_length(data)
+      initialize_field_length(data)
     end
 
     def formatted_header
       "%-#{self.field_length}s" % truncate(self.name.upcase)
     end
 
-    def formatted_field_value(data_obj)
-      "%-#{self.field_length}s" % truncate(data_obj.send(self.display_method).to_s)
+    def formatted_cell_value(data_obj, method_chain)
+      cell_value = ""
+
+      # top-level objects don't have method chain. Need to check explicitly whether our method is top-level, otherwise
+      # if the last method in our chain matches a top-level method we could accidentally print its data in our column.
+      #
+      # The method chain is what we've been building up as we were "recursing" through previous objects. You could think of
+      # it as a prefix for this row.  Eg, we could be looping through the columns with a method_chain of "locker.assets",
+      # indicating that we've recursed down from user to locker and are now interested in printing assets. So
+      #
+      unless method_chain == "" and self.method.include? "."
+        our_method_chain = self.method.split(".")
+        our_method = our_method_chain.pop
+
+        # check whether the method_chain fully qualifies the path to this particular object. If this is the bottom level
+        # of object in the tree, and the method_chain matches all the way down, then it's finally time to print this cell.
+        if method_chain == our_method_chain.join(".")
+          if data_obj.respond_to? our_method
+            cell_value = data_obj.send(our_method)
+          end
+        end
+      end
+      "%-#{self.field_length}s" % truncate(cell_value.to_s)
     end
 
-    def initialize_field_length(data)
-      # skip all this nonsense if we've been explicitly told what to do
-      if self.options[:field_length] and self.options[:field_length] > 0
-        length = self.options[:field_length]
-      else
-        length = self.name.length # it has to at least be long enough for the column header!
-
-        start = Time.now
-        data.each do |data_obj|
-          next if data_obj.nil?
-
-          # fixed-width fields don't require the full loop
-          case data_obj.send(self.display_method)
-            when Time
-              length = data_obj.send(self.display_method).to_s.length
-              break
-            when TrueClass, FalseClass
-              length = [5, length].max
-              break
-          end
+    # Determine if we need to add some stuff to the stack. If so, put it on top and update the tracking objects.
+    def add_stack_objects(stack, data_obj, method_chain, method_hash)
 
-          length = [length, data_obj.send(self.display_method).to_s.length].max
-          break if length >= self.max_field_length # we're never going to longer than the global max, so why keep going
-          break if (Time.now - start) > 2 # assume if we loop for more than 2s that we've made it through a representative sample, and bail
-        end
+      return unless self.add_to_stack?(method_chain, method_hash)
+
+      # TODO: probably a less awkward string method to do this
+      # current_method is the method we're going to call on our data_obj. Say our column is "locker.assets.url" and
+      # our chain is "locker", current_method would be "assets"
+      current_method = get_current_method(method_chain)
+
+      new_stack_objects = []
+      if current_method != "" and data_obj.respond_to? current_method
+        new_stack_objects = data_obj.send(current_method)
+      end
+
+      # Now that we've seen "locker.assets", no need to add it to the stack again for this row! Save it off in method_hash
+      # so when we hit "locker.assets.caption" we won't add the same assets again.
+      new_method_chain = method_chain == "" ? current_method : "#{method_chain}.#{current_method}"
+      method_hash[new_method_chain] = {}
+
+      # TODO: probably a cool array method to do this
+      # finally - update the stack with the object(s) we found
+      wrap(new_stack_objects).reverse_each do |stack_obj|
+        stack.unshift [stack_obj, new_method_chain]
+      end
+    end
+
+    def add_to_stack?(method_chain, method_hash = {})
+
+      # Check whether we're involved in this row. method_chain lets us know the path we took to find the current set of
+      # data objects. If our method doesn't act upon those objects, bail.
+      # eg, if these objects are the result of calling "locker.assets" on top-level user objects, but our method is "blogs.title",
+      # all we're going to be doing on this row is pushing out empty cells.
+      return unless self.method.start_with? method_chain
+
+      # check whether another column has already added our objects. if we hit "locker.assets.url" already and we're
+      # "locker.assets.caption", the assets are already on the stack. Don't want to add them again.
+      new_method_chain = method_chain == "" ? get_current_method(method_chain) : "#{method_chain}.#{get_current_method(method_chain)}"
+      return if method_hash.has_key? new_method_chain
+
+      # OK! this column relates to the data object and hasn't been beaten to the punch. But do we have more levels to recurse, or
+      # is this object on the bottom rung and just needs formatting?
+
+      # if this is the top level, all we need to do is check for a dot, indicating a chain of methods
+      if method_chain == ""
+        return method.include? "."
       end
 
-      self.field_length = [length, self.max_field_length].min   # never bigger than the max
+      # if this isn't the top level, subtract out the part of the chain we've already called before we check for further chaining
+      test_method = String.new(method[method_chain.length, method.length])
+      test_method = test_method[1, test_method.length] if test_method.start_with? "."
+
+      test_method.include? "."
     end
 
     private
-    
+
+    # borrowed from rails
+    # turn objects into an array
+    def wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary
+      else
+        [object]
+      end
+    end
+
+    # cut off field_value based on our previously determined width
     def truncate(field_value)
       copy = String.new(field_value)
-      if copy.length > self.max_field_length
-        copy = copy[0..self.max_field_length-1]
-        copy[-3..-1] = "..." unless self.max_field_length <= 3 # don't use ellipses when the string is tiny
+      if copy.length > self.field_length
+        copy = copy[0..self.field_length-1]
+        copy[-3..-1] = "..." unless self.field_length <= 3 # don't use ellipses when the string is tiny
       end
       copy
     end
+
+    # determine how wide this column is going to be
+    def initialize_field_length(data)
+      # skip all this nonsense if we've been explicitly told what to do
+      if self.options[:field_length] and self.options[:field_length] > 0
+        self.field_length = self.options[:field_length]
+      else
+        self.field_length = self.name.length # it has to at least be long enough for the column header!
+
+        find_data_length(data, self.method, Time.now)
+      end
+
+      self.field_length = [self.field_length, self.max_field_length].min # never bigger than the max
+    end
+
+    # recurse through the data set using the method chain to find the longest field (or until time's up)
+    def find_data_length(data, method, start)
+      return if (Time.now - start) > 2
+      return if method.nil?
+      return if data.nil?
+      return if self.field_length >= self.max_field_length
+
+      wrap(data).each do |data_obj|
+        next_method = method.split(".").first
+
+        return unless data_obj.respond_to? next_method
+
+        if next_method == method  # done!
+          self.field_length = [self.field_length, data_obj.send(next_method).to_s.length].max
+        else  # keep going
+          find_data_length(data_obj.send(next_method), method[(next_method.length + 1)..-1], start)
+        end
+      end
+    end
+
+    # add the next level to the method_chain
+    def get_current_method(method_chain)
+      if self.method.start_with? method_chain
+        current_method = String.new(self.method)
+        current_method = current_method[method_chain.length, current_method.length]
+        current_method.split(".").detect { |m| m != "" }
+      end
+    end
   end
+
 end
 
 module Kernel
@@ -243,10 +339,101 @@ module Kernel
     start = Time.now
     table_print = TablePrint.new
     puts table_print.tp(data, options)
-    Time.now - start
+    Time.now - start # we have to return *something*, might as well be execution time.
   end
 
   module_function :tp
 end
 
+## Some nested classes to make development easier! Make sure you don't commit these uncommented.
+#
+#class TestClass
+#  attr_accessor :title, :name, :blogs, :locker
+#
+#  def initialize(title, name, blogs, locker)
+#    self.title = title
+#    self.name = name
+#    self.blogs = blogs
+#    self.locker = locker
+#  end
+#end
+#
+#class Blog
+#  attr_accessor :title, :summary
+#
+#  def initialize(title, summary)
+#    self.title = title
+#    self.summary = summary
+#  end
+#end
+#
+#class Locker
+#  attr_accessor :assets
+#
+#  def initialize(assets)
+#    self.assets = assets
+#  end
+#end
+#
+#class Asset
+#  attr_accessor :url, :caption
+#
+#  def initialize(url, caption)
+#    self.url = url
+#    self.caption = caption
+#  end
+#end
+#
+#stack = [
+#
+#      TestClass.new("one title", "one name", [
+#            Blog.new("one blog title1", "one blog sum1"),
+#            Blog.new("one blog title2", "one blog sum2"),
+#            Blog.new("one blog title3", "one blog sum3"),
+#      ],
+#                    Locker.new([
+#                                     Asset.new("one asset url1", "one asset cap1"),
+#                                     Asset.new("one asset url2", "one asset cap2"),
+#                                     Asset.new("one asset url3", "one asset cap3"),
+#                               ])
+#      ),
+#      TestClass.new("two title", "two name", [
+#            Blog.new("two blog title1", "two blog sum1"),
+#            Blog.new("two blog title2", "two blog sum2"),
+#            Blog.new("two blog title3", "two blog sum3"),
+#      ],
+#                    Locker.new([
+#                                     Asset.new("two asset url1", "two asset cap1"),
+#                                     Asset.new("two asset url2", "two asset cap2"),
+#                                     Asset.new("two asset url3", "two asset cap3"),
+#                               ])
+#      ),
+#      TestClass.new("three title", "three name", [
+#            Blog.new("three blog title1", "three blog sum1"),
+#            Blog.new("three blog title2", "three blog sum2"),
+#            Blog.new("three blog title3", "three blog sum3"),
+#      ],
+#                    Locker.new([
+#                                     Asset.new("three asset url1", "three asset cap1"),
+#                                     Asset.new("three asset url2", "three asset cap2"),
+#                                     Asset.new("three asset url3", "three asset cap3"),
+#                               ])
+#      ),
+#      TestClass.new("four title", "four name", [
+#            Blog.new("four blog title1", "four blog sum1"),
+#            Blog.new("four blog title2", "four blog sum2"),
+#            Blog.new("four blog title3", "four blog sum3"),
+#      ],
+#                    Locker.new([
+#                                     Asset.new("four asset url1", "four asset cap1"),
+#                                     Asset.new("four asset url2", "four asset cap2"),
+#                                     Asset.new("four asset url3", "four asset cap3"),
+#                               ])
+#      ),
+#]
+
+#tp stack, :include => ["blogs.title", "blogs.summary", "locker.assets.url", "locker.assets.caption"]
+
+
+
 

data/table_print.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{table_print}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Chris Doyle"]
-  s.date = %q{2011-04-17}
+  s.date = %q{2011-04-26}
   s.description = %q{TablePrint formats an object or array of objects into columns for easy reading. To do this, it assumes the objects in your array all respond to the same methods (vs pretty_print or awesome_print, who can't create columns because your objects could be entirely different).}
   s.email = %q{archslide@gmail.com}
   s.extra_rdoc_files = [

data/test/helper.rb

@@ -16,3 +16,41 @@ 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,10 +1,30 @@
 require 'helper'
 
 class TablePrint
-  class Column
+  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
 
@@ -12,15 +32,35 @@ class TestTablePrint < Test::Unit::TestCase
 
   # TODO: active record tests if defined?(ActiveRecord)
 
-  # Vaguely ordered from most to least granular
+  # 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::Column.new([], "to_s")
+        @column = TablePrint::ColumnHelper.new([], "to_s")
       end
       should 'remember the display method' do
-        assert_equal "to_s", @column.display_method
+        assert_equal "to_s", @column.method
       end
       should 'set the name' do
         assert_equal "to s", @column.name
@@ -30,18 +70,27 @@ class TestTablePrint < Test::Unit::TestCase
     context 'with options including' do
       context 'name' do
         setup do
-          @column = TablePrint::Column.new([], "first", {:name => "test_tube"})
+          @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::Column.new(["short"], "first", {:field_length => 20})
+            @column = TablePrint::ColumnHelper.new(["short"], "first", {:field_length => 20})
           end
 
           should 'set the field length according to the options' do
@@ -51,7 +100,7 @@ class TestTablePrint < Test::Unit::TestCase
 
         context 'that is less than 1' do
           setup do
-            @column = TablePrint::Column.new(["short"], "first", {:field_length => 0})
+            @column = TablePrint::ColumnHelper.new(["short"], "first", {:field_length => 0})
           end
 
           should 'ignore the field_length' do
@@ -61,7 +110,7 @@ class TestTablePrint < Test::Unit::TestCase
 
         context 'that is bigger than the max' do
           setup do
-            @column = TablePrint::Column.new(["short"], "first", {:field_length => 20, :max_field_length => 10})
+            @column = TablePrint::ColumnHelper.new(["short"], "first", {:field_length => 20, :max_field_length => 10})
           end
 
           should 'respect the max_field_length' do
@@ -72,64 +121,259 @@ class TestTablePrint < Test::Unit::TestCase
     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::Column.new([], "")._truncate("asdf")
+      assert_equal "asdf", TablePrint::ColumnHelper.new(["a long long long string"], "first")._truncate("asdf")
     end
 
     should 'truncate long strings with ellipses' do
-      assert_equal "123456789012345678901234567...", TablePrint::Column.new([], "")._truncate("1234567890123456789012345678901234567890")
+      # 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 'when given a max length in the options' do
+    context 'with a non-default field length' do
       should 'truncate long strings with ellipses' do
-        assert_equal "1234567...", TablePrint::Column.new([], "", :max_field_length => 10)._truncate("1234567890123456789012345678901234567890")
+        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 "1", TablePrint::Column.new([], "", :max_field_length => -10)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "1", TablePrint::Column.new([], "", :max_field_length => 0)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "1", TablePrint::Column.new([], "", :max_field_length => 1)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "12", TablePrint::Column.new([], "", :max_field_length => 2)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "123", TablePrint::Column.new([], "", :max_field_length => 3)._truncate("1234567890123456789012345678901234567890")
-        assert_equal "1...", TablePrint::Column.new([], "", :max_field_length => 4)._truncate("1234567890123456789012345678901234567890")
+        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::Column.new(["hello there"], "to_s").field_length
+      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::Column.new(["hello there"], "to_s", :max_field_length => 5).field_length
+        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::Column.new(["he"], "to_s", :max_field_length => 5).field_length
-        assert_equal 12, TablePrint::Column.new(["hello"], "to_s", :name => "foobar THIS!").field_length
+        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 column is boolean and the data is the limiting factor' do
-      should 'always be 5' do
-        assert_equal 5, TablePrint::Column.new([[true]], "first", :name => "dur").field_length
-        assert_equal 5, TablePrint::Column.new([[false]], "first", :name => "dur").field_length
+    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
 
-    context 'when the column is boolean and the data is not the limiting factor' do
-      should 'be the column name length' do
-        assert_equal 7, TablePrint::Column.new([[true]], "unshift").field_length
-        assert_equal 8, TablePrint::Column.new([[false]], "unshift", :name => "durables").field_length
+  # 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

@@ -28,6 +28,7 @@ class MyClass
   end
 end
 
+
 class TablePrint
   def _get_display_methods(data_obj, options)
     get_display_methods(data_obj, options)
@@ -37,8 +38,8 @@ class TablePrint
     get_default_display_methods(data_obj)
   end
 
-  def _clean_display_methods(data_obj, display_methods)
-    clean_display_methods(data_obj, display_methods)
+  def _sort_display_methods(display_methods)
+    sort_display_methods(display_methods)
   end
 end
 
@@ -93,19 +94,6 @@ class TestTablePrint < Test::Unit::TestCase
       end
     end
 
-    context 'The clean_display_methods function' do
-      should 'only give back valid methods' do
-        assert_equal [], @tp._clean_display_methods(ManyMethods.new, [""])
-        assert_equal [], @tp._clean_display_methods(ManyMethods.new, [nil])
-        assert_equal ["title"], @tp._clean_display_methods(ManyMethods.new, ["title"])
-        assert_equal ["title"], @tp._clean_display_methods(ManyMethods.new, [:title])
-        assert_equal ["title"], @tp._clean_display_methods(ManyMethods.new, ["title", "title"])
-        assert_equal ["title"], @tp._clean_display_methods(ManyMethods.new, ["title", :title])
-        assert_equal ["title"], @tp._clean_display_methods(ManyMethods.new, [:title, :title])
-        assert_equal ["title"], @tp._clean_display_methods(ManyMethods.new, ["title", "january1985"])
-      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)
@@ -171,3 +159,4 @@ class TestTablePrint < Test::Unit::TestCase
     end
   end
 end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: table_print
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Chris Doyle
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-17 00:00:00 -07:00
+date: 2011-04-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency