roo 1.13.2 → 2.10.1

data/lib/roo/font.rb

@@ -0,0 +1,17 @@
+module Roo
+  class Font
+    attr_accessor :bold, :italic, :underline
+
+    def bold?
+      @bold
+    end
+
+    def italic?
+      @italic
+    end
+
+    def underline?
+      @underline
+    end
+  end
+end

data/lib/roo/formatters/base.rb

@@ -0,0 +1,15 @@
+module Roo
+  module Formatters
+    module Base
+      # converts an integer value to a time string like '02:05:06'
+      def integer_to_timestring(content)
+        h = (content / 3600.0).floor
+        content -= h * 3600
+        m = (content / 60.0).floor
+        content -= m * 60
+        s = content
+        Kernel.format("%02d:%02d:%02d", h, m, s)
+      end
+    end
+  end
+end

data/lib/roo/formatters/csv.rb

@@ -0,0 +1,84 @@
+module Roo
+  module Formatters
+    module CSV
+      def to_csv(filename = nil, separator = ",", sheet = default_sheet)
+        if filename
+          File.open(filename, "w") do |file|
+            write_csv_content(file, sheet, separator)
+          end
+          true
+        else
+          sio = ::StringIO.new
+          write_csv_content(sio, sheet, separator)
+          sio.rewind
+          sio.read
+        end
+      end
+
+      private
+
+      # Write all cells to the csv file. File can be a filename or nil. If the
+      # file argument is nil the output goes to STDOUT
+      def write_csv_content(file = nil, sheet = nil, separator = ",")
+        file ||= STDOUT
+        return unless first_row(sheet) # The sheet is empty
+
+        1.upto(last_row(sheet)) do |row|
+          1.upto(last_column(sheet)) do |col|
+            # TODO: use CSV.generate_line
+            file.print(separator) if col > 1
+            file.print cell_to_csv(row, col, sheet)
+          end
+          file.print("\n")
+        end
+      end
+
+      # The content of a cell in the csv output
+      def cell_to_csv(row, col, sheet)
+        return "" if empty?(row, col, sheet)
+
+        onecell = cell(row, col, sheet)
+
+        case celltype(row, col, sheet)
+        when :string
+          %("#{onecell.gsub('"', '""')}") unless onecell.empty?
+        when :boolean
+          # TODO: this only works for excelx
+          onecell = self.sheet_for(sheet).cells[[row, col]].formatted_value
+          %("#{onecell.gsub('"', '""').downcase}")
+        when :float, :percentage
+          if onecell == onecell.to_i
+            onecell.to_i.to_s
+          else
+            onecell.to_s
+          end
+        when :formula
+          case onecell
+          when String
+            %("#{onecell.gsub('"', '""')}") unless onecell.empty?
+          when Integer
+            onecell.to_s
+          when Float
+            if onecell == onecell.to_i
+              onecell.to_i.to_s
+            else
+              onecell.to_s
+            end
+          when Date, DateTime, TrueClass, FalseClass
+            onecell.to_s
+          else
+            fail "unhandled onecell-class #{onecell.class}"
+          end
+        when :date, :datetime
+          onecell.to_s
+        when :time
+          integer_to_timestring(onecell)
+        when :link
+          %("#{onecell.url.gsub('"', '""')}")
+        else
+          fail "unhandled celltype #{celltype(row, col, sheet)}"
+        end || ""
+      end
+    end
+  end
+end

data/lib/roo/formatters/matrix.rb

@@ -0,0 +1,23 @@
+module Roo
+  module Formatters
+    module Matrix
+      # returns a matrix object from the whole sheet or a rectangular area of a sheet
+      def to_matrix(from_row = nil, from_column = nil, to_row = nil, to_column = nil, sheet = default_sheet)
+        require 'matrix'
+
+        return ::Matrix.empty unless first_row
+
+        from_row ||= first_row(sheet)
+        to_row ||= last_row(sheet)
+        from_column ||= first_column(sheet)
+        to_column ||= last_column(sheet)
+
+        ::Matrix.rows(from_row.upto(to_row).map do |row|
+          from_column.upto(to_column).map do |col|
+            cell(row, col, sheet)
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/roo/formatters/xml.rb

@@ -0,0 +1,31 @@
+# returns an XML representation of all sheets of a spreadsheet file
+module Roo
+  module Formatters
+    module XML
+      def to_xml
+        Nokogiri::XML::Builder.new do |xml|
+          xml.spreadsheet do
+            sheets.each do |sheet|
+              self.default_sheet = sheet
+              xml.sheet(name: sheet) do |x|
+                if first_row && last_row && first_column && last_column
+                  # sonst gibt es Fehler bei leeren Blaettern
+                  first_row.upto(last_row) do |row|
+                    first_column.upto(last_column) do |col|
+                      next if empty?(row, col)
+
+                      x.cell(cell(row, col),
+                      row: row,
+                      column: col,
+                      type: celltype(row, col))
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end.to_xml
+      end
+    end
+  end
+end

data/lib/roo/formatters/yaml.rb

@@ -0,0 +1,40 @@
+module Roo
+  module Formatters
+    module YAML
+      # returns a rectangular area (default: all cells) as yaml-output
+      # you can add additional attributes with the prefix parameter like:
+      # oo.to_yaml({"file"=>"flightdata_2007-06-26", "sheet" => "1"})
+      def to_yaml(prefix = {}, from_row = nil, from_column = nil, to_row = nil, to_column = nil, sheet = default_sheet)
+        # return an empty string if there is no first_row, i.e. the sheet is empty
+        return "" unless first_row
+
+        from_row ||= first_row(sheet)
+        to_row ||= last_row(sheet)
+        from_column ||= first_column(sheet)
+        to_column ||= last_column(sheet)
+
+        result = "--- \n"
+        from_row.upto(to_row) do |row|
+          from_column.upto(to_column) do |col|
+            next if empty?(row, col, sheet)
+
+            result << "cell_#{row}_#{col}: \n"
+            prefix.each do|k, v|
+              result << "  #{k}: #{v} \n"
+            end
+            result << "  row: #{row} \n"
+            result << "  col: #{col} \n"
+            result << "  celltype: #{celltype(row, col, sheet)} \n"
+            value = cell(row, col, sheet)
+            if celltype(row, col, sheet) == :time
+              value = integer_to_timestring(value)
+            end
+            result << "  value: #{value} \n"
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/roo/helpers/default_attr_reader.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Roo
+  module Helpers
+    module DefaultAttrReader
+      def attr_reader_with_default(attr_hash)
+        attr_hash.each do |attr_name, default_value|
+          instance_variable = :"@#{attr_name}"
+          define_method attr_name do
+            if instance_variable_defined? instance_variable
+              instance_variable_get instance_variable
+            else
+              default_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roo/helpers/weak_instance_cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "weakref"
+
+module Roo
+  module Helpers
+    module WeakInstanceCache
+      private
+
+      def instance_cache(key)
+        object = nil
+
+        if instance_variable_defined?(key) && (ref = instance_variable_get(key)) && ref.weakref_alive?
+          begin
+            object = ref.__getobj__
+          rescue => e
+            unless (defined?(::WeakRef::RefError) && e.is_a?(::WeakRef::RefError)) || (defined?(RefError) && e.is_a?(RefError))
+              raise e
+            end
+          end
+        end
+
+        unless object
+          object = yield
+          ObjectSpace.define_finalizer(object, instance_cache_finalizer(key))
+          instance_variable_set(key, WeakRef.new(object))
+        end
+
+        object
+      end
+
+      def instance_cache_finalizer(key)
+        proc do |object_id|
+          if instance_variable_defined?(key) && (ref = instance_variable_get(key)) && (!ref.weakref_alive? || ref.__getobj__.object_id == object_id)
+            remove_instance_variable(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roo/libre_office.rb

@@ -0,0 +1,4 @@
+require 'roo/open_office'
+
+# LibreOffice is just an alias for Roo::OpenOffice class
+Roo::LibreOffice = Roo::OpenOffice

data/lib/roo/link.rb

@@ -0,0 +1,34 @@
+require 'uri'
+
+module Roo
+  class Link < String
+    # FIXME: Roo::Link inherits from String. A link cell is_a?(Roo::Link). **It is
+    #        the only situation where a cells `value` is always a String**. Link
+    #        cells have a nifty `to_uri` method, but this method isn't easily
+    #        reached. (e.g. `sheet.sheet_for(nil).cells[[row,column]]).value.to_uri`;
+    #        `sheet.hyperlink(row, column)` doesn't use `to_uri`).
+    #
+    #        1. Add different types of links (String, Numeric, Date, DateTime, etc.)
+    #        2. Remove Roo::Link.
+    #        3. Don't inherit the string and pass the cell's value.
+    #
+    #        I don't know the historical reasons for the Roo::Link, but right now
+    #        it seems uneccessary. I'm in favor of keeping it just in case.
+    #
+    #        I'm also in favor of passing the cell's value to Roo::Link. The
+    #        cell.value's class would still be Roo::Link, but the value itself
+    #        would depend on what type of cell it is (Numeric, Date, etc.).
+    #
+    attr_reader :href
+    alias_method :url, :href
+
+    def initialize(href = '', text = href)
+      super(text)
+      @href = href
+    end
+
+    def to_uri
+      URI.parse href
+    end
+  end
+end