robust_excel_ole 0.2.0

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+vendor/bundle
+*~
+.DS_Store
+doc/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in robust_excel_ole.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,10 @@
+# -*- mode: ruby -*-
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', cli: "--color", all_after_pass: false, all_on_start: false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/robust_excel_ole/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('lib/robust_excel_ole.rb')     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2011-2013 tomi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,148 @@
+= RobustExcelOle
+
+This is a simple fork from tomiacannondale's wrap_excel adapted to Ruby 1.8.6.
+The functionality of wrap_excel is optimised and extended by new features.
+
+
+== Description
+
+RobustExcelOle wraps the win32ole, and uses the Excel operations with ruby.
+
+== Requirements
+
+* Ruby 1.9.2 or higher (platform is windows)
+* also works with Ruby 1.8.6
+
+== Install
+
+  gem install robust_excel_ole
+
+== Usage
+=== access book
+
+Read with block.
+
+  RobustExcelOle::Book.open('./sample.xls') do |book|
+    # do something
+  end
+
+Read without block.
+
+  book = RobustExcelOle::Book.open('./sample.xls')
+  book.close
+
+Options are the following.
+
+[read_only] boolean(default true)
+[displayalerts] boolean(default false)
+[visible] boolean(default false)
+
+=== access sheet
+
+Sheet object can access with Book#[] method.
+
+  sheet = book[0]
+
+Access with sheet name.
+
+    book['Sheet1']
+
+=== access row or column
+
+Sheet object is included enumerable. Use Sheet#each_column or Sheet#each_row or Sheet#each method.
+
+  sheet.each do |cell|
+    # do something with cell
+    # read every row every column
+  end
+
+  sheet.each_row do |row|
+    # do something with row_range
+  end
+
+  sheet.each_column do |column_range|
+    # do something with column_range
+  end
+
+=== access cell
+
+Read from sheet object.
+
+  sheet[0, 0]  => first cell.
+
+Read from range object
+
+  row_range[0]  => first cell in row_range
+  column_range[1] => second cell in column_range
+
+=== write excel
+
+Can save an existing file.
+
+Saves a file, if no file with the same name exists.
+
+Proceeds acocording to the options, otherwise.
+
+  RobustExcelOle::Book.open('./sample.xls', :read_only => false) do |book|
+    # do something
+    book.save '.\sample.xls'
+  end
+
+or
+
+  book = RobustExcelOle::Book.open('./sample.xls', :read_only => false)
+  book.save '.\sample.xls'
+  book.close
+
+Can save with an another file name.
+
+  RobustExcelOle::Book.open('./sample.xls', :read_only => false) do |book|
+    # do something  
+    book.save './another_file.xls'
+  end
+
+
+Save to another_file.xls.
+
+Options are the following:
+
+[:if_exists] :overwrite, :excel, :raise (default)
+
+:overwrite: 
+
+Delete the old file and write the file.
+
+:excel
+
+Give the control to Excel.
+
+:raise
+
+Throw an exception. Don't write the file.
+
+Example:
+
+ RobustExcelOle::Book.open('./sample.xls', :read_only => false) do |book|
+    # do something
+    book.save('./another_file.xls', :if_exists => :overwrite)
+  end
+
+=== Want to do more things
+
+All RobustExcelOle object include win32ole instance. If you want to do something that not provide a function, you can use win32ole methods.
+
+== Support
+
+Report issues and feature requests to github Issues. https://github.com/Thomas008/robust_excel_ole/issues
+
+== Collaborate
+
+Please pull request on github.
+
+== Author
+
+thomas mailto:traths@cs.uni-potsdam.de
+
+== License
+
+MIT License. For more imformation, please see LICENSE.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+
+require "rake"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |s|
+  s.rspec_opts = '-f d'
+end
+task :default => :spec

data/lib/robust_excel_ole.rb

@@ -0,0 +1,13 @@
+require "win32ole"
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/excel_app')
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/book')
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/sheet')
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/cell')
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/range')
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/cygwin') if RUBY_PLATFORM =~ /cygwin/
+#+#require "robust_excel_ole/version"
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/version')
+
+module RobustExcelOle
+
+end

data/lib/robust_excel_ole/book.rb

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+require 'weakref'
+
+module RobustExcelOle
+
+  class Book
+    attr_reader :workbook
+
+
+    class << self
+
+      # opens a book.
+      # 
+      # options: 
+      #  :reuse         (boolean)  use an already open Excel-application (default: true)
+      #  :read_only     (boolean)  open in read-only mode                (default: false)
+      #  :displayalerts (boolean)  allow display alerts in Excel         (default: false)
+      #  :visible       (boolean)  make visibe in Excel                  (default: false)
+      #  :if_unsaved    if an unsaved book with the same name is open, then
+      #                 :raise   -> raise an exception                   (default)             
+      #                 :accept  -> let the unsaved book open                  
+      #                 :forget  -> close the unsaved book, open the new book
+      #                 :excel   -> give control to excel
+      #                 :new_app -> open the new book in a new excel application
+      #  :if_unsaved_other_book   if an unsaved book with the same name in a different path is open, then
+      #                  :raise   -> raise an exception                  (default)             
+      #                  :save    -> save and close the unsaved book and open the new book
+      #                  :forget  -> close the unsaved book, open the new book
+      #                  :new_app -> open the new book in a new excel application
+      def open(file, options={ :reuse => true}, &block)
+        new(file, options, &block)
+      end
+
+    end
+
+    def initialize(file, opts={ }, &block)
+      @options = {
+        :reuse => true,
+        :read_only => false,
+        :if_unsaved => :raise,
+        :if_unsaved_other_book => :raise
+      }.merge(opts)
+      excel_app_options = {:reuse => true}.merge(opts).delete_if{|k,v| 
+        k== :if_read_only || k== :unsaved || k == :if_unsaved_other_book}
+      if not File.exist?(file)
+        raise ExcelErrorOpen, "file #{file} not found"
+      end
+      @excel_app = ExcelApp.new(excel_app_options)
+      workbooks = @excel_app.Workbooks
+      @workbook = workbooks.Item(File.basename(file)) rescue nil
+      if @workbook then
+        blocked_by_other_book = (File.basename(file) == File.basename(@workbook.Fullname)) && 
+                                (not (file == @workbook.Fullname.gsub("\\","/")))
+        if blocked_by_other_book then
+          case @options[:if_unsaved_other_book]
+          when :raise
+            raise ExcelErrorOpen, "blocked by an unsaved book with the same name in a different path"
+          when :save
+            #nothing
+          when :forget
+            @workbook.Close
+          when :new_app
+            @options[:reuse] = false
+            @excel_app = ExcelApp.new(@options)
+            @workbook = nil
+          else
+            raise ExcelErrorOpen, ":if_unsaved_other_book: invalid option"
+          end
+        else
+          # book open, not saved, not blocked by other book
+          if (not @workbook.Saved) then
+            #p "book not saved"
+            case @options[:if_unsaved]
+            when :raise
+              raise ExcelErrorOpen, "book is already open but not saved (#{File.basename(file)})"
+            when :accept
+              #nothing
+            when :forget
+              @workbook.Close
+            when :excel
+              old_displayalerts = @excel_app.DisplayAlerts
+              @excel_app.DisplayAlerts = true 
+            when :new_app
+              @options[:reuse] = false
+              @excel_app = ExcelApp.new(@options)
+              @workbook = nil
+            else
+              raise ExcelErrorOpen, ":if_unsaved: invalid option"
+            end
+          end
+        end
+      end
+      begin
+        # if book not open (was not open,was closed with option :forget or shall be opened in new application)
+        #    or :if_unsaved => :excel
+        if ((not alive?) || (@options[:if_unsaved] == :excel)) then
+          begin
+            @workbook = @excel_app.Workbooks.Open(absolute_path(file),{ 'ReadOnly' => @options[:read_only] })
+          rescue WIN32OLERuntimeError
+            raise ExcelUserCanceled, "open: canceled by user"
+          end
+        end
+      ensure
+        if @options[:if_unsaved] == :excel then
+          @excel_app.DisplayAlerts = old_displayalerts
+        end
+      end
+      if block
+        begin
+          yield self
+        ensure
+          close
+        end
+      end
+      @workbook
+    end
+    
+    # closes the book, if it is alive
+    #
+    # options:
+    #  :if_unsaved    if book is unsaved
+    #                 :raise   -> raise an exception       (default)             
+    #                 :save    -> save the book before it is closed                  
+    #                 :forget  -> close the book 
+    #                 :excel   -> give control to excel
+    def close(opts={ })
+      @options = {
+        :if_unsaved => :raise,
+      }.merge(opts)
+      if ((alive?) && (not @workbook.Saved)) then
+        #puts "book not saved"
+        case @options[:if_unsaved]
+        when :raise
+          raise ExcelErrorClose, "book is unsaved (#{File.basename(filename)})"
+        when :save
+          save
+        when :forget
+          #nothing
+        when :excel
+          old_displayalerts = @excel_app.DisplayAlerts
+          @excel_app.DisplayAlerts = true 
+        else
+          raise ExcelErrorClose, ":if_unsaved: invalid option"
+        end
+      end
+      begin
+        @workbook.Close if alive?
+        @workbook = nil unless alive?
+        raise ExcelUserCanceled, "close: canceled by user" if alive? && @options[:if_unsaved] == :excel && (not @workbook.Saved)
+      ensure
+        if @options[:if_unsaved] == :excel then
+          @excel_app.DisplayAlerts = old_displayalerts
+        end
+      end
+      #@excel_app.Workbooks.Close
+      #@excel_app.Quit
+    end
+
+    # returns true, if the work book is alive, false otherwise
+    def alive?
+      begin 
+        @workbook.Name
+        true
+      rescue 
+        @workbook = nil  # dead object won't be alive again
+        #puts $!.message
+        false
+      end
+    end
+
+    # returns the full file name of the book
+    def filename
+      @workbook.Fullname.tr('\\','/') rescue nil
+    end
+
+    #returns true, if the full book names and excel appications are identical, false, otherwise  
+    def == other_book
+      other_book.is_a?(Book) &&
+      @excel_app == other_book.excel_app &&
+      self.filename == other_book.filename  
+    end
+
+
+    attr_reader :excel_app
+
+    # saves a book.
+    # returns true, if successfully saved, nil otherwise
+    def save
+      raise IOError, "Not opened for writing(open with :read_only option)" if @options[:read_only]
+      if @workbook then
+        @workbook.Save 
+        true
+      else
+        nil
+      end
+    end
+
+    # saves a book.
+    #
+    # options:
+    #  :if_exists   if a file with the same name exists, then  
+    #               :raise     -> raise an exception, dont't write the file  (default)
+    #               :overwrite -> write the file, delete the old file
+    #               :excel     -> give control to Excel
+    # returns true, if successfully saved, nil otherwise
+    def save_as(file = nil, opts = {:if_exists => :raise} )
+      raise IOError, "Not opened for writing(open with :read_only option)" if @options[:read_only]
+      dirname, basename = File.split(file)
+      file_format =
+        case File.extname(basename)
+        when '.xls' : RobustExcelOle::XlExcel8
+        when '.xlsx': RobustExcelOle::XlOpenXMLWorkbook
+        when '.xlsm': RobustExcelOle::XlOpenXMLWorkbookMacroEnabled
+        end
+      if File.exist?(file) then
+        case opts[:if_exists]
+        when :overwrite
+          File.delete(file) 
+          #File.delete(absolute_path(File.join(dirname, basename)))
+        when :excel 
+          old_displayalerts = @excel_app.DisplayAlerts
+          @excel_app.DisplayAlerts = true 
+        when :raise
+          raise ExcelErrorSave, "book already exists: #{basename}"
+        else
+          raise ExcelErrorSave, ":if_exists: invalid option"
+        end
+      end
+      begin
+        @workbook.SaveAs(absolute_path(File.join(dirname, basename)), file_format)
+      rescue WIN32OLERuntimeError => msg
+        if msg.message =~ /SaveAs/ and msg.message =~ /Workbook/ then
+          #toDo: more condition for cancel. if user cancels: raise an exception
+          if opts[:if_exists] == :excel then 
+            raise ExcelUserCanceled, "save: canceled by user"
+          else
+            return nil
+          end
+          # another possible semantics. raise ExcelErrorSaveFailed, "could not save Workbook"
+        else
+          raise ExcelErrorSaveUnknown, "unknown WIN32OELERuntimeError:\n#{msg.message}"
+        end       
+      ensure
+        if opts[:if_exists] == :excel then
+          @excel_app.DisplayAlerts = old_displayalerts
+        end
+      end
+      true
+    end
+
+    
+    def [] sheet
+      sheet += 1 if sheet.is_a? Numeric
+      RobustExcelOle::Sheet.new(@workbook.Worksheets.Item(sheet))
+    end
+
+    def each
+      @workbook.Worksheets.each do |sheet|
+        yield RobustExcelOle::Sheet.new(sheet)
+      end
+    end
+
+    # adds a sheet
+    def add_sheet(sheet = nil, opts = { })
+      if sheet.is_a? Hash
+        opts = sheet
+        sheet = nil
+      end
+
+      new_sheet_name = opts.delete(:as)
+
+      after_or_before, base_sheet = opts.to_a.first || [:after, RobustExcelOle::Sheet.new(@workbook.Worksheets.Item(@workbook.Worksheets.Count))]
+      base_sheet = base_sheet.sheet
+      sheet ? sheet.Copy({ after_or_before.to_s => base_sheet }) : @workbook.WorkSheets.Add({ after_or_before.to_s => base_sheet })
+
+      new_sheet = RobustExcelOle::Sheet.new(@excel_app.Activesheet)
+      new_sheet.name = new_sheet_name if new_sheet_name
+      new_sheet
+    end        
+
+    # absolute path of the file
+    def absolute_path(file)
+      file = File.expand_path(file)
+      file = RobustExcelOle::Cygwin.cygpath('-w', file) if RUBY_PLATFORM =~ /cygwin/
+      WIN32OLE.new('Scripting.FileSystemObject').GetAbsolutePathName(file)
+    end
+  end
+
+end
+
+class ExcelUserCanceled < RuntimeError
+end
+
+class ExcelError < RuntimeError
+end
+
+class ExcelErrorSave < ExcelError
+end
+
+class ExcelErrorSaveFailed < ExcelErrorSave  
+end
+
+class ExcelErrorSaveUnknown < ExcelErrorSave  
+end
+
+class ExcelErrorOpen < ExcelError
+end
+
+class ExcelErrorClose < ExcelError
+end