nurettin-jruby-poi 0.8.2

data/lib/poi/workbook/workbook.rb

@@ -0,0 +1,262 @@
+require 'tmpdir'
+require 'stringio'
+require 'java'
+
+module POI
+  class Workbook < Facade(:poi_workbook, org.apache.poi.ss.usermodel.Workbook)
+    FONT = org.apache.poi.ss.usermodel.Font
+    FONT_CONSTANTS = Hash[*FONT.constants.map{|e| [e.downcase.to_sym, FONT.const_get(e)]}.flatten]
+
+    CELL_STYLE = org.apache.poi.ss.usermodel.CellStyle
+    CELL_STYLE_CONSTANTS = Hash[*CELL_STYLE.constants.map{|e| [e.downcase.to_sym, CELL_STYLE.const_get(e)]}.flatten]
+    
+    INDEXED_COLORS = org.apache.poi.ss.usermodel.IndexedColors
+    INDEXED_COLORS_CONSTANTS = Hash[*INDEXED_COLORS.constants.map{|e| [e.downcase.to_sym, INDEXED_COLORS.const_get(e)]}.flatten]
+    
+    def self.open(filename_or_stream)
+      name, stream = if filename_or_stream.kind_of?(java.io.InputStream)
+        [File.join(Dir.tmpdir, "spreadsheet.xlsx"), filename_or_stream]
+      elsif filename_or_stream.kind_of?(IO) || StringIO === filename_or_stream || filename_or_stream.respond_to?(:read)
+        # NOTE: the String.unpack here can be very inefficient on large files
+        [File.join(Dir.tmpdir, "spreadsheet.xlsx"), java.io.ByteArrayInputStream.new(filename_or_stream.read.unpack('c*').to_java(:byte))]
+      else
+        raise Exception, "FileNotFound" unless File.exists?( filename_or_stream )
+        [filename_or_stream, java.io.FileInputStream.new(filename_or_stream)]
+      end
+      instance = self.new(name, stream)
+      if block_given?
+        result = yield instance
+        return result 
+      end
+      instance
+    end
+    
+    def self.create(filename)
+      self.new(filename, nil)
+    end
+    
+    attr_reader :filename
+
+    def initialize(filename, io_stream)
+      @filename = filename
+      @workbook = io_stream ? org.apache.poi.ss.usermodel.WorkbookFactory.create(io_stream) : org.apache.poi.xssf.usermodel.XSSFWorkbook.new
+    end
+    
+    def formula_evaluator
+      @formula_evaluator ||= @workbook.creation_helper.create_formula_evaluator
+    end
+
+    def save
+      save_as(@filename)
+    end
+
+    def save_as(filename)
+      output = output_stream filename
+      begin
+        @workbook.write(output)
+      ensure
+        output.close
+      end
+    end
+    
+    def output_stream name
+      java.io.FileOutputStream.new(name)
+    end
+
+    def close
+      #noop
+    end
+    
+    def create_sheet name='New Sheet'
+      # @workbook.createSheet name
+      worksheets[name]
+    end
+    
+    def create_style options={}
+      font = @workbook.createFont
+      set_value( font, :font_height_in_points, options ) do | value |
+        value.to_i
+      end
+      set_value font, :bold_weight, options, FONT_CONSTANTS
+      set_value font, :color, options, INDEXED_COLORS_CONSTANTS do | value |
+        value.index
+      end
+
+      style = @workbook.createCellStyle
+      [:alignment, :vertical_alignment, :fill_pattern, :border_right, :border_left, :border_top, :border_bottom].each do | sym |
+        set_value style, sym, options, CELL_STYLE_CONSTANTS do | value |
+          value.to_i
+        end
+      end
+      [:right_border_color, :left_border_color, :top_border_color, :bottom_border_color, :fill_foreground_color, :fill_background_color].each do | sym |
+        set_value( style, sym, options, INDEXED_COLORS_CONSTANTS ) do | value |
+          value.index
+        end
+      end
+      [:hidden, :locked, :wrap_text].each do | sym |
+        set_value style, sym, options
+      end
+      [:rotation, :indentation].each do | sym |
+        set_value( style, sym, options ) do | value |
+          value.to_i
+        end
+      end
+      set_value( style, :data_format, options ) do |value|
+        @workbook.create_data_format.getFormat(value)
+      end
+      style.font = font
+      style
+    end
+    
+    def set_value on, value_sym, from, using=nil
+      return on unless from.has_key?(value_sym)
+      value = if using
+        using[from[value_sym]]
+      else
+        from[value_sym]
+      end
+      value = yield value if block_given?
+      on.send("set_#{value_sym}", value)
+      on
+    end
+
+    def worksheets
+      @worksheets ||= Worksheets.new(self)
+    end
+    
+    def named_ranges
+      @named_ranges ||= (0...@workbook.number_of_names).collect do | idx |
+        NamedRange.new @workbook.name_at(idx), self
+      end
+    end
+
+    # reference can be a Fixnum, referring to the 0-based sheet or
+    # a String which is the sheet name or a cell reference.
+    # 
+    # If a cell reference is passed the value of that cell is returned.
+    #
+    # If the reference refers to a contiguous range of cells an Array of values will be returned.
+    #
+    # If the reference refers to a multiple columns a Hash of values will be returned by column name.
+    def [](reference)
+      if Fixnum === reference
+        return worksheets[reference]
+      end
+      
+      if sheet = worksheets.detect{|e| e.name == reference}
+        return sheet.poi_worksheet.nil? ? nil : sheet
+      end
+
+      cell = cell(reference)
+      if Array === cell
+        cell.collect{|e| e.value}
+      elsif Hash === cell
+        values = {}
+        cell.each_pair{|column_name, cells| values[column_name] = cells.collect{|e| e.value}}
+        values
+      else
+        cell.value
+      end
+    end
+
+    # takes a String in the form of a 3D cell reference and returns the Cell (eg. "Sheet 1!A1")
+    #
+    # If the reference refers to a contiguous range of cells an array of Cells will be returned
+    def cell reference
+      # if the reference is to a named range of cells, get that range and return it
+      if named_range = named_ranges.detect{|e| e.name == reference}
+        cells = named_range.cells.compact
+        if cells.empty?
+          return nil
+        else
+          return cells.length == 1 ? cells.first : cells
+        end
+      end
+      
+      # check if the named_range is a full column reference
+      if column_reference?(named_range)
+        return all_cells_in_column named_range.formula
+      end
+      
+      # if the reference is to an area of cells, get all the cells in that area and return them
+      cells = cells_in_area(reference)
+      unless cells.empty?
+        return cells.length == 1 ? cells.first : cells
+      end
+      
+      if column_reference?(reference)
+        return all_cells_in_column reference
+      end
+
+      ref = POI::CELL_REF.new(reference)
+      single_cell ref
+    end
+    
+    # ref is a POI::CELL_REF instance
+    def single_cell ref
+      if ref.sheet_name.nil?
+        raise 'cell references at the workbook level must include a sheet reference (eg. Sheet1!A1)'
+      else
+        worksheets[ref.sheet_name][ref.row][ref.col]
+      end
+    end
+    
+    def cells_in_area reference
+      area = Area.new(reference)
+      area.in(self)
+    end
+
+    def poi_workbook
+      @workbook
+    end
+    
+    def on_update cell
+      #clear_all_formula_results
+      #formula_evaluator.notify_update_cell cell.poi_cell
+    end
+    
+    def on_formula_update cell
+      #clear_all_formula_results
+      formula_evaluator.notify_set_formula cell.poi_cell
+      formula_evaluator.evaluate_formula_cell(cell.poi_cell)
+    end
+    
+    def on_delete cell
+      #clear_all_formula_results
+      formula_evaluator.notify_delete_cell cell.poi_cell
+    end
+    
+    def clear_all_formula_results
+      formula_evaluator.clear_all_cached_result_values
+    end
+    
+    def all_cells_in_column reference
+      sheet_parts = reference.split('!')
+      area_parts  = sheet_parts.last.split(':')
+      area_start  = "#{sheet_parts.first}!#{area_parts.first}"
+      area_end    = area_parts.last
+      
+      area = org.apache.poi.ss.util.AreaReference.getWholeColumn(area_start, area_end)
+      full_ref = "#{area.first_cell.format_as_string}:#{area.last_cell.format_as_string}"
+      Area.new(full_ref).in(self)
+      # cell_reference = org.apache.poi.ss.util.CellReference.new( reference + "1" )
+      # column         = cell_reference.get_col
+      # sheet          = cell_reference.get_sheet_name
+      # worksheets[sheet].rows.collect{|row| row[column]}
+    end
+    
+    private
+      def column_reference? named_range_or_reference
+        return false if named_range_or_reference.nil?
+        
+        reference = named_range_or_reference
+        if NamedRange === named_range_or_reference
+          reference = named_range_or_reference.formula
+        end
+        cell_reference = reference.split('!', 2).last
+        beginning, ending = cell_reference.split(':')
+        !(beginning =~ /\d/ || (ending.nil? ? false : ending =~ /\d/))
+      end
+  end
+end
+

data/lib/poi/workbook/worksheet.rb

@@ -0,0 +1,78 @@
+module POI
+  class Worksheets
+    include Enumerable
+    
+    def initialize(workbook)
+      @workbook = workbook
+      @poi_workbook = workbook.poi_workbook
+    end
+
+    def [](index_or_name)
+      worksheet = case
+        when index_or_name.kind_of?(Numeric)
+          @poi_workbook.sheet_at(index_or_name) || @poi_workbook.create_sheet
+        else 
+          @poi_workbook.get_sheet(index_or_name) || @poi_workbook.create_sheet(index_or_name)
+      end
+      Worksheet.new(worksheet, @workbook)
+    end
+
+    def size
+      @poi_workbook.number_of_sheets
+    end
+
+    def each
+      (0...size).each { |i| yield Worksheet.new(@poi_workbook.sheet_at(i), @workbook) }
+    end
+  end
+
+  class Worksheet < Facade(:poi_worksheet, org.apache.poi.ss.usermodel.Sheet)
+
+    def initialize(worksheet, workbook)
+      @worksheet = worksheet
+      @workbook  = workbook
+    end
+    
+    def name
+      @worksheet.sheet_name
+    end
+
+    def first_row
+      @worksheet.first_row_num
+    end
+
+    def last_row
+      @worksheet.last_row_num
+    end
+
+    def rows
+      @rows ||= Rows.new(self)
+    end
+    
+    # Accepts a Fixnum or a String as the row_index
+    #
+    # row_index as Fixnum: returns the 0-based row
+    #
+    # row_index as String: assumes a cell reference within this sheet
+    #    if the value of the reference is non-nil the value is returned,
+    #    otherwise the referenced cell is returned
+    def [](row_index)
+      if Fixnum === row_index
+        rows[row_index]
+      else
+        ref = org.apache.poi.ss.util.CellReference.new(row_index)
+        cell = rows[ref.row][ref.col]
+        cell && cell.value ? cell.value : cell
+      end
+    end
+
+    def poi_worksheet
+      @worksheet
+    end
+    
+    def workbook
+      @workbook
+    end
+  end
+end
+

data/lib/poi/workbook.rb

@@ -0,0 +1,41 @@
+module POI
+  AREA_REF = org.apache.poi.ss.util.AreaReference
+  CELL_REF = org.apache.poi.ss.util.CellReference
+  
+  def self.Facade(delegate, java_class)
+    cls = Class.new
+    java_class.java_class.java_instance_methods.select{|e| e.public?}.each do | method |
+      args = method.arity.times.collect{|i| "arg#{i}"}.join(", ")
+      method_name = method.name.gsub(/([A-Z])/){|e| "_#{e.downcase}"}
+      code = "def #{method_name}(#{args}); #{delegate}.#{method.name}(#{args}); end"
+
+      if method_name =~ /^get_[a-z]/
+        alias_method_name = method_name.sub('get_', '')
+        code += "\nalias :#{alias_method_name} :#{method_name}"
+        if method.return_type.to_s == 'boolean'
+          code += "\nalias :#{alias_method_name}? :#{method_name}"
+        end
+      elsif method_name =~ /^set_[a-z]/ && method.arity == 1
+        alias_method_name = "#{method_name.sub('set_', '')}"
+        code += "\nalias :#{alias_method_name}= :#{method_name}"
+        if method.argument_types.first.to_s == 'boolean'
+          code += "\ndef #{alias_method_name}!; #{alias_method_name} = true; end"
+        end
+      elsif method.return_type.to_s == 'boolean' && method_name =~ /is_/
+        code += "\nalias :#{method_name.sub('is_', '')}? :#{method_name}"
+      elsif method.return_type.nil? && (method.argument_types.nil? || method.argument_types.empty?)
+        code += "\nalias :#{method_name}! :#{method_name}"
+      end
+      
+      cls.class_eval(code, __FILE__, __LINE__)
+    end
+    cls
+  end
+end
+
+require File.join(JRUBY_POI_LIB_PATH, 'poi', 'workbook', 'area')
+require File.join(JRUBY_POI_LIB_PATH, 'poi', 'workbook', 'named_range')
+require File.join(JRUBY_POI_LIB_PATH, 'poi', 'workbook', 'workbook')
+require File.join(JRUBY_POI_LIB_PATH, 'poi', 'workbook', 'worksheet')
+require File.join(JRUBY_POI_LIB_PATH, 'poi', 'workbook', 'row')
+require File.join(JRUBY_POI_LIB_PATH, 'poi', 'workbook', 'cell')

data/lib/poi.rb

@@ -0,0 +1,15 @@
+JRUBY_POI_LIB_PATH=File.expand_path(File.dirname(__FILE__))
+
+# Java
+require 'java'
+require File.join(JRUBY_POI_LIB_PATH, 'poi-3.7-20101029.jar')
+require File.join(JRUBY_POI_LIB_PATH, 'poi-ooxml-3.7-20101029.jar')
+require File.join(JRUBY_POI_LIB_PATH, 'poi-ooxml-schemas-3.7-20101029.jar')
+require File.join(JRUBY_POI_LIB_PATH, 'poi-scratchpad-3.7-20101029.jar')
+require File.join(JRUBY_POI_LIB_PATH, 'ooxml-lib', 'xmlbeans-2.3.0.jar')
+require File.join(JRUBY_POI_LIB_PATH, 'ooxml-lib', 'dom4j-1.6.1.jar')
+require File.join(JRUBY_POI_LIB_PATH, 'ooxml-lib', 'geronimo-stax-api_1.0_spec-1.0.jar')
+
+
+# Ruby
+require File.join(JRUBY_POI_LIB_PATH, 'poi', 'workbook')

data/spec/facade_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "POI.Facade" do
+  it "should create specialized methods for boolean methods, getters, and setters" do
+    book = POI::Workbook.create('foo.xlsx')
+    sheet = book.create_sheet
+    sheet.respond_to?(:column_broken?).should be_true
+    sheet.respond_to?(:column_hidden?).should be_true
+    sheet.respond_to?(:display_formulas?).should be_true
+    sheet.respond_to?(:display_gridlines?).should be_true
+    sheet.respond_to?(:selected?).should be_true
+    sheet.respond_to?(:column_breaks).should be_true
+    sheet.respond_to?(:column_break=).should be_true
+    sheet.respond_to?(:autobreaks?).should be_true
+    sheet.respond_to?(:autobreaks=).should be_true
+    sheet.respond_to?(:autobreaks!).should be_true
+    sheet.respond_to?(:column_broken?).should be_true
+    sheet.respond_to?(:fit_to_page).should be_true
+    sheet.respond_to?(:fit_to_page?).should be_true
+    sheet.respond_to?(:fit_to_page=).should be_true
+    sheet.respond_to?(:fit_to_page!).should be_true
+
+    sheet.respond_to?(:array_formula).should_not be_true
+    sheet.respond_to?(:array_formula=).should_not be_true
+    
+    row = sheet[0]
+    row.respond_to?(:first_cell_num).should be_true
+    row.respond_to?(:height).should be_true
+    row.respond_to?(:height=).should be_true
+    row.respond_to?(:height_in_points).should be_true
+    row.respond_to?(:height_in_points=).should be_true
+    row.respond_to?(:zero_height?).should be_true
+    row.respond_to?(:zero_height!).should be_true
+    row.respond_to?(:zero_height=).should be_true
+
+    cell = row[0]
+    cell.respond_to?(:boolean_cell_value).should be_true
+    cell.respond_to?(:boolean_cell_value?).should be_true
+    cell.respond_to?(:cached_formula_result_type).should be_true
+    cell.respond_to?(:cell_error_value=).should be_true
+    cell.respond_to?(:cell_value=).should be_true
+    cell.respond_to?(:hyperlink=).should be_true
+    cell.respond_to?(:cell_value!).should be_true
+    cell.respond_to?(:remove_cell_comment!).should be_true
+    cell.respond_to?(:cell_style).should be_true
+    cell.respond_to?(:cell_style=).should be_true
+  end
+end

data/spec/io_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe POI::Workbook do
+  before :each do
+    @mock_output_stream = nil
+    class POI::Workbook
+      def mock_output_stream name
+        @mock_output_stream ||= Java::jrubypoi.MockOutputStream.new name
+        @mock_output_stream
+      end
+
+      alias_method :original_output_stream, :output_stream unless method_defined?(:original_output_stream)
+      alias_method :output_stream, :mock_output_stream
+    end
+  end
+
+  after :each do
+    @mock_output_stream = nil
+    class POI::Workbook
+      alias_method :output_stream, :original_output_stream
+    end
+  end
+
+  it "should read an xlsx file" do 
+    name = TestDataFile.expand_path("various_samples.xlsx")
+    book = nil
+    lambda { book = POI::Workbook.open(name) }.should_not raise_exception
+    book.should be_kind_of POI::Workbook
+  end
+
+  it "should read an xls file" do 
+    name = TestDataFile.expand_path("simple_with_picture.xls")
+    book = nil
+    lambda { book = POI::Workbook.open(name) }.should_not raise_exception
+    book.should be_kind_of POI::Workbook
+  end
+
+  it "should read an ods file", :unimplemented => true do 
+    name = TestDataFile.expand_path("spreadsheet.ods")
+    book = nil
+    lambda { book = POI::Workbook.open(name) }.should_not raise_exception
+    book.should be_kind_of POI::Workbook
+  end
+
+  it "should write an open workbook" do
+    name = TestDataFile.expand_path("various_samples.xlsx")
+    POI::Workbook.open(name) do |book|
+      lambda { book.save }.should_not raise_exception
+      verify_mock_output_stream book.instance_variable_get("@mock_output_stream"), name
+    end
+  end
+
+  it "should write an open workbook to a new file" do
+    name = TestDataFile.expand_path("various_samples.xlsx")
+    new_name = TestDataFile.expand_path("saved-as.xlsx")
+
+    POI::Workbook.open(name) do |book|
+      @mock_output_stream.should be_nil
+      lambda { book.save_as(new_name) }.should_not raise_exception
+      verify_mock_output_stream book.instance_variable_get("@mock_output_stream"), new_name
+    end
+  end
+  
+  def verify_mock_output_stream mock_output_stream, name
+    mock_output_stream.should_not be_nil
+    name.should == mock_output_stream.name
+    true.should == mock_output_stream.write_called
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.configure do |c|
+  c.filter_run_excluding :unimplemented => true
+end
+
+require File.expand_path('../lib/poi', File.dirname(__FILE__))
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+require File.join(File.dirname(__FILE__), "support", "java", "support.jar")
+
+class TestDataFile
+  def self.expand_path(name)
+    File.expand_path(File.join(File.dirname(__FILE__), 'data', name))
+  end
+end

data/spec/support/java/jrubypoi/MockOutputStream.java

@@ -0,0 +1,24 @@
+package jrubypoi;
+import java.io.*;
+
+public class MockOutputStream extends OutputStream {
+  public String name;
+  public boolean write_called;
+  
+  public MockOutputStream(String name) {
+    this.name = name;
+    this.write_called = false;
+  }
+  
+  public void write(int b) throws IOException {
+    this.write_called = true;
+  }
+
+  public void write(byte[] b) throws IOException {
+    this.write_called = true;
+  }
+
+  public void write(byte[] b, int offset, int length) throws IOException {
+    this.write_called = true;
+  }
+}

data/spec/support/matchers/cell_matcher.rb

@@ -0,0 +1,17 @@
+RSpec::Matchers.define :equal_at_cell do |expected, row, col|
+  match do |actual|
+    actual == expected
+  end
+
+  failure_message_for_should do |actual|
+    "expected #{actual} to equal #{expected} (row:#{row}, cell:#{col})"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected #{actual} not to equal #{expected} (row:#{row}, cell:#{col})"
+  end
+
+  description do
+    "to equal #{expected}"
+  end
+end