xlsx_writer 0.3.2 → 0.4.0

data/CHANGELOG

@@ -1,3 +1,15 @@
+0.4.0 / 2012-07-19
+
+* Enhancements
+
+  * Use a shared string file! thanks to @ledbettj in https://github.com/seamusabshere/xlsx_writer/pull/3
+  * Write rows and shared strings directly to disk to minimize memory usage
+  * Simplify syntax: XlsxWriter.new instead of XlsxWriter::Document.new
+
+* Bug fixes
+
+  * Render BigDecimal and Rational as decimal
+
 0.3.2 / 2012-07-12
 
 * Bug fixes

data/README.markdown

@@ -33,7 +33,7 @@ Features not present in simple_xlsx_writer:
 
     require 'xlsx_writer'
     
-    doc = XlsxWriter::Document.new
+    doc = XlsxWriter.new
 
     # show TRUE for true but a blank cell instead of FALSE
     doc.quiet_booleans!

data/foo.rb

@@ -19,7 +19,8 @@ require 'xlsx_writer'
 # @sheet1.add_autofilter 'A1:B1'
 
 @sheet2 = @doc.add_sheet("Sheet2")
-@sheet2.add_row(['a', 'a'])
+@sheet2.add_row(['one', 'two'])
+@sheet2.add_row(['a', 1])
 @sheet2.add_row(['false1', false])
 @sheet2.add_row(['false2', {:value => false, :type => :Boolean}])
 @sheet2.add_row(['false3', 'faLse'])

data/lib/xlsx_writer.rb

@@ -1,30 +1,111 @@
 require 'thread'
+require 'fileutils'
 require 'active_support/core_ext'
 require 'unix_utils'
 
-module XlsxWriter
-end
-
 require 'xlsx_writer/cell'
-require 'xlsx_writer/document'
 require 'xlsx_writer/row'
-require 'xlsx_writer/xml'
 require 'xlsx_writer/header_footer'
 require 'xlsx_writer/autofilter'
 require 'xlsx_writer/page_setup'
+require 'xlsx_writer/sheet'
+require 'xlsx_writer/shared_strings'
 
+require 'xlsx_writer/xml'
 # manual
-require 'xlsx_writer/generators/sheet'
-require 'xlsx_writer/generators/sheet_rels'
-require 'xlsx_writer/generators/image'
-
-# generators
-require 'xlsx_writer/generators/app'
-require 'xlsx_writer/generators/content_types'
-require 'xlsx_writer/generators/doc_props'
-require 'xlsx_writer/generators/rels'
-require 'xlsx_writer/generators/styles'
-require 'xlsx_writer/generators/workbook'
-require 'xlsx_writer/generators/workbook_rels'
-require 'xlsx_writer/generators/vml_drawing'
-require 'xlsx_writer/generators/vml_drawing_rels'
+require 'xlsx_writer/xml/sheet_rels'
+require 'xlsx_writer/xml/image'
+# automatic
+require 'xlsx_writer/xml/app'
+require 'xlsx_writer/xml/content_types'
+require 'xlsx_writer/xml/doc_props'
+require 'xlsx_writer/xml/rels'
+require 'xlsx_writer/xml/styles'
+require 'xlsx_writer/xml/workbook'
+require 'xlsx_writer/xml/workbook_rels'
+require 'xlsx_writer/xml/vml_drawing'
+require 'xlsx_writer/xml/vml_drawing_rels'
+
+class XlsxWriter
+  attr_reader :staging_dir
+  attr_reader :sheets
+  attr_reader :images
+  attr_reader :page_setup
+  attr_reader :header_footer
+  attr_reader :shared_strings
+
+  def initialize
+    @mutex = Mutex.new
+    staging_dir = UnixUtils.tmp_path 'xlsx_writer'
+    FileUtils.mkdir_p staging_dir
+    @staging_dir = staging_dir
+    @sheets = []
+    @images = []
+    @page_setup = PageSetup.new
+    @header_footer = HeaderFooter.new
+    @shared_strings = SharedStrings.new self
+  end
+
+  # Instead of TRUE or FALSE, show TRUE and blank if false
+  def quiet_booleans!
+    @quiet_booleans = true
+  end
+
+  def quiet_booleans?
+    @quiet_booleans == true
+  end
+
+  def add_sheet(name)
+    raise RuntimeError, "Can't add sheet, already generated!" if generated?
+    ndx = sheets.length + 1
+    sheet = Sheet.new self, name, ndx
+    sheets << sheet
+    sheet
+  end
+  
+  delegate :header, :footer, :to => :header_footer
+  
+  def add_image(path, width, height)
+    raise RuntimeError, "Can't add image, already generated!" if generated?
+    image = Image.new self, path, width, height
+    images << image
+    image
+  end
+
+  def path
+    @path || @mutex.synchronize do
+      @path ||= begin
+        sheets.each { |sheet| sheet.generate }
+        images.each { |image| image.generate }
+        shared_strings.generate
+        Xml.auto.each { |part| part.new(self).generate }
+        with_zip_extname = UnixUtils.zip staging_dir
+        with_xlsx_extname = with_zip_extname.sub(/.zip$/, '.xlsx')
+        FileUtils.mv with_zip_extname, with_xlsx_extname
+        @generated = true
+        with_xlsx_extname
+      end
+    end
+  end
+
+  def cleanup
+    @mutex.synchronize do
+      FileUtils.rm_rf @staging_dir
+      FileUtils.rm_f @path
+      @path = nil
+      @generated = false
+    end
+  end
+  
+  def generate
+    path
+    true
+  end
+  
+  def generated?
+    @generated == true
+  end
+end
+
+# backwards compatibility
+XlsxWriter::Document = XlsxWriter

data/lib/xlsx_writer/autofilter.rb

@@ -1,4 +1,4 @@
-module XlsxWriter
+class XlsxWriter
   class Autofilter < ::Struct.new(:sheet, :range)
     def to_xml
       %{<autoFilter ref="#{range}" />}

data/lib/xlsx_writer/cell.rb

@@ -1,48 +1,10 @@
 require 'fast_xs'
 
-module XlsxWriter
+class XlsxWriter
   class Cell
     class << self
-      # TODO make a class for this
-      def excel_type(calculated_type)
-        case calculated_type
-        when :String
-          :inlineStr
-        when :Number, :Integer, :Decimal, :Date, :Currency
-          :n
-        when :Boolean
-          :b
-        else
-          raise ::ArgumentError, "Unknown cell type #{calculated_type}"
-        end
-      end
-      
-      # TODO make a class for this
-      def excel_style_number(calculated_type, faded = false)
-        i = case calculated_type
-        when :String
-          0
-        when :Boolean
-          0 # todo
-        when :Currency
-          1
-        when :Date
-          2
-        when :Number, :Integer
-          3
-        when :Decimal
-          4
-        else
-          raise ::ArgumentError, "Unknown cell type #{k}"
-        end
-        if faded
-          i * 2 + 1
-        else
-          i * 2
-        end
-      end
-      
-      def excel_column_letter(i)
+      # 0 -> A (zero based!)
+      def column_letter(i)
         result = []
         while i >= 26 do
           result << ABC[i % 26]
@@ -51,77 +13,65 @@ module XlsxWriter
         result << ABC[result.empty? ? i : i - 1]
         result.reverse.join
       end
-            
-      def excel_string(value)
-        value.to_s.fast_xs
-      end
-      
-      def excel_number(value)
-        str = value.to_s.dup
-        unless str =~ /\A[0-9\.\-]*\z/
-          raise ::ArgumentError, %{Bad value "#{value}" Only numbers and dots (.) allowed in number fields}
+
+      # backwards compatibility
+      alias :excel_column_letter :column_letter
+
+      def type(value, proposed = nil)
+        hint = if proposed
+          proposed
+        elsif value.is_a?(String) and value =~ TRUE_FALSE_PATTERN
+          :Boolean
+        else
+          value.class.name.to_sym
         end
-        str.fast_xs
-      end
-      
-      alias :excel_currency :excel_number
-      alias :excel_integer :excel_number
-      alias :excel_decimal :excel_number
-      
-      # doesn't necessarily work for times yet
-      def excel_date(value)
-        if value.is_a?(::String)
-          ((::Time.parse(str) - JAN_1_1900) / 86_400).round
-        elsif value.respond_to?(:to_date)
-          (value.to_date - JAN_1_1900.to_date).to_i
+        case hint
+        when :NilClass
+          :String
+        when :Fixnum
+          :Integer
+        when :Float, :Rational, :BigDecimal
+          :Decimal
+        when :TrueClass, :FalseClass
+          :Boolean
+        else
+          hint
         end
       end
-      
-      def excel_boolean(value)
-        value ? 1 : 0
+
+      def style_number(type, faded = false)
+        style_number = STYLE_NUMBER[type] or raise("Don't know style number for #{type.inspect}. Must be #{STYLE_NUMBER.keys.map(&:inspect).join(', ')}.")
+        if faded
+          style_number * 2 + 1
+        else
+          style_number * 2
+        end
       end
 
+      def type_name(type)
+        TYPE_NAME[type] or raise "Don't know type name for #{type.inspect}. Must be #{TYPE_NAME.keys.map(&:inspect).join(', ')}."
+      end
+      
       # width = Truncate([{Number of Characters} * {Maximum Digit Width} + {5 pixel padding}]/{Maximum Digit Width}*256)/256
       # Using the Calibri font as an example, the maximum digit width of 11 point font size is 7 pixels (at 96 dpi). In fact, each digit is the same width for this font. Therefore if the cell width is 8 characters wide, the value of this attribute shall be Truncate([8*7+5]/7*256)/256 = 8.7109375.
-      def pixel_width(character_width)
-        [
-          ((character_width.to_f*MAX_DIGIT_WIDTH+5)/MAX_DIGIT_WIDTH*256)/256,
-          MAX_REASONABLE_WIDTH
-        ].min
-      end
-
-      def calculate_type(value)
-        case value
-        when Date
-          :Date
-        when Integer
-          :Integer
-        when Float
-          :Decimal
-        when Numeric
-          :Number
-        when TrueClass, FalseClass, TRUE_FALSE_PATTERN
-          :Boolean
+      def pixel_width(value, type = nil)
+        if (w = ((character_width(value, type).to_f*MAX_DIGIT_WIDTH+5)/MAX_DIGIT_WIDTH*256)/256) < MAX_REASONABLE_WIDTH
+          w
         else
-          if (defined?(Decimal) and value.is_a?(Decimal)) or (defined?(BigDecimal) and value.is_a?(BigDecimal))
-            :Decimal
-          else
-            :String
-          end
+          MAX_REASONABLE_WIDTH
         end
       end
 
-      def character_width(value, calculated_type = nil)
-        calculated_type ||= calculate_type(value)
-        case calculated_type
-        when :String
+      def character_width(value, type = nil)
+        if type.nil?
+          type = Cell.type(value)
+        end
+        case type
+        when :String, :Integer
           value.to_s.length
-        when :Number, :Integer, :Decimal
+        when :Decimal
           # -1000000.5
-          len = round(value, 2).to_s.length
-          len += 2 if calculated_type == :Decimal
-          len += 1 if value < 0
-          len
+          round(value, 2).to_s.length + 2
         when :Currency
           # (1,000,000.50)
           len = round(value, 2).to_s.length + log_base(value.abs, 1e3).floor
@@ -131,15 +81,47 @@ module XlsxWriter
           DATE_LENGTH
         when :Boolean
           BOOLEAN_LENGTH
+        else
+          raise "Don't know character width for #{type.inspect}."
         end
       end
 
-      if ::RUBY_VERSION >= '1.9'
+      def escape(value, type = nil)
+        if type.nil?
+          type = Cell.type(value)
+        end
+        case type
+        when :Integer
+          value.to_s
+        when :Decimal, :Currency
+          case value
+          when BIG_DECIMAL
+            value.to_s('F')
+          when Rational
+            value.to_f.to_s
+          else
+            value.to_s
+          end
+        when :Date
+          # doesn't work for DateTimes or Times yet
+          if value.is_a?(String)
+            ((Time.parse(str) - JAN_1_1900) / 86_400).round
+          elsif value.respond_to?(:to_date)
+            (value.to_date - JAN_1_1900.to_date).to_i
+          end
+        when :Boolean
+          value ? 1 : 0
+        else
+          value.fast_xs
+        end
+      end
+
+      if RUBY_VERSION >= '1.9'
         def round(number, precision)
           number.round precision
         end
         def log_base(number, base)
-          ::Math.log number, base
+          Math.log number, base
         end
       else
         def round(number, precision)
@@ -147,65 +129,87 @@ module XlsxWriter
         end
         # http://blog.vagmim.com/2010/01/logarithm-to-any-base-in-ruby.html
         def log_base(number, base)
-          ::Math.log(number) / ::Math.log(base)
+          Math.log(number) / Math.log(base)
         end
       end
     end
-    
+
     ABC = ('A'..'Z').to_a
     MAX_DIGIT_WIDTH = 5
     MAX_REASONABLE_WIDTH = 75
     DATE_LENGTH = 'YYYY-MM-DD'.length
     BOOLEAN_LENGTH = 'FALSE'.length + 1
-    JAN_1_1900 = ::Time.parse('1899-12-30 00:00:00 UTC')
+    JAN_1_1900 = Time.parse('1899-12-30 00:00:00 UTC')
     TRUE_FALSE_PATTERN = %r{^true|false$}i
-    
+    BIG_DECIMAL = defined?(BigDecimal) ? BigDecimal : Struct.new
+
+    STYLE_NUMBER = {
+      :String     => 0,
+      :Boolean    => 0,
+      :Currency   => 1,
+      :Date       => 2,
+      :Integer    => 3,
+      :Decimal    => 4,
+    }
+
+    TYPE_NAME = {
+      :String     => :s,
+      :Boolean    => :b,
+      :Currency   => :n,
+      :Date       => :n,
+      :Integer    => :n,
+      :Decimal    => :n,
+    }
+
     attr_reader :row
+    attr_reader :x
+    attr_reader :y
     attr_reader :value
-    attr_reader :pixel_width
-    attr_reader :excel_type
-    attr_reader :excel_style_number
-    attr_reader :excel_value
+    attr_reader :type
 
-    def initialize(row, data)
+    def initialize(row, raw_value, x, y)
       @row = row
-      if data.is_a?(::Hash)
-        data = data.symbolize_keys
-        @value = data[:value]
-        faded = data[:faded]
-        calculated_type = data[:type] || Cell.calculate_type(@value)
+      @x = x
+      @y = y
+      if raw_value.is_a?(Hash)
+        @value = raw_value[:value]
+        @type = Cell.type @value, raw_value[:type]
+        @faded_query = raw_value[:faded]
       else
-        @value = data
-        faded = false
-        calculated_type = Cell.calculate_type @value
+        @value = raw_value
+        @type = Cell.type value
       end
-      character_width = Cell.character_width @value, calculated_type
-      @pixel_width = Cell.pixel_width character_width
-      @excel_type = Cell.excel_type calculated_type
-      @excel_style_number = Cell.excel_style_number calculated_type, faded
-      @excel_value = Cell.send "excel_#{calculated_type.to_s.underscore}", @value
+    end
+
+    def faded?
+      @faded_query == true
+    end
+
+    def empty?
+      return @empty_query if defined?(@empty_query)
+      @empty_query = (value.nil? or (value.is_a?(String) and value.empty?) or (value == false and row.sheet.document.quiet_booleans?))
     end
 
     def to_xml
-      if value.nil? or (value.is_a?(String) and value.empty?) or (value == false and quiet_booleans?)
-        %{<c r="#{excel_column_letter}#{row.ndx}" s="0" t="inlineStr" />}
-      elsif excel_type == :inlineStr
-        %{<c r="#{excel_column_letter}#{row.ndx}" s="#{excel_style_number}" t="#{excel_type}"><is><t>#{excel_value}</t></is></c>}
+      if empty?
+        %{<c r="#{Cell.column_letter(x)}#{y}" s="0" t="s" />}
       else
-        %{<c r="#{excel_column_letter}#{row.ndx}" s="#{excel_style_number}" t="#{excel_type}"><v>#{excel_value}</v></c>}
+        %{<c r="#{Cell.column_letter(x)}#{y}" s="#{Cell.style_number(type, faded?)}" t="#{Cell.type_name(type)}"><v>#{escaped_value}</v></c>}
       end
     end
 
-    # 0 -> A (zero based!)
-    def excel_column_letter
-      Cell.excel_column_letter row.cells.index(self)
+    def pixel_width
+      @pixel_width ||= Cell.pixel_width value, type
     end
 
-    private
-
-    def quiet_booleans?
-      return @quiet_booleans if defined?(@quiet_booleans)
-      @quiet_booleans = row.sheet.document.quiet_booleans?
+    def escaped_value
+      @escaped_value ||= begin
+        if type == :String
+          row.sheet.document.shared_strings.ndx value
+        else
+          Cell.escape value
+        end
+      end
     end
   end
 end