axlsx 1.0.10 → 1.0.11

data/lib/axlsx/stylesheet/styles.rb

@@ -286,6 +286,8 @@ module Axlsx
       @cellXfs = SimpleTypedList.new Xf, "cellXfs"
       @cellXfs << Xf.new(:borderId=>0, :xfId=>0, :numFmtId=>0, :fontId=>0, :fillId=>0)
       @cellXfs << Xf.new(:borderId=>1, :xfId=>0, :numFmtId=>0, :fontId=>0, :fillId=>0)
+      # default date formatting
+      @cellXfs << Xf.new(:borderId=>0, :xfId=>0, :numFmtId=>14, :fontId=>0, :fillId=>0)
       @cellXfs.lock
 
       @dxfs = SimpleTypedList.new(Xf, "dxfs"); @dxfs.lock

data/lib/axlsx/util/constants.rb

@@ -199,6 +199,9 @@ module Axlsx
   # cellXfs id for thin borders around the cell
   STYLE_THIN_BORDER = 1
 
+  # cellXfs id for default date styling
+  STYLE_DATE = 2
+
   # error messages RestrictionValidor
   ERR_RESTRICTION = "Invalid Data: %s. %s must be one of %s." 
 
@@ -207,4 +210,7 @@ module Axlsx
 
   # error message for RegexValidator
   ERR_REGEX = "Invalid Data. %s does not match %s."
+
+  # error message for duplicate sheet names
+  ERR_DUPLICATE_SHEET_NAME = "There is already a worksheet in this workbook named '%s'. Please use a unique name"
 end

data/lib/axlsx/util/parser.rb

@@ -0,0 +1,43 @@
+module Axlsx
+  # The Parser module mixes in a number of methods to help in generating a model from xml
+  # This module is not included in the axlsx library at this time. It is for future development only,
+  module Parser
+
+    # The xml to be parsed
+    attr_accessor :parser_xml
+    
+    # parse and assign string attribute
+    def parse_string attr_name, xpath
+      send("#{attr_name.to_s}=", parse_value(xpath))
+    end
+    
+    # parse convert and assign node text to symbol
+    def parse_symbol attr_name, xpath
+      v = parse_value xpath
+      v = v.to_sym unless v.nil?
+      send("#{attr_name.to_s}=", v)
+    end
+    
+    # parse, convert and assign note text to integer
+    def parse_integer attr_name, xpath
+      v = parse_value xpath
+      v = v.to_i if v.respond_to?(:to_i)
+      send("#{attr_name.to_s}=", v)
+    end
+    
+    # parse, convert and assign node text to float
+    def parse_float attr_name, xpath
+      v = parse_value xpath
+      v = v.to_f if v.respond_to?(:to_f)
+      send("#{attr_name.to_s}=", v)
+    end
+
+    # return node text based on xpath
+    def parse_value xpath
+      node = parser_xml.xpath(xpath)
+      return nil if node.empty?
+      node.text.strip
+    end    
+    
+  end
+end

data/lib/axlsx/version.rb

@@ -1,4 +1,4 @@
 module Axlsx
   # version
-  VERSION="1.0.10"
+  VERSION="1.0.11"
 end

data/lib/axlsx/workbook/workbook.rb

@@ -71,7 +71,16 @@ require 'axlsx/workbook/worksheet/worksheet.rb'
 
     # Indicates if the epoc date for serialization should be 1904. If false, 1900 is used.
     @@date1904 = false
-    
+
+    # lets come back to this later when we are ready for parsing. 
+    #def self.parse entry
+    #  io = entry.get_input_stream
+    #  w = self.new
+    #  w.parser_xml = Nokogiri::XML(io.read)
+    #  w.parse_string :date1904, "//xmlns:workbookPr/@date1904"      
+    #  w
+    #end
+
     # Creates a new Workbook
     # @option options [Boolean] date1904
     def initialize(options={})
@@ -120,6 +129,17 @@ require 'axlsx/workbook/worksheet/worksheet.rb'
       r
     end
 
+    # returns a range of cells in a worksheet
+    # @param [String] cell_def The excel style reference defining the worksheet and cells. The range must specify the sheet to 
+    # retrieve the cells from. e.g. range('Sheet1!A1:B2') will return an array of four cells [A1, A2, B1, B2] while range('Sheet1!A1') will return a single Cell.
+    # @return [Cell, Array]
+    def [](cell_def)
+      sheet_name = cell_def.split('!')[0] if cell_def.match('!')
+      worksheet =  self.worksheets.select { |s| s.name == sheet_name }.first
+      raise ArgumentError, 'Unknown Sheet' unless sheet_name && worksheet.is_a?(Worksheet) 
+      worksheet[cell_def.gsub(/.+!/,"")]
+    end
+
     # Serializes the workbook document
     # @return [String]
     def to_xml()

data/lib/axlsx/workbook/worksheet/cell.rb

@@ -53,27 +53,137 @@ module Axlsx
 
 
     # The value of this cell.
-    # @return casted value based on cell's type attribute.
+    # @return [String, Integer, Float, Time] casted value based on cell's type attribute.
     attr_reader :value
     # @see value
     def value=(v)
       #TODO: consider doing value based type determination first?
       @value = cast_value(v)
     end
+    
+    # The inline font_name property for the cell
+    # @return [String]
+    attr_reader :font_name
+    # @see font_name
+    def font_name=(v) Axlsx::validate_string(v); @font_name = v; end
+
+    # The inline charset property for the cell
+    # @return [String]
+    attr_reader :charset
+    # @see charset
+    def charset=(v) Axlsx::validate_unsigned_int(v); @charset = v; end
+
+    # The inline family property for the cell
+    # @return [String]
+    attr_reader :family
+    # @see family
+    def family=(v) Axlsx::validate_string(v); @family = v; end
+
+    # The inline bold property for the cell
+    # @return [Boolean]
+    attr_reader :b
+    # @see b
+    def b=(v) Axlsx::validate_boolean(v); @b = v; end
+
+    # The inline italic property for the cell
+    # @return [Boolean]
+    attr_reader :i
+    # @see i
+    def i=(v) Axlsx::validate_boolean(v); @i = v; end
+
+    # The inline strike property for the cell
+    # @return [Boolean]
+    attr_reader :strike
+    # @see strike
+    def strike=(v) Axlsx::validate_boolean(v); @strike = v; end
+
+    # The inline outline property for the cell
+    # @return [Boolean]
+    attr_reader :outline
+    # @see outline
+    def outline=(v) Axlsx::validate_boolean(v); @outline = v; end
+
+    # The inline shadow property for the cell
+    # @return [Boolean]
+    attr_reader :shadow
+    # @see shadow
+    def shadow=(v) Axlsx::validate_boolean(v); @shadow = v; end
 
+    # The inline condense property for the cell
+    # @return [Boolean]
+    attr_reader :condense
+    # @see condense
+    def condense=(v) Axlsx::validate_boolean(v); @condense = v; end
+
+    # The inline extend property for the cell
+    # @return [Boolean]
+    attr_reader :extend
+    # @see extend
+    def extend=(v) Axlsx::validate_boolean(v); @extend = v; end
+
+    # The inline underline property for the cell
+    # @return [Boolean]
+    attr_reader :u
+    # @see u
+    def u=(v) Axlsx::validate_boolean(v); @u = v; end
+
+    # The inline color property for the cell
+    # @return [Color]
+    attr_reader :color
+    # @param [String] The 8 character representation for an rgb color #FFFFFFFF"
+    def color=(v) 
+      @color = v.is_a?(Color) ? v : Color.new(:rgb=>v)
+    end
+
+    # The inline sz property for the cell
+    # @return [Boolean]
+    attr_reader :sz
+    # @see sz
+    def sz=(v) Axlsx::validate_unsigned_int(v); @sz = v; end
+
+    # The inline vertical alignment property for the cell
+    # this must be one of [:baseline, :subscript, :superscript]
+    # @return [Symbol]
+    attr_reader :vertAlign
+    # @see vertAlign
+    def vertAlign=(v) RestrictionValidator.validate "Cell.vertAlign", [:baseline, :subscript, :superscript], v; @vertAlign = v; end
+
+    # The inline scheme property for the cell
+    # this must be one of [:none, major, minor]
+    # @return [Symbol]
+    attr_reader :scheme
+    # @see scheme
+    def scheme=(v) RestrictionValidator.validate "Cell.schema", [:none, :major, :minor], v; @scheme = v; end
 
     # @param [Row] row The row this cell belongs to.
     # @param [Any] value The value associated with this cell. 
     # @option options [Symbol] type The intended data type for this cell. If not specified the data type will be determined internally based on the vlue provided.
     # @option options [Integer] style The index of the cellXfs item to be applied to this cell. If not specified, the default style (0) will be applied.
+    # @option options [String] font_name
+    # @option options [Integer] charset
+    # @option options [String] family
+    # @option options [Boolean] b
+    # @option options [Boolean] i
+    # @option options [Boolean] strike
+    # @option options [Boolean] outline
+    # @option options [Boolean] shadow
+    # @option options [Boolean] condense
+    # @option options [Boolean] extend
+    # @option options [Boolean] u
+    # @option options [Symbol] vertAlign must be one of :baseline, :subscript, :superscript
+    # @option options [Integer] sz
+    # @option options [String] color an 8 letter rgb specification
+    # @option options [Symbol] scheme must be one of :none, major, :minor
     def initialize(row, value="", options={})
       self.row=row
-      #reference for validation
       @styles = row.worksheet.workbook.styles
-      @type= options[:type] || cell_type_from_value(value)
-      self.style = options[:style] || 0 
+      @style = 0 
+      @type = cell_type_from_value(value)
+      @row.cells << self      
+      options.each do |o|
+        self.send("#{o[0]}=", o[1]) if self.respond_to? "#{o[0]}="
+      end
       @value = cast_value(value)
-      @row.cells << self
     end
 
     # @return [Integer] The index of the cell in the containing row.
@@ -104,7 +214,10 @@ module Axlsx
       @style = v
     end
 
-
+    # @return [Array] of x/y coordinates in the cheet for this cell.
+    def pos
+      [index, row.index]
+    end
 
     # Serializes the cell
     # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
@@ -118,7 +231,45 @@ module Axlsx
       
       # however nokogiri does a nice 'force_encoding' which we shall remove!
       if @type == :string 
-        xml.c(:r => r, :t=>:inlineStr, :s=>style) { xml.is { xml.t @value.to_s } }
+        #parse formula
+        if @value.start_with?('=')
+          xml.c(:r => r, :s=>style) {
+            xml.f @value.to_s.gsub('=', '')
+          }
+        else
+          #parse standard string
+          #xml.c(:r => r, :t=>:inlineStr, :s=>style) {
+          #  xml.is { xml.t @value.to_s } 
+          #}
+          #parse styled string
+          xml.c(:r => r, :s=>style) {
+            xml.is {
+              xml.r {
+                xml.rPr {
+                  xml.rFont(:val=>@font_name) if @font_name
+                  xml.charset(:val=>@charset) if @charset
+                  xml.family(:val=>@family) if @family
+                  xml.b(:val=>@b) if @b
+                  xml.i(:val=>@i) if @i
+                  xml.strike(:val=>@strike) if @strike
+                  xml.outline(:val=>@outline) if @outline
+                  xml.shadow(:val=>@shadow) if @shadow
+                  xml.condense(:val=>@condense) if @condense
+                  xml.extend(:val=>@extend) if @extend
+                  @color.to_xml(xml) if @color
+                  xml.sz(:val=>@sz) if @sz
+                  xml.u(:val=>@u) if @u
+                  # :baseline, :subscript, :superscript
+                  xml.vertAlign(:val=>@vertAlign) if @verAlign
+                  # :none, major, :minor
+                  xml.scheme(:val=>@scheme) if @scheme
+                }
+                xml.t @value.to_s
+              }
+            }
+          }
+        end
+
       else
         xml.c(:r => r, :s => style) { xml.v value }
       end
@@ -169,6 +320,7 @@ module Axlsx
     def cast_value(v)
       if (@type == :time && v.is_a?(Time)) || (@type == :time && v.respond_to?(:to_time))
         v = v.respond_to?(:to_time) ? v.to_time : v
+        self.style = STYLE_DATE if self.style == 0
         # Using hardcoded offsets here as some operating systems will not except a 'negative' offset from the ruby epoc.
         # (1970)
         epoc1900 = -2209021200 #Time.local(1900, 1, 1) 

data/lib/axlsx/workbook/worksheet/row.rb

@@ -93,11 +93,13 @@ module Axlsx
     def array_to_cells(values, options={})
       values = values
       DataTypeValidator.validate 'Row.array_to_cells', Array, values
-      types, style = options[:types], options[:style]
+      types, style = options.delete(:types), options.delete(:style)
       values.each_with_index do |value, index|        
         cell_style = style.is_a?(Array) ? style[index] : style
+        options[:style] = cell_style if cell_style
         cell_type = types.is_a?(Array)? types[index] : types
-        Cell.new(self, value, :style=>cell_style, :type=>cell_type) 
+        options[:type] = cell_type if cell_type
+        Cell.new(self, value, options)
       end
     end
   end

data/lib/axlsx/workbook/worksheet/worksheet.rb

@@ -42,9 +42,44 @@ module Axlsx
       @cols = SimpleTypedList.new Cell
     end
 
+    # Returns the cell or cells defined using excel style A1:B3 references.
+    # @param [String] cell_def the string defining the cell or range of cells
+    # @return [Cell, Array]
+    def [](cell_def)
+      parts = cell_def.split(':')
+      first = name_to_cell parts[0]
+
+      if parts.size == 1
+        first
+      else
+        cells = []
+        last = name_to_cell(parts[1])
+        rows[(first.row.index..last.row.index)].each do |r|
+          r.cells[(first.index..last.index)].each do |c|
+            cells << c
+          end
+        end
+        cells
+      end
+    end
+
+    # returns the column and row index for a named based cell
+    # @param [String] name The cell or cell range to return. "A1" will return the first cell of the first row.
+    # @return [Cell]
+    def name_to_cell(name)
+      col_index, row_index = *Axlsx::name_to_indices(name)
+      r = rows[row_index]
+      r.cells[col_index] if r
+    end
+
     # The name of the worksheet
     # @param [String] v
-    def name=(v) DataTypeValidator.validate "Worksheet.name", String, v; @name=v end
+    def name=(v) 
+      DataTypeValidator.validate "Worksheet.name", String, v
+      sheet_names = @workbook.worksheets.map { |s| s.name }
+      raise ArgumentError, (ERR_DUPLICATE_SHEET_NAME % v) if sheet_names.include?(v) 
+      @name=v 
+    end
 
     # The part name of this worksheet
     # @return [String]
@@ -205,13 +240,12 @@ module Axlsx
       styles = self.workbook.styles
       cellXfs, fonts = styles.cellXfs, styles.fonts
       sz = fonts[0].sz
-
       cells.each_with_index do |item, index|
+        next if item.value.is_a?(String) && item.value.start_with?('=')
         col = @auto_fit_data[index] || {:longest=>"", :sz=>sz} 
         cell_xf = cellXfs[item.style]
         font = fonts[cell_xf.fontId || 0]
-        sz = font.sz || sz
-
+        sz = item.sz || font.sz || fonts[0].sz
         if (col[:longest].scan(/./mu).size * col[:sz]) < (item.value.to_s.scan(/./mu).size * sz)
           col[:sz] =  sz
           col[:longest] = item.value.to_s

data/test/drawing/tc_picture_locking.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'axlsx.rb'
+
+class TestPictureLocking < Test::Unit::TestCase
+  def setup    
+    @item = Axlsx::PictureLocking.new
+  end
+  def teardown
+  end
+
+  def test_initialiation
+    assert_equal(@item.instance_values.size, 1)
+    assert_equal(@item.noChangeAspect, true)
+  end
+
+  def test_noGrp
+    assert_raise(ArgumentError) { @item.noGrp = -1 }
+    assert_nothing_raised { @item.noGrp = false }
+    assert_equal(@item.noGrp, false )
+  end
+
+  def test_noRot
+    assert_raise(ArgumentError) { @item.noRot = -1 }
+    assert_nothing_raised { @item.noRot = false }
+    assert_equal(@item.noRot, false )
+  end
+
+  def test_noChangeAspect
+    assert_raise(ArgumentError) { @item.noChangeAspect = -1 }
+    assert_nothing_raised { @item.noChangeAspect = false }
+    assert_equal(@item.noChangeAspect, false )
+  end
+
+  def test_noMove
+    assert_raise(ArgumentError) { @item.noMove = -1 }
+    assert_nothing_raised { @item.noMove = false }
+    assert_equal(@item.noMove, false )
+  end
+
+  def test_noResize
+    assert_raise(ArgumentError) { @item.noResize = -1 }
+    assert_nothing_raised { @item.noResize = false }
+    assert_equal(@item.noResize, false )
+  end
+
+  def test_noEditPoints
+    assert_raise(ArgumentError) { @item.noEditPoints = -1 }
+    assert_nothing_raised { @item.noEditPoints = false }
+    assert_equal(@item.noEditPoints, false )
+  end
+
+  def test_noAdjustHandles
+    assert_raise(ArgumentError) { @item.noAdjustHandles = -1 }
+    assert_nothing_raised { @item.noAdjustHandles = false }
+    assert_equal(@item.noAdjustHandles, false )
+  end
+
+  def test_noChangeArrowheads
+    assert_raise(ArgumentError) { @item.noChangeArrowheads = -1 }
+    assert_nothing_raised { @item.noChangeArrowheads = false }
+    assert_equal(@item.noChangeArrowheads, false )
+  end
+
+  def test_noChangeShapeType
+    assert_raise(ArgumentError) { @item.noChangeShapeType = -1 }
+    assert_nothing_raised { @item.noChangeShapeType = false }
+    assert_equal(@item.noChangeShapeType, false )
+  end
+
+
+
+
+end