tabular 0.0.7 → 0.2.0

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "ruby-ole", :git => "git://github.com/scottwillson/ruby-ole.git"
+gem "spreadsheet", :git => "git://github.com/scottwillson/spreadsheet.git"
+gem "jeweler"

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GIT
+  remote: git://github.com/scottwillson/ruby-ole.git
+  revision: 6b9d2530b12259ca21af75ed2dcb26ba745a6115
+  specs:
+    ruby-ole (1.2.11.3)
+
+GIT
+  remote: git://github.com/scottwillson/spreadsheet.git
+  revision: e5d97bc43f3db66600a70ace5de638f41a4a700b
+  specs:
+    spreadsheet (0.6.6)
+      ruby-ole
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.7)
+    rake (10.0.4)
+    rdoc (4.0.1)
+      json (~> 1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  ruby-ole!
+  spreadsheet!

data/Rakefile

@@ -23,11 +23,9 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-task :test => :check_dependencies
-
 task :default => :test
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""
 

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.2.0

data/lib/tabular.rb

@@ -2,9 +2,13 @@ require "rubygems"
 
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")
 
-require "tabular/column.rb"
-require "tabular/columns.rb"
-require "tabular/row.rb"
-require "tabular/table.rb"
+require "tabular/keys"
+
+require "tabular/column"
+require "tabular/columns"
+require "tabular/renderer"
+require "tabular/row"
+require "tabular/table"
 
 require "tabular/support/object"
+require "tabular/support/zero"

data/lib/tabular/column.rb

@@ -1,12 +1,15 @@
 module Tabular
   class Column
     attr_reader :key, :column_type
-    
-    def initialize(key = nil, columns_map = {})
+
+    def initialize(table, columns, key = nil, columns_map = {})
+      @columns = columns
+      @table = table
+
       key = symbolize(key)
       columns_map = columns_map || {}
       map_for_key = columns_map[key]
-    
+
       @column_type = :string
       case map_for_key
       when nil
@@ -17,7 +20,7 @@ module Tabular
         @column_type = :date if key == :date
       when Hash
         @key = key
-        @column_type = map_for_key[:column_type] 
+        @column_type = map_for_key[:column_type]
       else
         raise "Expected Symbol or Hash, but was #{map_for_key.class}"
       end
@@ -25,7 +28,7 @@ module Tabular
 
     def symbolize(key)
       return nil if key.blank?
-      
+
       begin
         key.to_s.strip.gsub(/::/, '/').
           gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
@@ -38,13 +41,37 @@ module Tabular
         nil
       end
     end
-    
+
+    def rows
+      @table.rows
+    end
+
+    def cells
+      rows.map { |r| r[key] }
+    end
+
+    def max
+      cells.compact.max
+    end
+
+    def precision
+      @precision || cells.map(&:to_f).map {|n| n.round(3) }.map {|n| n.to_s.split(".").last.gsub(/0+$/, "").length }.max
+    end
+
+    def render
+      renderer.render_header self
+    end
+
+    def renderer
+      @columns.renderer(key)
+    end
+
     def inspect
       "#<Tabular::Column #{key} #{column_type}>"
     end
-    
+
     def to_s
-      key
+      key.to_s
     end
   end
 end

data/lib/tabular/columns.rb

@@ -2,18 +2,22 @@ module Tabular
   # The Table's header: a list of Columns.
   class Columns
     include Enumerable
-    
+    include Tabular::Keys
+
+    attr_accessor :renderer
+
     # +data+ -- array of header names
     # +columns_map+ -- see Table. Maps column names and type conversion.
-    def initialize(data, columns_map = {})
+    def initialize(table, names, columns_map = {})
+      @table = table
       columns_map ||= {}
       @columns_map = normalize_columns_map(columns_map)
       @column_indexes = {}
       @columns_by_key = {}
       index = 0
       @columns = nil
-      @columns = data.map do |column|
-        new_column = Tabular::Column.new(column, @columns_map)
+      @columns = names.map do |column|
+        new_column = Tabular::Column.new(table, self, column, @columns_map)
         unless new_column.key.blank?
           @column_indexes[new_column.key] = index
           @columns_by_key[new_column.key] = new_column
@@ -22,50 +26,76 @@ module Tabular
         new_column
       end
     end
-    
+
     # Is the a Column with this key? Keys are lower-case, underscore symbols.
     # Example: :postal_code
     def has_key?(key)
       @columns.any? { |column| column.key == key }
     end
-    
+
     # Column for +key+
     def [](key)
-      @columns_by_key[key]
+      @columns_by_key[key_to_sym(key)]
     end
-    
+
     # Zero-based index of Column for +key+
     def index(key)
       @column_indexes[key]
     end
-    
+
     # Call +block+ for each Column
     def each(&block)
       @columns.each(&block)
     end
-    
+
     # Add a new Column with +key+
     def <<(key)
-      column = Column.new(key, @columns_map)
-      unless column.key.blank?
+      column = Column.new(@table, self, key, @columns_map)
+      unless column.key.blank? || has_key?(key)
         @column_indexes[column.key] = @columns.size
         @column_indexes[@columns.size] = column
         @columns_by_key[column.key] = column
+        @columns << column
       end
-      @columns << column
     end
-    
-    
-    private 
-    
+
+    def delete(key)
+      @columns.delete_if { |column| column.key == key }
+      @columns_by_key.delete key
+      @column_indexes.delete key
+
+      @columns.each.with_index do |column, index|
+        @column_indexes[column.key] = index
+      end
+    end
+
+    def size
+      @columns.size
+    end
+
+    def max
+      cells.compact.max
+    end
+
+    def renderer(key)
+      renderers[key] || @renderer || Renderer
+    end
+
+    def renderers
+      @renderers ||= {}
+    end
+
+
+    private
+
     def normalize_columns_map(columns_map)
       normalized_columns_map = {}
       columns_map.each do |key, value|
         case value
         when Hash, Symbol
-          normalized_columns_map[key.to_sym] = value
+          normalized_columns_map[key_to_sym(key)] = value
         else
-          normalized_columns_map[key.to_sym] = value.to_sym
+          normalized_columns_map[key_to_sym(key)] = value.to_sym
         end
       end
       normalized_columns_map

data/lib/tabular/keys.rb

@@ -0,0 +1,14 @@
+module Tabular
+  module Keys
+    def key_to_sym(key)
+      _key = case key
+      when Column
+        key.key
+      when String
+        key.to_sym
+      else
+        key
+      end
+    end
+  end
+end

data/lib/tabular/renderer.rb

@@ -0,0 +1,11 @@
+module Tabular
+  class Renderer
+    def self.render(column, row)
+      row[column.key]
+    end
+
+    def self.render_header(column)
+      column.to_s
+    end
+  end
+end

data/lib/tabular/row.rb

@@ -4,23 +4,37 @@ module Tabular
   # Associate list of cells. Each Table has a list of Rows. Access Row cells via symbols. Ex: row[:city]
   class Row
     include Enumerable
-    
+    include Tabular::Keys
+
     attr_reader :index
-    
+    attr_reader :source
+
     # +table+ -- Table
-    # +cell+ -- array (not neccessarily Strings)
-    def initialize(table, cells = [])
+    # +cells+ -- array (not neccessarily Strings)
+    # +source+ -- original data before mapped to Hash or Array (optional)
+    def initialize(table, cells = [], source = nil)
       @table = table
-      @array = cells
-      @hash = nil
+      @source = source || cells
+
+      if cells.respond_to?(:keys)
+        @array = cells.values
+        @hash = {}
+        cells.each do |key, value|
+          @hash[key_to_sym(key)] = value
+        end
+      else
+        @array = cells
+        @hash = nil
+      end
+
       @index = table.rows.size
     end
-    
+
     # Cell value by symbol. E.g., row[:phone_number]
     def [](key)
       hash[key]
     end
-    
+
     # Set cell value. Adds cell to end of Row and adds new Column if there is no Column for +key_
     def []=(key, value)
       if columns.has_key?(key)
@@ -31,42 +45,61 @@ module Tabular
       end
       hash[key] = value
     end
-    
+
     # Call +block+ for each cell
     def each(&block)
       @array.each(&block)
     end
 
+    # Call +block+ for each cell
+    def each_with_key(&block)
+      hash.each(&block)
+    end
+    
+    def keys
+      hash.keys
+    end
+
     # For pretty-printing cell values
     def join(sep = nil)
       @array.join(sep)
     end
-    
+
+    def delete(key)
+      @array.delete key
+      hash.delete key
+    end
+
     def previous
       if index > 0
         @table.rows[index - 1]
       end
     end
-    
+
     def columns
       @table.columns
     end
-    
+
+    def render(key)
+      column = columns[key]
+      column.renderer.render column, self
+    end
+
     def to_hash
       hash.dup
     end
-    
+
     def inspect
       hash.inspect
     end
-    
+
     def to_s
       @array.join(", ").to_s
     end
 
 
     protected
-    
+
     def hash #:nodoc:
       unless @hash
         @hash = Hash.new
@@ -103,14 +136,14 @@ module Tabular
       end
       @hash
     end
-    
-    
+
+
     private
-    
+
     # Handle common m/d/yy case that Date.parse dislikes
     def parse_invalid_date(value)
       return unless value
-      
+
       parts = value.split("/")
       return unless parts.size == 3
 
@@ -128,7 +161,7 @@ module Tabular
       elsif year < 1900 || year > 2050
         return nil
       end
-      
+
       Date.new(year, month, day)
     end
   end

data/lib/tabular/support/zero.rb

@@ -0,0 +1,29 @@
+class Object
+  def zero?
+    false
+  end
+end
+
+class NilClass #:nodoc:
+  def zero?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  def zero?
+    false
+  end
+end
+
+class TrueClass #:nodoc:
+  def zero?
+    false
+  end
+end
+
+class String #:nodoc:
+  def zero?
+    self == "0" || self[/^0+\.0+$/]
+  end
+end