slayer-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/tokens.txt

@@ -0,0 +1,2 @@
+'B' -> 'C'
+'2B' -> 'C2'

data/lib/surpass/utilities.rb

@@ -0,0 +1,118 @@
+module Utilities
+  # For ease of comparing with pyExcelerator output values
+  # python seems to automatically decode to hex values
+  def hex_array_to_binary_string(array_of_hex_values)
+    [array_of_hex_values.collect {|h| [sprintf("%02x", h)]}.join].pack('H*')
+  end
+  
+  def binary_string_to_hex_array(binary_string)
+    binary_string.unpack("H*")
+  end
+  
+  def points_to_pixels(points)
+    points*(4.0/3)
+  end
+  
+  def pixels_to_points(pixels)
+    pixels * (3.0 / 4)
+  end
+  
+  def twips_to_pixels(twips)
+    twips / 15.0
+  end
+  
+  def pixels_to_twips(pixels)
+    pixels * 15.0
+  end
+  
+  def as_excel_date(date)
+    date = DateTime.parse(date.strftime("%c")) if date.is_a?(Time)
+    excel_date = (date - Date.civil(1899, 12, 31)).to_f
+    excel_date += 1 if excel_date > 59 # Add a day for Excel's missing leap day in 1900
+    excel_date
+  end
+  
+  def mock_unicode_string(s)
+    [s.length, 0].pack('vC') + s
+  end
+  
+  
+  def as_boolean(input)
+    case input
+    when 1, true
+      true
+    when 0, false
+      false
+    else
+      raise "Can't convert #{input} from excel boolean!"
+    end
+  end
+  
+  def as_numeric(input)
+    case input
+    when true, 1
+      1
+    when false, 0
+      0
+    else
+      raise "Can't convert #{input} to excel boolean!"
+    end
+  end
+  
+  # Mimic python's "hex" function 0x00
+  def hex(value)
+    "0x" + value.to_s(16)
+  end
+  
+  RE_CELL_EX = /^(\$)?([A-I]?[A-Z])(\$?)(\d+)$/i
+
+  def col_by_name(column_name)
+    col = 0
+    pow = 1
+    column_name.reverse.each_byte do |l|
+      col += (l - 64) * pow
+      pow *= 26
+    end
+    col - 1
+  end
+
+  def cell_to_rowcol(cell)
+    match = RE_CELL_EX.match(cell)
+    raise "Ill-formed single cell reference #{cell}" if match.nil?
+    col_abs, col, row_abs, row = match.captures
+    row = row.to_i - 1
+    col = col_by_name(col.upcase)
+    [row, col, row_abs.nil?, col_abs.nil?]
+  end
+
+  def cell_to_packed_rowcol(cell)
+    row, col, row_abs, col_abs = cell_to_rowcol(cell)
+    raise "Column #{col} is greater than IV (#{MAX_COL})" if col >= MAX_COL
+    raise "Row #{row} is greater than #{MAX_ROW} in #{cell}" if row >= MAX_ROW
+
+    col |= row_abs.to_i << 15
+    col |= col_abs.to_i << 14
+
+    [row, col]
+  end
+end
+
+def String.random_alphanumeric(size=16)
+  s = ""
+  size.times { s << (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61 ))).chr }
+  s
+end
+
+class TrueClass
+  def to_i
+    1
+  end
+end
+
+class FalseClass
+  def to_i
+    0
+  end
+end
+
+include Utilities