rmasalov-surpass 0.1.0

data/lib/surpass/formula.rb

@@ -0,0 +1,25 @@
+class Formula
+  NO_CALCS=0x00
+  RECALC_ALWAYS=0x01
+  CALC_ON_OPEN=0x02
+  PART_OF_SHARED_FORMULA=0x08
+
+  attr_reader :parser
+
+  def initialize(formula_string)
+    raise "formulas not available" unless FORMULAS_AVAILABLE
+    @lexer = ExcelFormula::Lexer.new(formula_string)
+    @parser = ExcelFormula::Parser.new(@lexer)
+    begin
+      @parser.formula
+    rescue RuntimeError => e
+      puts e
+      raise "invalid Excel formula"
+    end
+  end
+
+  def to_biff
+    rpn = @parser.rpn
+    [rpn.length].pack('v') + rpn
+  end
+end

data/lib/surpass/row.rb

@@ -0,0 +1,173 @@
+class Row
+  attr_accessor :index
+  attr_accessor :parent
+  attr_accessor :parent_wb
+  attr_accessor :cells
+  attr_accessor :min_col_index
+  attr_accessor :max_col_index
+  attr_accessor :total_str
+  attr_accessor :xf_index
+  attr_accessor :has_default_format
+  attr_accessor :height_in_pixels
+  
+  attr_accessor :height
+  attr_accessor :has_default_height
+  attr_accessor :height_mismatch
+  attr_accessor :level
+  attr_accessor :collapse
+  attr_accessor :hidden
+  attr_accessor :space_above
+  attr_accessor :space_below
+
+  def initialize(index, parent_sheet)
+    is_int = index.is_a?(Integer)
+    in_range = (index >= 0) && (index <= 65535)
+    raise "row index #{index} is not valid" unless is_int && in_range
+    
+    @index = index
+    @parent = parent_sheet
+    @parent_wb = parent_sheet.parent()
+    @cells = []
+    @min_col_index = 0
+    @max_col_index = 0
+    @total_str = 0
+    @xf_index = 0x0F
+    @has_default_format = 0
+    @height_in_pixels = 0x11
+    
+    @height = 0x00FF
+    @has_default_height = 0x00
+    @height_mismatch = 0
+    @level = 0
+    @collapse = 0
+    @hidden = 0
+    @space_above = 0
+    @space_below = 0
+  end
+  
+  def adjust_height(style)
+    twips = style.font.height
+    points = twips/20.0
+    # Cell height in pixels can be calcuted by following approx. formula:
+    # cell height in pixels = font height in points * 83/50 + 2/5
+    # It works when screen resolution is 96 dpi 
+    pix = (points*83.0/50.0 + 2.0/5.0).round
+    @height_in_pixels = pix if (pix > @height_in_pixels)
+  end
+
+  def set_height(height)
+    @height = height * 20 #This seems to correspond to row height in excel.
+    @height_mismatch = 1
+  end
+  
+  def adjust_boundary_column_indexes(*args)
+    args.each do |a|
+      is_int = (a.to_i == a)
+      in_range = (0 <= a) && (a <= 255)
+      raise "invalid boundary index #{a}" unless is_int && in_range
+      @min_col_index = a if a < @min_col_index
+      @max_col_index = a if a > @max_col_index
+    end
+  end
+  
+  # TODO can we get rid of this? Tests pass if it is commented out.
+  def style=(style)
+    adjust_height(style)
+    @xf_index = @parent_wb.styles.add(style)
+    @has_default_format = 1
+  end
+  
+  def cells_count
+    @cells.length
+  end
+ 
+  ### @export "to-biff"
+  def to_biff
+    height_options = (@height & 0x07FFF)
+    height_options |= (@has_default_height & 0x01) << 15
+    
+    options =  (@level & 0x07) << 0
+    options |= (@collapse & 0x01) << 4
+    options |= (@hidden & 0x01) << 5
+    options |= (@height_mismatch & 0x01) << 6
+    options |= (@has_default_format & 0x01) << 7
+    options |= (0x01 & 0x01) << 8
+    options |= (@xf_index & 0x0FFF) << 16
+    options |= (@space_above & 0x01) << 28
+    options |= (@space_below & 0x01) << 29
+
+    args = [@index, @min_col_index, @max_col_index, height_options, options]
+    RowRecord.new(*args).to_biff
+  end
+  
+  def cells_biff
+    cells.collect {|c| c.to_biff }.join
+  end
+  ### @end
+  
+  def cell(col_index)
+    cells.select {|c| c.index == col_index}.first
+  end
+  
+  def write(col, label, style)
+    case style
+    when StyleFormat
+      # leave it alone
+    when Hash
+      style = StyleFormat.new(style)
+### @export "autoformats"
+    when TrueClass # Automatically apply a nice numeric format.
+      case label
+      when DateTime, Time
+        style = @parent_wb.styles.default_datetime_style
+      when Date
+        style = @parent_wb.styles.default_date_style
+      when Float
+        style = @parent_wb.styles.default_float_style
+      else
+        style = @parent_wb.styles.default_style
+      end
+### @end
+    when NilClass
+      style = @parent_wb.styles.default_style
+    else
+      raise "I don't know how to use this to format a cell #{style.inspect}"
+    end
+
+    style_index = @parent_wb.styles.add(style)
+
+    raise "trying to write to cell #{self.index}, #{col} - already exists!" if cell(col)
+    
+    adjust_height(style)
+    adjust_boundary_column_indexes(col)
+
+    ### @export "label-classes"
+    case label
+    when TrueClass, FalseClass
+      @cells << BooleanCell.new(self, col, style_index, label)
+    when String, NilClass
+      if label.to_s.length == 0
+        @cells << BlankCell.new(self, col, style_index)
+      else
+        @cells << StringCell.new(self, col, style_index, @parent_wb.sst.add_str(label))
+        @total_str += 1
+      end
+    when Numeric
+      @cells << NumberCell.new(self, col, style_index, label)
+    when Date, DateTime, Time
+      @cells << NumberCell.new(self, col, style_index, as_excel_date(label))
+    when Formula
+      @cells << FormulaCell.new(self, col, style_index, label)
+    else
+      raise "You are trying to write an object of class #{label.class.name} to a spreadsheet. Please convert this to a supported class such as String."
+    end
+    ### @end
+  end
+  
+  def write_blanks(c1, c2, style)
+    raise unless c1 <= c2
+    adjust_height(style)
+    adjust_boundary_column_indexes(c1, c2)
+    @cells << MulBlankCell.new(self, c1, c2, @parent_wb.styles.add(style))
+  end
+end

data/lib/surpass/style.rb

@@ -0,0 +1,194 @@
+class StyleFormat
+  attr_accessor :number_format_string
+  attr_accessor :font
+  attr_accessor :alignment
+  attr_accessor :borders
+  attr_accessor :pattern
+  attr_accessor :protection
+  
+  def initialize(hash = {})
+    @number_format_string = hash[:number_format_string] || 'General'
+
+    @font           = Font.new(hash_select(hash, /^font_/))
+    @alignment      = Alignment.new(hash_select(hash, /^text_/))
+    @borders        = Borders.new(hash_select(hash, /^border_/))
+    @pattern        = Pattern.new(hash_select(hash, /^(fill|pattern)_/))
+    @protection     = Protection.new
+  end
+  
+  def hash_select(hash, pattern)
+    new_hash = {}
+    hash.keys.each do |k|
+      next unless k.to_s =~ pattern
+      new_key = k.to_s.gsub(pattern, '').to_sym
+      new_hash[new_key] = hash[k]
+    end
+    new_hash
+  end
+end
+
+class StyleCollection
+  attr_accessor :fonts
+  attr_accessor :number_formats
+  attr_accessor :styles
+  attr_accessor :default_style
+  attr_accessor :default_format
+  
+  FIRST_USER_DEFINED_NUM_FORMAT_INDEX = 164
+  
+  STANDARD_NUMBER_FORMATS = [
+    'General',
+    '0',
+    '0.00',
+    '#,##0',
+    '#,##0.00',
+    '"$"#,##0_);("$"#,##',
+    '"$"#,##0_);[Red]("$"#,##',
+    '"$"#,##0.00_);("$"#,##',
+    '"$"#,##0.00_);[Red]("$"#,##',
+    '0%',
+    '0.00%',
+    '0.00E+00',
+    '# ?/?',
+    '# ??/??',
+    'M/D/YY',
+    'D-MMM-YY',
+    'D-MMM',
+    'MMM-YY',
+    'h:mm AM/PM',
+    'h:mm:ss AM/PM',
+    'h:mm',
+    'h:mm:ss',
+    'M/D/YY h:mm',
+    '_(#,##0_);(#,##0)',
+    '_(#,##0_);[Red](#,##0)',
+    '_(#,##0.00_);(#,##0.00)',
+    '_(#,##0.00_);[Red](#,##0.00)',
+    '_("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_(@_)',
+    '_(* #,##0_);_(* (#,##0);_(* "-"_);_(@_)',
+    '_("$"* #,##0.00_);_("$"* (#,##0.00);_("$"* "-"??_);_(@_)',
+    '_(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)',
+    'mm:ss',
+    '[h]:mm:ss',
+    'mm:ss.0',
+    '##0.0E+0',
+    '@'   
+  ]
+  
+  def initialize
+    # Populate default font list.
+    @fonts = {}
+    # Initialize blank fonts into slots 0,1,2,3,5 in order to skip slot 4.
+    [0,1,2,3,5].each do |i|
+      @fonts[i] = Font.new
+    end
+    
+    # Populate default number format list.
+    @number_formats = {}
+    STANDARD_NUMBER_FORMATS.each_with_index do |s, i|
+      index = (i <= 23) ? i : i + 14
+      @number_formats[index] = s
+    end
+    
+    @styles = {}
+    @default_style = StyleFormat.new
+    
+    # Store the 6 parameters of the default_style
+    @default_format = add_style(@default_style)[0]
+  end
+  
+### @export "autoformats"
+  def default_date_style
+    @default_date_style ||= StyleFormat.new(:number_format_string => 'dd-mmm-yyyy')
+  end
+
+  def default_datetime_style
+    @default_datetime_style ||= StyleFormat.new(:number_format_string => 'dd-mmm-yyyy hh:mm:ss')
+  end
+
+  def default_float_style
+    @default_float_style ||= StyleFormat.new(:number_format_string => '#,##0.00')
+  end
+### @end
+
+  def add(style)
+    if style.nil?
+      0x10 # Return the index of the default style.
+    else
+      # TODO find way to freeze style so if someone modifies a StyleFormat instance it won't affect previously formatted cells.
+      add_style(style)[1] # Return the index of the style just stored.
+    end
+  end
+  
+  def number_format_index(number_format_string)
+    index = @number_formats.index(number_format_string)
+    if index.nil?
+      # TODO implement regex to check if valid string
+      index = FIRST_USER_DEFINED_NUM_FORMAT_INDEX + @number_formats.length - STANDARD_NUMBER_FORMATS.length
+      @number_formats[index] = number_format_string
+    end
+    index
+  end
+  
+  def font_index(font)
+    index = @fonts.index(font)
+    if index.nil?
+      index = @fonts.length + 1
+      @fonts[index] = font
+    end
+    index
+  end
+  
+  def format_index(format)
+    index = @styles.index(format)
+    if index.nil?
+      index = 0x10 + @styles.length
+      @styles[index] = format
+    end
+    index
+  end
+  
+  private
+  # This is private, please use add(style) instead.
+  def add_style(style)
+    number_format_index = number_format_index(style.number_format_string)
+    font_index = font_index(style.font)
+    
+    format = [font_index, number_format_index, style.alignment, style.borders, style.pattern, style.protection]
+    [format, format_index(format)]
+  end
+  
+  public
+  def to_biff
+    fonts_biff + number_formats_biff + cell_styles_biff + StyleRecord.new.to_biff
+  end
+  
+  # TODO use inject here?
+  def fonts_biff
+    result = ''
+    @fonts.sort.each do |i, f|
+      result += f.to_biff
+    end
+    result
+  end
+  
+  def number_formats_biff
+    result = ''
+    @number_formats.sort.each do |i, f|
+      next if i < FIRST_USER_DEFINED_NUM_FORMAT_INDEX
+      result += NumberFormatRecord.new(i, f).to_biff
+    end
+    result
+  end
+  
+  def cell_styles_biff
+    result = ''
+    0.upto(15) do |i|
+      result += XFRecord.new(@default_format, 'style').to_biff
+    end
+    @styles.sort.each do |i, f|
+      result += XFRecord.new(f).to_biff
+    end
+    result
+  end
+end

data/lib/surpass/surpass_cell.rb

@@ -0,0 +1,187 @@
+class SurpassCell
+  attr_reader :index
+
+  def set_style(style)
+    style = StyleFormat.new(style) if style.is_a?(Hash)
+    @format_index = @parent.parent_wb.styles.add(style)
+  end
+
+  def row
+    @parent
+  end
+
+  def col
+    @index
+  end
+end
+
+### @export "string-cell"
+class StringCell < SurpassCell
+  def initialize(parent, index, format_index, sst_index)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @sst_index = sst_index
+  end
+
+  def to_biff
+    LabelSSTRecord.new(@parent.index, @index, @format_index, @sst_index).to_biff
+  end
+end
+
+### @export "blank-cell"
+class BlankCell < SurpassCell
+  def initialize(parent, index, format_index)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+  end
+
+  def to_biff
+    BlankRecord.new(@parent.index, @index, @format_index).to_biff
+  end
+end
+### @end
+
+class NumberCell < SurpassCell
+  def initialize(parent, index, format_index, number)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @number = number
+  end
+
+  def rk_record(rk_encoded)
+    RKRecord.new(@parent.index, @index, @format_index, rk_encoded).to_biff
+  end
+
+  # TODO test this section to be sure numbers are categorized and packed correctly.
+  def to_biff
+    # 30 bit signed int
+    in_range = (-0x20000000 <= @number) && (@number < 0x20000000)
+    is_int = (@number.to_i == @number)
+    if in_range && is_int
+      rk_encoded = 2 | (@number.to_i << 2)
+      return rk_record(rk_encoded)
+    end
+
+    # try scaling by 100 then using a 30 bit signed int
+    in_range = (-0x20000000 <= @number * 100) && (@number * 100 < 0x20000000)
+    round_trip = (@number.to_i*100) == @number*100
+    if in_range && round_trip
+      rk_encoded = (3 | (@number.to_i*100 << 2))
+      return rk_record(rk_encoded)
+    end
+
+    w0, w1, w2, w3 = [@number].pack('E').unpack('v4')
+
+    is_float_rk = (w0 == 0) && (w1 == 0) && (w2 & 0xFFFC) == w2
+    if is_float_rk
+      rk_encoded = (w3 << 16) | w2
+      return rk_record(rk_encoded)
+    end
+
+    w0, w1, w2, w3 = [@number * 100].pack('E').unpack('v4')
+
+    is_float_rk_100 = w0 == 0 && w1 == 0 && w2 & 0xFFFC == w2
+    if is_float_rk_100
+      rk_encoded = 1 | (w3 << 16) | w2
+      return rk_record(rk_encoded)
+    end
+
+    # If not an RK value, use a NumberRecord instead.
+    NumberRecord.new(@parent.index, @index, @format_index, @number).to_biff
+  end
+end
+
+class MulNumberCell < SurpassCell
+  def initialize(parent, index, format_index, sst_index)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @sst_index = sst_index
+  end
+
+  def to_biff
+    raise "not implemented"
+  end
+end
+
+class MulBlankCell < SurpassCell
+  def initialize(parent, col1, col2, xf_idx)
+    raise unless col1 < col2
+    @parent = parent
+    @col1 = col1
+    @col2 = col2
+    @xf_idx = xf_idx
+  end
+
+  def to_biff
+    MulBlankRecord.new(@parent.index, @col1, @col2, @xf_idx).to_biff
+  end
+end
+
+### @export "formula-cell"
+class FormulaCell < SurpassCell
+  def initialize(parent, index, format_index, formula, calc_flags = 0)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @formula = formula
+    @calc_flags = calc_flags
+  end
+
+  def to_biff
+    args = [@parent.index, @index, @format_index, @formula.to_biff, @calc_flags]
+    FormulaRecord.new(*args).to_biff
+  end
+end
+### @end
+
+class BooleanCell < SurpassCell
+  def initialize(parent, index, format_index, number)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @number = number
+    @is_error = 0
+  end
+
+  def to_biff
+    number = @number ? 1 : 0
+    BoolErrRecord.new(@parent.index, @index, @format_index, number, @is_error).to_biff
+  end
+end
+
+class ErrorCell < SurpassCell
+  ERROR_CODES = {
+      0x00 =>  0, # Intersection of two cell ranges is empty
+      0x07 =>  7, # Division by zero
+      0x0F => 15, # Wrong type of operand
+      0x17 => 23, # Illegal or deleted cell reference
+      0x1D => 29, # Wrong function or range name
+      0x24 => 36, # Value range overflow
+      0x2A => 42, # Argument or function not available
+      '#NULL!'  =>  0, # Intersection of two cell ranges is empty
+      '#DIV/0!' =>  7, # Division by zero
+      '#VALUE!' => 36, # Wrong type of operand
+      '#REF!'   => 23, # Illegal or deleted cell reference
+      '#NAME?'  => 29, # Wrong function or range name
+      '#NUM!'   => 36, # Value range overflow
+      '#N/A!'   => 42  # Argument or function not available
+  }
+
+  def initialize(parent, index, format_index, error_string_or_code)
+    @parent = parent
+    @index = index
+    @format_index = format_index
+    @number = ERROR_CODES[error_string_or_code]
+    @is_error = 1
+
+    raise "invalid error code #{error_string_or_code}" if @number.nil?
+  end
+
+  def to_biff
+    BoolErrRecord.new(@parent.index, @index, @format_index, @number, @is_error)
+  end
+end