xls 0.1.1 → 0.1.2

data/bin/xls

@@ -16,29 +16,38 @@ program :description, 'A command line utility for working with data in Excel.'
 #
 ################################################################################
 
-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)
+def build_enumerator_command(action, description)
+  command action do |c|
+    c.syntax = "xls #{action.to_s} FILE"
+    c.description = description
+    c.option('-s SELECTION', 'The Excel style selection to work within.')
+    c.option('-e CODE', 'The code to execute for each cell.')
+    c.option('--use-headers', 'Whether to use the first row as a header row.')
+    c.option('--output FILE', 'The path to the output file.') unless action == :each
+    c.when_called do|args, options|
+      abort("Input file required") if args.length == 0
+      abort("Output file required") if action != :each && options.e.nil?
+      abort("Execution code required") if options.e.nil?
 
-    # 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)
+      # Run enumerator.
+      workbook = Spreadsheet.open(args.first)
+      enumerator = Xls::Enumerator.new()
+      enumerator.action = action
+      enumerator.use_headers = options.use_headers
+      enumerator.selection = Xls::Selection.parse(options.s.upcase) unless options.s.nil?
+      enumerator.proc = options.e
+      enumerator.process(workbook)
+
+      # Write output to file.
+      workbook.write(options.output) if action != :each
+    end
   end
 end
 
+build_enumerator_command(:each, 'Executes Ruby code on each cell of a workbook.')
+build_enumerator_command(:map, 'Maps output of Ruby code on each cell.')
+build_enumerator_command(:select, 'Keeps each cell where the code evaluates true.')
+build_enumerator_command(:reject, 'Keeps each cell where the code evaluates false.')
 
 
 
@@ -50,7 +59,7 @@ end
 
 command :columnize do |c|
   c.syntax = 'xls columnize FILE'
-  c.description = 'Converts a worksheet formatted as table into 2-column rows using header/value.'
+  c.description = 'Converts table into 2-column rows table.'
   c.option('--output FILE', 'The path to the output file.')
   c.option('--fixed-columns COLUMNS', 'The columns that should stay fixed.')
   c.when_called do|args, options|

data/lib/xls/enumerator.rb

@@ -8,7 +8,7 @@ class Xls
 
     def initialize(options={})
       self.selection = options[:selection]
-      self.procs = options[:procs] || []
+      self.proc = options[:proc]
     end
 
 
@@ -18,12 +18,18 @@ class Xls
     #
     ############################################################################
 
+    # The action to perform on each cell of data (:none, :map, :select, :reject).
+    attr_accessor :action
+
     # The selection to enumerate over.
     attr_accessor :selection
     
-    # A list of procs to run on each cell.
-    attr_accessor :procs
-    
+    # The proc to run on each cell.
+    attr_accessor :proc
+
+    # A flag stating if headers should be used.
+    attr_accessor :use_headers
+
 
     ############################################################################
     #
@@ -31,25 +37,32 @@ class Xls
     #
     ############################################################################
     
-    # Executes a set of procs on each cell in a selection.
+    # Executes a proc 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)
+        headers = sheet.row(0)
         
         # Loop over each row.
-        sheet.each do |row|
+        sheet.each(use_headers ? 1 : 0) 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)
+            # Run proc and retrieve the results.
+            header = (use_headers ? headers[col_index].to_s : '')
+            result = cell_binding(cell.to_s, col_index, row.idx, header).eval(proc)
+            
+            # Perform an action if one is specified.
+            case action
+            when :map then row[col_index] = result.to_s
+            when :select then row[col_index] = '' unless result
+            when :reject then row[col_index] = '' if result
             end
           end
         end
@@ -57,5 +70,15 @@ class Xls
       
       return nil
     end
+    
+    
+    ####################################
+    # Bindings
+    ####################################
+
+    # Returns the context in which cell procs are run.
+    def cell_binding(text, col, row, header)
+      return binding
+    end
   end
 end

data/lib/xls/version.rb

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

data/test/enumerator_test.rb

@@ -9,23 +9,42 @@ class TestEnumerator < MiniTest::Unit::TestCase
   # 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
+  def test_map_enumerate
+    workbook = Spreadsheet.open('fixtures/enumerator/basic.xls')
+    @enumerator.action = :map
+    @enumerator.proc = "text.to_s + '!'"
+    @enumerator.process(workbook)
+    assert_worksheet [
+      ['a!', 'b!', 'c!'],
+      ['d!', 'e!', 'f!'],
+      ['g!', 'h!', 'i!'],
+      ],
+      workbook.worksheet(0)
   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
+  def test_select_enumerate
+    workbook = Spreadsheet.open('fixtures/enumerator/basic.xls')
+    @enumerator.action = :select
+    @enumerator.proc = "text.to_s.ord % 2 == 0"
+    @enumerator.process(workbook)
+    assert_worksheet [
+      ['', 'b', ''],
+      ['d', '', 'f'],
+      ['', 'h', ''],
+      ],
+      workbook.worksheet(0)
+  end
+
+  def test_reject_enumerate
+    workbook = Spreadsheet.open('fixtures/enumerator/basic.xls')
+    @enumerator.action = :reject
+    @enumerator.proc = "text.to_s.ord % 2 == 0"
+    @enumerator.process(workbook)
+    assert_worksheet [
+      ['a', '', 'c'],
+      ['', 'e', ''],
+      ['g', '', 'i'],
+      ],
+      workbook.worksheet(0)
   end
 end

data/test/test_helper.rb

@@ -10,8 +10,8 @@ class MiniTest::Unit::TestCase
     worksheet.each do |row|
       act << row.map {|cell| cell.to_s.strip }
     end
-    exp = exp.map {|row| row.map {|cell| '%-10s' % cell.to_s}.join('').strip}.join("\n")
-    act = act.map {|row| row.map {|cell| '%-10s' % cell.to_s}.join('').strip}.join("\n")
+    exp = exp.map {|row| row.map {|cell| '%-10s' % cell.to_s}.join('').rstrip}.join("\n")
+    act = act.map {|row| row.map {|cell| '%-10s' % cell.to_s}.join('').rstrip}.join("\n")
     assert_equal(exp, act, msg)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xls
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors: