xls 0.1.0 → 0.1.1

data/bin/xls

@@ -11,7 +11,41 @@ program :description, 'A command line utility for working with data in Excel.'
 
 
 ################################################################################
-# Processing
+#
+# Enumeration
+#
+################################################################################
+
+command :"enumerate" do |c|
+  c.syntax = 'xls enumerate FILE'
+  c.description = 'Executes Ruby code on each cell of a workbook.'
+  c.option('--selection SELECTION', 'The Excel style selection to work within.')
+  c.option('-e CODE', 'The code to execute for each cell.')
+  c.when_called do|args, options|
+    # Open input file.
+    abort("Input file required") if args.length == 0
+    workbook = Spreadsheet.open(args.first)
+
+    # Convert Ruby source to procs.
+    abort("Enumerator code required") if options.e.nil?
+    procs = options.e.is_a?(String) ? [options.e] : options.e
+    procs.map! {|source| eval("lambda { |cell, col_index, row_index| #{source} }")}
+    
+    # Run enumerator.
+    enumerator = Xls::Enumerator.new()
+    enumerator.selection = Xls::Selection.parse(options.selection.upcase) unless options.selection.nil?
+    enumerator.procs = procs
+    enumerator.process(workbook)
+  end
+end
+
+
+
+
+################################################################################
+#
+# Transformation
+#
 ################################################################################
 
 command :columnize do |c|
@@ -21,15 +55,16 @@ command :columnize do |c|
   c.option('--fixed-columns COLUMNS', 'The columns that should stay fixed.')
   c.when_called do|args, options|
     # Open input file.
+    abort("Output file required") if options.output.nil?
     abort("Input file required") if args.length == 0
-    workbook = Spreadsheet.open(args.first)
+    input = Spreadsheet.open(args.first)
     
     # Run columnizer.
     columnizer = Xls::Columnizer.new()
     columnizer.fixed_columns = options.fixed_columns.to_s.split(",")
-    columnizer.execute(workbook)
+    output = columnizer.process(input)
     
-    # Write output.
-    workbook.write(options.output || $stdout)
+    # Write output to file.
+    output.write(options.output)
   end
 end

data/lib/xls.rb

@@ -1,6 +1,9 @@
 require 'spreadsheet'
+require 'tempfile'
 
 require 'xls/columnizer'
+require 'xls/enumerator'
+require 'xls/selection'
 require 'xls/version'
 
 class Xls

data/lib/xls/enumerator.rb

@@ -0,0 +1,61 @@
+class Xls
+  class Enumerator
+    ############################################################################
+    #
+    # Constructor
+    #
+    ############################################################################
+
+    def initialize(options={})
+      self.selection = options[:selection]
+      self.procs = options[:procs] || []
+    end
+
+
+    ############################################################################
+    #
+    # Attributes
+    #
+    ############################################################################
+
+    # The selection to enumerate over.
+    attr_accessor :selection
+    
+    # A list of procs to run on each cell.
+    attr_accessor :procs
+    
+
+    ############################################################################
+    #
+    # Methods
+    #
+    ############################################################################
+    
+    # Executes a set of procs on each cell in a selection.
+    #
+    # @param [Workbook]  input The input workbook.
+    def process(input)
+      # Loop over each worksheet.
+      (0...input.sheet_count).each do |sheet_index|
+        sheet = input.worksheet(sheet_index)
+        
+        # Loop over each row.
+        sheet.each do |row|
+          next unless selection.nil? || selection.rows.nil? || selection.rows.cover?(row.idx)
+          
+          # Loop over each cell.
+          row.each_with_index do |cell, col_index|
+            next unless selection.nil? || selection.columns.nil? || selection.columns.cover?(col_index)
+            
+            # Run each proc.
+            procs.each do |proc|
+              proc.call(cell.to_s, col_index, row.idx)
+            end
+          end
+        end
+      end
+      
+      return nil
+    end
+  end
+end

data/lib/xls/selection.rb

@@ -0,0 +1,99 @@
+class Xls
+  class Selection
+    ############################################################################
+    #
+    # Error Classes
+    #
+    ############################################################################
+
+    class SelectionFormatError < StandardError; end
+
+
+    ############################################################################
+    #
+    # Static Methods
+    #
+    ############################################################################
+
+    # Parses an Excel style [COLUMN][ROW]:[COLUMN][ROW] format into a
+    # selection.
+    #
+    # @param [String]  str The Excel-style selection.
+    #
+    # @return [Selection]  A selection object.
+    def self.parse(str)
+      m, tl_col, tl_row, br_col, br_row = *str.to_s.match(/^([A-Z]+)?(\d+)?(?::([A-Z]+)?(\d+)?)?$/)
+      raise SelectionFormatError.new("Invalid selection: #{str}") if m.nil?
+      
+      # Default bottom-right for single cell selection.
+      br_col = tl_col if br_col.nil?
+      br_row = tl_row if br_row.nil?
+      
+      # Convert column letters to numbers.
+      columns = nil
+      if !tl_col.nil? && !br_col.nil?
+        tl_col = col_to_index(tl_col)
+        br_col = col_to_index(br_col)
+        tl_col, br_col = [tl_col, br_col].min, [tl_col, br_col].max
+        columns = (tl_col..br_col)
+      end
+      
+      # Convert rows to zero-based indices.
+      rows = nil
+      if !tl_row.nil? && !br_row.nil?
+        tl_row = tl_row.to_i - 1
+        br_row = br_row.to_i - 1
+        tl_row, br_row = [tl_row, br_row].min, [tl_row, br_row].max
+        rows = (tl_row..br_row)
+      end
+      
+      # Return a selection object.
+      return Xls::Selection.new(columns, rows)
+    end
+
+    # Converts column letters to integer indices.
+    def self.col_to_index(letters)
+      value = 0
+      letters.upcase.split('').each_with_index do |letter, index|
+        value = value + ((letter.ord - "A".ord) * (26 ** index))
+      end
+      return value
+    end
+    
+
+    ############################################################################
+    #
+    # Constructor
+    #
+    ############################################################################
+
+    def initialize(columns, rows)
+      self.columns = columns
+      self.rows = rows
+    end
+
+
+    ############################################################################
+    #
+    # Attributes
+    #
+    ############################################################################
+
+    # A range of row indices that the selection covers.
+    attr_accessor :rows
+
+    # A range of column indices that the selection covers.
+    attr_accessor :columns
+    
+    # An array of indicies (top-level column, top-left row, bottom-right
+    # column, bottom-right row).
+    def indices
+      return [
+        columns.nil? ? nil : columns.begin,
+        rows.nil? ? nil : rows.begin,
+        columns.nil? ? nil : columns.end,
+        rows.nil? ? nil : rows.end
+      ]
+    end
+  end
+end

data/lib/xls/version.rb

@@ -1,3 +1,3 @@
 class Xls
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/test/enumerator_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class TestEnumerator < MiniTest::Unit::TestCase
+  def setup
+    @enumerator = Xls::Enumerator.new
+  end
+  
+  ######################################
+  # Execute
+  ######################################
+  
+  def test_enumerate
+    my_arr = []
+    input = Spreadsheet.open('fixtures/enumerator/basic.xls')
+    @enumerator.procs = [
+      lambda {|cell, col, row| my_arr << cell.to_s},
+      lambda {|cell, col, row| my_arr << '0'},
+    ]
+    @enumerator.process(input)
+    assert_equal ["a", "0", "b", "0", "c", "0", "d", "0", "e", "0", "f", "0", "g", "0", "h", "0", "i", "0"], my_arr
+  end
+
+  def test_enumerate_with_selection
+    my_arr = []
+    input = Spreadsheet.open('fixtures/enumerator/basic.xls')
+    @enumerator.procs = [lambda {|cell, col, row| my_arr << cell.to_s}]
+    @enumerator.selection = Xls::Selection.parse("B2:C3")
+    @enumerator.process(input)
+    assert_equal ['e', 'f', 'h', 'i'], my_arr
+  end
+end

data/test/selection_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class TestSelection < MiniTest::Unit::TestCase
+  ######################################
+  # Parsing
+  ######################################
+  
+  def test_parse_top_left_cell
+    assert_equal [0, 0, 0, 0], Xls::Selection.parse("A1").indices
+    assert_equal [0, 0, 0, 0], Xls::Selection.parse("A1:A1").indices
+  end
+
+  def test_parse_single_cell
+    assert_equal [2, 7, 2, 7], Xls::Selection.parse("C8").indices
+  end
+
+  def test_parse_range
+    assert_equal [2, 7, 4, 9], Xls::Selection.parse("C8:E10").indices
+  end
+
+  def test_parse_inverse_range
+    assert_equal [2, 7, 4, 9], Xls::Selection.parse("E10:C8").indices
+    assert_equal [2, 7, 4, 9], Xls::Selection.parse("C10:E8").indices
+  end
+
+  def test_parse_columns_only
+    assert_equal [2, nil, 2, nil], Xls::Selection.parse("C").indices
+    assert_equal [2, nil, 4, nil], Xls::Selection.parse("C:E").indices
+  end
+
+  def test_parse_rows_only
+    assert_equal [nil, 2, nil, 2], Xls::Selection.parse("3").indices
+    assert_equal [nil, 4, nil, 7], Xls::Selection.parse("5:8").indices
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xls
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -132,10 +132,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/xls/columnizer.rb
+- lib/xls/enumerator.rb
+- lib/xls/selection.rb
 - lib/xls/version.rb
 - lib/xls.rb
 - README.md
 - test/columnizer_test.rb
+- test/enumerator_test.rb
+- test/selection_test.rb
 - test/test_helper.rb
 - bin/xls
 homepage: http://github.com/benbjohnson/xls
@@ -164,4 +168,6 @@ specification_version: 3
 summary: A command line utilty for working with data in Excel.
 test_files:
 - test/columnizer_test.rb
+- test/enumerator_test.rb
+- test/selection_test.rb
 - test/test_helper.rb