table_print 0.2.3 → 1.0.0.rc3

data/features/support/step_definitions/before.rb

@@ -0,0 +1,3 @@
+Before do
+  Sandbox.cleanup!
+end

data/features/support/step_definitions/steps.rb

@@ -0,0 +1,77 @@
+require 'cat'
+require 'ostruct'
+require 'table_print'
+
+Given /^a class named (.*)$/ do |klass|
+  Sandbox.add_class(klass)
+end
+
+Given /^(.*) has attributes (.*)$/ do |klass, attributes|
+  attrs = attributes.split(",").map { |attr| attr.strip }
+
+  Sandbox.add_attributes(klass, *attrs)
+end
+
+Given /^(.*) has a class method named (.*) with (.*)$/ do |klass, method_name, blk|
+  Sandbox.add_class_method(klass, method_name, &eval(blk))
+end
+
+Given /^(.*) has a method named (\w*) with (.*)$/ do |klass, method_name, blk|
+  Sandbox.add_method(klass, method_name, &eval(blk))
+end
+
+When /^I instantiate a (.*) with (\{.*\})$/ do |klass, args|
+  @objs ||= OpenStruct.new
+  @objs.send("#{klass.downcase}=", Sandbox.const_get_from_string(klass).new(eval(args)))
+end
+
+When /^I instantiate a (.*) with (\{.*\}) and (add it|assign it) to (.*)$/ do |klass, args, assignment_method, target|
+  # the thing we're instantiating
+  child = Sandbox.const_get_from_string(klass).new(eval(args))
+
+  # the place we're going to add it
+  method_chain = target.split(".")
+  target_method = method_chain.pop
+  target_object = method_chain.inject(@objs) { |obj, method_name| obj.send(method_name) }
+
+  # how we're going to add it
+  if assignment_method == "assign it"
+    target_object.send("#{target_method}=", child)
+  else
+    target_object.send("#{target_method}") << child
+  end
+end
+
+When /^configure (.*) with (.*)$/ do |klass, config|
+  klass = Sandbox.const_get_from_string(klass)
+  TablePrint::Config.set(klass, eval(config))
+end
+
+When /table_print ([\w:]*), (.*)$/ do |klass, options|
+  tp(@objs.send(klass.downcase), eval(options))
+end
+
+When /table_print ([\w\.:]*)$/ do |klass|
+  obj = @objs.send(klass.split(".").first.downcase)
+  obj = obj.send(klass.split(".").last) if klass.include? "."  # hack - we're assuming only two levels. use inject to find the target.
+  
+  tp(obj)
+end
+
+Then /^the output should contain$/ do |string|
+  output = []
+  while line = @r.gets
+    output << line
+  end
+  @r.close
+
+  output.zip(string.split("\n")).each do |actual, expected|
+    actual.gsub(/\s/m, "").split(//).sort.join.should == expected.gsub(" ", "").split(//).sort.join
+  end
+end
+
+def tp(data, options={})
+  @r, w = IO.pipe
+  w.puts TablePrint::Printer.table_print(data, options)
+  w.close
+end

data/lib/cattr.rb

@@ -0,0 +1,46 @@
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/column.rb

@@ -0,0 +1,45 @@
+module TablePrint
+  class Column
+    attr_reader :formatters
+    attr_writer :width
+    attr_accessor :name, :data, :time_format
+
+    def initialize(attr_hash={})
+      @formatters = []
+      attr_hash.each do |k, v|
+        self.send("#{k}=", v)
+      end
+    end
+
+    def name=(n)
+      @name = n.to_s
+    end
+
+    def formatters=(formatter_list)
+      formatter_list.each do |f|
+        add_formatter(f)
+      end
+    end
+
+    def display_method=(method)
+      method = method.to_s unless method.is_a? Proc
+      @display_method = method
+    end
+
+    def display_method
+      @display_method ||= name
+    end
+
+    def add_formatter(formatter)
+      @formatters << formatter
+    end
+
+    def data_width
+      [name.length].concat(data.compact.collect(&:to_s).collect(&:length)).max
+    end
+
+    def width
+      @width ||= data_width
+    end
+  end
+end

data/lib/config.rb

@@ -0,0 +1,36 @@
+require 'cattr'
+
+module TablePrint
+  class Config
+    cattr_accessor :max_width, :time_format
+
+    DEFAULT_MAX_WIDTH = 30
+    DEFAULT_TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+    @@max_width = DEFAULT_MAX_WIDTH
+    @@time_format = DEFAULT_TIME_FORMAT
+
+    @@klasses = {}
+
+    def self.set(klass, val)
+      if klass.is_a? Class
+        @@klasses[klass] = val  # val is a hash of column options
+      else
+        TablePrint::Config.send("#{klass}=", val.first)
+      end
+    end
+
+    def self.for(klass)
+      @@klasses.fetch(klass) {}
+    end
+
+    def self.clear(klass)
+      if klass.is_a? Class
+        @@klasses.delete(klass)
+      else
+        original_value = TablePrint::Config.const_get("DEFAULT_#{klass.to_s.upcase}")
+        TablePrint::Config.send("#{klass}=", original_value)
+      end
+    end
+  end
+end

data/lib/config_resolver.rb

@@ -0,0 +1,91 @@
+require 'column'
+require 'config'
+
+module TablePrint
+  class ConfigResolver
+    def initialize(klass, default_column_names, *options)
+      @column_hash = {}
+
+      @default_columns = default_column_names.collect { |name| option_to_column(name) }
+
+      @included_columns = []
+      @excepted_columns = []
+      @only_columns = []
+
+      process_option_set(TablePrint::Config.for(klass))
+      process_option_set(options)
+    end
+
+    def process_option_set(options)
+
+      options = [options].flatten
+      options.delete_if { |o| o == {} }
+
+      # process special symbols
+
+      @included_columns.concat [get_and_remove(options, :include)].flatten
+      @included_columns.map! do |option|
+        if option.is_a? Column
+          option if option.is_a? Column
+        else
+          option_to_column(option)
+        end
+      end
+
+      @included_columns.each do |c|
+        @column_hash[c.name] = c
+      end
+
+      # excepted columns don't need column objects since we're just going to throw them out anyway
+      @excepted_columns.concat [get_and_remove(options, :except)].flatten
+
+      # anything that isn't recognized as a special option is assumed to be a column name
+      options.compact!
+      @only_columns = options.collect { |name| option_to_column(name) } unless options.empty?
+    end
+
+    def get_and_remove(options_array, key)
+      except = options_array.select do |option|
+        option.is_a? Hash and option.keys.include? key
+      end
+
+      return [] if except.empty?
+      except = except.first
+
+      option_of_interest = except.fetch(key)
+      except.delete(key)
+
+      options_array.delete(except) if except.keys.empty?  # if we've taken all the info from this option, get rid of it
+
+      option_of_interest
+    end
+
+    def option_to_column(option)
+      if option.is_a? Hash
+        name = option.keys.first
+        if option[name].is_a? Proc
+          option = {:name => name, :display_method => option[name]}
+        else
+          option = option[name].merge(:name => name)
+        end
+      else
+        option = {:name => option}
+      end
+      c = Column.new(option)
+      @column_hash[c.name] = c
+      c
+    end
+    
+    def usable_column_names
+      base = @default_columns
+      base = @only_columns unless @only_columns.empty?
+      Array(base).collect(&:name) + Array(@included_columns).collect(&:name) - Array(@excepted_columns).collect(&:to_s)
+    end
+
+    def columns
+      usable_column_names.collect do |name|
+        @column_hash[name]
+      end
+    end
+  end
+end

data/lib/fingerprinter.rb

@@ -0,0 +1,85 @@
+require 'row_group'
+require 'hash_extensions'
+
+module TablePrint
+  class Fingerprinter
+    def lift(columns, object)
+      @column_names_by_display_method = {}
+      columns.each { |c| @column_names_by_display_method[c.display_method] = c.name }
+
+      column_hash = display_methods_to_nested_hash(columns.collect(&:display_method))
+
+      hash_to_rows("", column_hash, object)
+    end
+
+    def hash_to_rows(prefix, hash, objects)
+      rows = []
+
+      # convert each object into its own row
+      Array(objects).each do |target|
+        row = populate_row(prefix, hash, target)
+        rows << row
+
+        # make a group and recurse for the columns we don't handle
+        groups = create_child_group(prefix, hash, target)
+        row.add_children(groups) unless groups.all? {|g| g.children.empty?}
+      end
+
+      rows
+    end
+
+    def populate_row(prefix, hash, target)
+      row = TablePrint::Row.new()
+
+      # populate a row with the columns we handle
+      cells = {}
+      handleable_columns(hash).each do |method|
+        display_method = (prefix == "" ? method : "#{prefix}.#{method}")
+        cell_value = method.call(target) if method.is_a? Proc
+        cell_value ||= target.send(method)
+        cells[@column_names_by_display_method[display_method]] = cell_value
+      end
+
+      row.set_cell_values(cells)
+    end
+
+    def create_child_group(prefix, hash, target)
+      passable_columns(hash).collect do |name|
+        recursing_prefix = "#{prefix}#{'.' unless prefix == ''}#{name}"
+        group = RowGroup.new
+        group.add_children hash_to_rows(recursing_prefix, hash[name], target.send(name))
+        group
+      end
+    end
+
+    def handleable_columns(hash)
+      # get the keys where the value is an empty hash
+      hash.select { |k, v| v == {} }.collect { |k, v| k }
+    end
+
+    def passable_columns(hash)
+      # get the keys where the value is not an empty hash
+      hash.select { |k, v| v != {} }.collect { |k, v| k }
+    end
+
+    def display_methods_to_nested_hash(display_methods)
+      extended_hash = {}.extend TablePrint::HashExtensions::ConstructiveMerge
+
+      # turn each column chain into a nested hash and add it to the output
+      display_methods.inject(extended_hash) do |hash, display_method|
+        hash.constructive_merge!(display_method_to_nested_hash(display_method))
+      end
+    end
+
+    def display_method_to_nested_hash(display_method)
+      hash = {}
+
+      return {display_method => {}} if display_method.is_a? Proc
+
+      display_method.split(".").inject(hash) do |hash_level, method|
+        hash_level[method] ||= {}
+      end
+      hash
+    end
+  end
+end

data/lib/formatter.rb

@@ -0,0 +1,45 @@
+require 'config'
+
+module TablePrint
+  class TimeFormatter
+    def initialize(time_format=nil)
+      @format = time_format
+      @format ||= TablePrint::Config.time_format
+    end
+
+    def format(value)
+      return value unless value.is_a? Time
+      value.strftime @format
+    end
+  end
+
+  class NoNewlineFormatter
+    def format(value)
+      value.to_s.gsub(/\r\n/, "\n").gsub(/\n/, " ")
+    end
+  end
+
+  class FixedWidthFormatter
+    def initialize(width)
+      @width = width
+    end
+
+    def format(value)
+      "%-#{width}s" % truncate(value)
+    end
+
+    def width
+      [@width, TablePrint::Config.max_width].min
+    end
+
+    private
+    def truncate(value)
+      return "" unless value
+
+      value = value.to_s
+      return value unless value.length > width
+
+      "#{value[0..width-4]}..."
+    end
+  end
+end

data/lib/hash_extensions.rb

@@ -0,0 +1,37 @@
+module TablePrint
+  module HashExtensions
+    module ConstructiveMerge
+      def constructive_merge(hash)
+        target = dup
+
+        hash.keys.each do |key|
+          if hash[key].is_a? Hash and self[key].is_a? Hash
+            target[key].extend ConstructiveMerge
+            target[key] = target[key].constructive_merge(hash[key])
+            next
+          end
+
+          target[key] = hash[key]
+        end
+
+        target
+      end
+
+      def constructive_merge!(hash)
+        target = self
+
+        hash.keys.each do |key|
+          if hash[key].is_a? Hash and self[key].is_a? Hash
+            target[key].extend ConstructiveMerge
+            target[key] = target[key].constructive_merge(hash[key])
+            next
+          end
+
+          target[key] = hash[key]
+        end
+
+        target
+      end
+    end
+  end
+end