surpass 0.0.4 → 0.0.6

data/lib/{formatting.rb → surpass/formatting.rb}

@@ -8,7 +8,6 @@ module Formatting
     'brown' => 0x3c,
     'coral' => 0x1d,
     'cornflower-blue' => 0x18,
-    'cyan'    => 0x0F,
     'dark-blue' => 0x12,
     'dark-green' => 0x3a,
     'dark-red' => 0x10,
@@ -32,17 +31,14 @@ module Formatting
     'light-orange' => 0x34,
     'light-turquoise' => 0x29,
     'light-yellow' => 0x2b,
-    'lime'    => 0x0B,
     'lime' => 0x32,
     'magenta' => 0x0E,
     'maroon' => 0x19,
-    'navy'    => 0x12,
     'olive-green' => 0x3b,
     'orange' => 0x35,
     'orchid' => 0x1c,
     'pale-blue' => 0x2c,
     'pink'    => 0x21,
-    'pink' => 0xe,
     'plum' => 0x3d,
     'purple'  => 0x14,
     'red'     => 0x0A,
@@ -115,7 +111,7 @@ class Font
   attr_accessor :shadow
   attr_accessor :colour_index
   attr_accessor :bold
-  attr_accessor :weight # In practice, seems to be only 400 = normal, 700 = bold so just use bold = true.
+  attr_accessor :weight # Looks like only 400 = normal, 700 = bold are supported so just use bold = true.
   attr_accessor :escapement
   attr_accessor :charset
   attr_accessor :name
@@ -410,6 +406,10 @@ class Borders
     LINE_TYPE_DIRECTIVES.collect {|k, v| v}
   end
   
+  def self.line_type_directives_hash
+    Hash[*LINE_TYPE_DIRECTIVES.flatten]
+  end
+  
   def initialize(hash = {})
     @left   = NO_LINE
     @right  = NO_LINE
@@ -456,8 +456,7 @@ class Borders
       end
       
       if Borders.line_type_directives.include?(a)
-        line_type_directives_hash = Hash[*LINE_TYPE_DIRECTIVES.flatten]
-        instructions[0] = line_type_directives_hash[a]
+        instructions[0] = Borders.line_type_directives_hash[a]
         next
       end
       
@@ -488,50 +487,64 @@ class Borders
     @bottom, @bottom_colour = process_directives(directives)
   end
 end
-# public final static short     NO_FILL             = 0  ;
-# /**  Solidly filled */
-# public final static short     SOLID_FOREGROUND    = 1  ;
-# /**  Small fine dots */
-# public final static short     FINE_DOTS           = 2  ;
-# /**  Wide dots */
-# public final static short     ALT_BARS            = 3  ;
-# /**  Sparse dots */
-# public final static short     SPARSE_DOTS         = 4  ;
-# /**  Thick horizontal bands */
-# public final static short     THICK_HORZ_BANDS    = 5  ;
-# /**  Thick vertical bands */
-# public final static short     THICK_VERT_BANDS    = 6  ;
-# /**  Thick backward facing diagonals */
-# public final static short     THICK_BACKWARD_DIAG = 7  ;
-# /**  Thick forward facing diagonals */
-# public final static short     THICK_FORWARD_DIAG  = 8  ;
-# /**  Large spots */
-# public final static short     BIG_SPOTS           = 9  ;
-# /**  Brick-like layout */
-# public final static short     BRICKS              = 10 ;
-# /**  Thin horizontal bands */
-# public final static short     THIN_HORZ_BANDS     = 11 ;
-# /**  Thin vertical bands */
-# public final static short     THIN_VERT_BANDS     = 12 ;
-# /**  Thin backward diagonal */
-# public final static short     THIN_BACKWARD_DIAG  = 13 ;
-# /**  Thin forward diagonal */
-# public final static short     THIN_FORWARD_DIAG   = 14 ;
-# /**  Squares */
-# public final static short     SQUARES             = 15 ;
-# /**  Diamonds */
-# public final static short     DIAMONDS            = 16 ;
-# /**  Less Dots */
-# public final static short     LESS_DOTS           = 17 ;
-# /**  Least Dots */
-# public final static short     LEAST_DOTS          = 18 ;
+
+
 class Pattern
   NO_PATTERN      = 0x00 
-  SOLID_PATTERN   = 0x01
+  SOLID_FOREGROUND   = 0x01
+  SOLID_PATTERN = SOLID_FOREGROUND # for backwards compatibility
+  FINE_DOTS = 0x02
+  ALT_BARS = 0x03
+  SPARSE_DOTS = 0x04
+  THICK_HORZ_BANDS = 0x05
+  THICK_VERT_BANDS = 0x06
+  THICK_BACKWARD_DIAG = 0x07
+  THICK_FORWARD_DIAG = 0x08
+  BIG_SPOTS = 0x09
+  BRICKS = 0x0A
+  THIN_HORZ_BANDS = 0x0B
+  THIN_VERT_BANDS = 0x0C
+  THIN_BACKWARD_DIAG = 0x0D
+  THIN_FORWARD_DIAG = 0x0E
+  SQUARES = 0x0F
+  DIAMONDS = 0x10
+  LESS_DOTS = 0x11
+  LEAST_DOTS = 0x12
   
-  attr_accessor :pattern
-  attr_accessor :pattern_fore_colour
-  attr_accessor :pattern_back_colour
+  # Want to keep these sorted in this order, so need nested array instead of hash.
+  PATTERN_DIRECTIVES = [
+    ['none', NO_PATTERN],
+    ['solid', SOLID_FOREGROUND],
+    ['fine-dots', FINE_DOTS],
+    ['alt-bars', ALT_BARS],
+    ['sparse-dots', SPARSE_DOTS],
+    ['thick-horz-bands', THICK_HORZ_BANDS],
+    ['thick-vert-bands', THICK_VERT_BANDS],
+    ['thick-backward-diag', THICK_BACKWARD_DIAG],
+    ['thick-forward-diag', THICK_FORWARD_DIAG],
+    ['big-spots', BIG_SPOTS],
+    ['bricks', BRICKS],
+    ['thin-horz-bands', THIN_HORZ_BANDS],
+    ['thin-vert-bands', THIN_VERT_BANDS],
+    ['thin-backward-diag', THIN_BACKWARD_DIAG],
+    ['thin-forward-diag', THIN_FORWARD_DIAG],
+    ['squares', SQUARES],
+    ['diamonds', DIAMONDS],
+    ['less-dots', LESS_DOTS],
+    ['least-dots', LEAST_DOTS]
+  ]
+  
+  attr_reader :pattern
+  attr_reader :pattern_fore_colour
+  attr_reader :pattern_back_colour
+  
+  def self.fill_directives
+    PATTERN_DIRECTIVES.collect {|a| a[0]}
+  end
+  
+  def self.directives_hash
+    Hash[*PATTERN_DIRECTIVES.flatten]
+  end
   
   def initialize(hash = {})
     @pattern = NO_PATTERN
@@ -543,12 +556,39 @@ class Pattern
     end
   end
   
-  # Convenience method to set fill colour
+  def pattern=(arg)
+    case arg
+    when String
+      pattern_index = Pattern.directives_hash[arg]
+    when Integer
+      pattern_index = arg
+    else
+      raise "I don't know how to interpret #{arg.inspect} as a pattern!"
+    end
+    raise "invalid pattern #{arg}" if pattern_index.nil?
+    
+    @pattern = pattern_index
+  end
+  
+  def fore_colour=(arg)
+   colour_index = Formatting::COLOURS[arg]
+   raise "Invalid colour #{arg}" if colour_index.nil?
+   @pattern_fore_colour = colour_index
+  end
+  alias :fore_color= :fore_colour=
+
+  def back_colour=(arg)
+   colour_index = Formatting::COLOURS[arg]
+   raise "Invalid colour #{arg}" if colour_index.nil?
+   @pattern_back_colour = colour_index
+  end
+  alias :back_color= :back_colour=
+  
+  # Sets the foreground colour, also if no pattern has been specified
+  # will assume you want a solid colour fill.
   def colour=(arg)
-    colour_index = Formatting::COLOURS[arg]
-    raise "Invalid colour #{arg}" if colour_index.nil?
-    @pattern = SOLID_PATTERN
-    @pattern_fore_colour = colour_index
+    self.fore_colour = arg
+    @pattern = SOLID_PATTERN if @pattern == NO_PATTERN
   end
   alias :color= :colour=
   alias :fill= :colour=

data/lib/{style.rb → surpass/style.rb}

@@ -12,7 +12,7 @@ class StyleFormat
     @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        = Pattern.new(hash_select(hash, /^(fill|pattern)_/))
     @protection     = Protection.new
   end
   
@@ -115,6 +115,7 @@ class StyleCollection
     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

data/lib/surpass/tokens.txt

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

data/lib/{worksheet.rb → surpass/worksheet.rb}

@@ -38,7 +38,7 @@ class Worksheet
   
   attr_accessor :delta
   attr_accessor :save_recalc
-  
+  attr_accessor :formula_options
   attr_accessor :print_headers
   attr_accessor :print_grid
   attr_accessor :grid_set
@@ -269,24 +269,32 @@ class Worksheet
     end
   end
 
-  # Write the text stored in label in a single cell at (r,c) according to style.
+# TODO get rid of meaningless default value for label, should be required?
+### @export "write-method"
   def write(r, c, label = "", style = nil)
-    row(r).write(c, label, style)
+    if label.is_a?(Array)
+      if label[0].is_a?(Array)
+        write_arrays(r, c, label, style || true)
+      else
+        write_array_to_row(label, r, c)
+      end
+    else
+      row(r).write(c, label, style)
+    end
   end
-  
+
+### @export "write-arrays"
   def write_array_to_row(array, r, c = 0, style = true)
     array.each_with_index do |a, i|
       row(r).write(c + i, a, style)
     end
   end
-  alias :rarray :write_array_to_row
 
   def write_array_to_column(array, c, r = 0, style = true)
     array.each_with_index do |a, i|
       row(r + i).write(c, a, style)
     end
   end
-  alias :carray :write_array_to_column
   
   def write_arrays(r, c, array_of_arrays, style = true)
     array_of_arrays.each_with_index do |a, i|
@@ -294,6 +302,7 @@ class Worksheet
       write_array_to_row(a, r + i, c, style)
     end
   end
+### @end
   
   # Comment from xlwt:
   ## Stand-alone merge of previously written cells.

data/lib/surpass.rb

@@ -1,7 +1,7 @@
 module Surpass
 
   # :stopdoc:
-  VERSION = '0.0.4'
+  VERSION = '0.0.6'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/spec/biff_record_spec.rb

@@ -0,0 +1,268 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe InterfaceHeaderRecord do
+  it "should pack correctly" do
+    b = InterfaceHeaderRecord.new
+    b.to_biff.unpack('M*').should === ["\341\000\002\000\260\004"]
+  end
+end
+
+describe InterfaceEndRecord do
+  it "should pack correctly" do
+    b = InterfaceEndRecord.new
+    b.to_biff.unpack('M*').should === ["\342\000\000\000"]
+  end
+end
+
+describe MMSRecord do
+  it "should pack correctly" do
+    b = MMSRecord.new
+    b.to_biff.unpack('M*').should === ["\301\000\002\000\000\000"]
+  end
+end
+
+describe WriteAccessRecord do
+  it "should pack correctly" do
+    b = WriteAccessRecord.new("Ana")
+    b.to_biff.unpack('M*').should === ["\\\000p\000Ana" + " " * 109]
+  end
+end
+
+describe DSFRecord do
+  it "should pack correctly" do
+    b = DSFRecord.new
+    b.to_biff.unpack('M*').should === ["a\001\002\000\000\000"]
+  end
+end
+
+describe TabIDRecord do
+  it "should pack correctly" do
+    b = TabIDRecord.new(2)
+    b.record_data.should === "\001\000\002\000"
+    b.to_biff.unpack('A*').should === ["=\001\004\000\001\000\002"]
+  end
+end
+
+describe FnGroupCountRecord do
+  it "should pack correctly" do
+    b = FnGroupCountRecord.new
+    b.record_data.should === "\016\000"
+    b.to_biff.unpack('A*').should === ["\234\000\002\000\016"]
+  end
+end
+
+describe WindowProtectRecord do
+  it "should pack correctly" do
+    b = WindowProtectRecord.new(0)
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\031\000\002"]
+  end
+end
+
+describe ObjectProtectRecord do
+  it "should pack correctly" do
+    b = ObjectProtectRecord.new(0)
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["c\000\002"]
+  end
+end
+
+describe ScenarioProtectRecord do
+  it "should pack correctly" do
+    b = ScenarioProtectRecord.new(0)
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\335\000\002"]
+  end
+end
+
+describe PasswordRecord do
+  before(:each) do
+    @b = PasswordRecord.new
+  end
+  it "should pack correctly with blank password" do
+    @b.password_hash("").should == 0
+  end
+  
+  it "should pack correctly with a password of 123456" do
+    @b.password_hash("123456").should === 50975
+  end
+  
+  it "should pack correctly with a password of abcdefghij" do
+    @b.password_hash("abcdefghij").should == 65265
+  end
+  
+  it "should pack correctly with a password of ok" do
+    @b.password_hash("ok").should == 53051
+  end
+end
+
+describe Prot4RevRecord do
+  it "should pack correctly" do
+    b = Prot4RevRecord.new
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\257\001\002"]
+  end
+end
+
+describe Prot4RevPassRecord do
+  it "should pack correctly" do
+    b = Prot4RevPassRecord.new
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\274\001\002"]
+  end
+end
+
+describe BackupRecord do
+  it "should pack correctly" do
+    b = BackupRecord.new(0)
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["@\000\002"]
+  end
+end
+
+describe HideObjRecord do
+  it "should pack correctly" do
+    b = HideObjRecord.new
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\215\000\002"]
+  end
+end
+
+describe RefreshAllRecord do
+  it "should pack correctly" do
+    b = RefreshAllRecord.new
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\267\001\002"]
+  end
+end
+
+describe BookBoolRecord do
+  it "should pack correctly" do
+    b = BookBoolRecord.new
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\332\000\002"]
+  end
+end
+
+describe CountryRecord do
+  it "should pack correctly" do
+    b = CountryRecord.new(1,1)
+    b.record_data.should === "\001\000\001\000"
+    b.to_biff.unpack('A*').should === ["\332\000\004\000\001\000\001"]
+  end
+end
+
+describe UseSelfsRecord do
+  it "should pack correctly" do
+    b = UseSelfsRecord.new
+    b.record_data.should === "\001\000"
+    b.to_biff.unpack('A*').should === ["`\001\002\000\001"]
+  end
+end
+
+describe EOFRecord do
+  it "should pack correctly" do
+    b = EOFRecord.new
+    b.record_data.should === ""
+    b.to_biff.unpack('A*').should === ["\n"]
+  end
+end
+
+describe DateModeRecord do
+  it "should pack correctly when passed true" do
+    b = DateModeRecord.new(true)
+    b.record_data.should === "\001\000"
+    b.to_biff.unpack('A*').should === ["\"\000\002\000\001"]
+  end
+  it "should pack correctly when passed false" do
+    b = DateModeRecord.new(false)
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\"\000\002"]
+  end
+end
+
+describe PrecisionRecord do
+  it "should pack correctly when passed true" do
+    b = PrecisionRecord.new(true)
+    b.record_data.should === "\001\000"
+    b.to_biff.unpack('A*').should === ["\016\000\002\000\001"]
+  end
+  it "should pack correctly when passed false" do
+    b = PrecisionRecord.new(false)
+    b.record_data.should === "\000\000"
+    b.to_biff.unpack('A*').should === ["\016\000\002"]
+  end
+end
+
+describe CodepageBiff8Record do
+  it "should pack correctly" do
+    b = CodepageBiff8Record.new
+    b.record_data.should === "\260\004"
+    b.to_biff.unpack('A*').should === ["B\000\002\000\260\004"]
+  end
+end
+
+describe Window1Record do
+  it "should pack correctly" do
+    b = Window1Record.new(1,1,1,1,1,1,1,1,1)
+    b.record_data.should === "\001\000\001\000\001\000\001\000\001\000\001\000\001\000\001\000\001\000"
+    b.to_biff.unpack('A*').should === ["=\000\022\000\001\000\001\000\001\000\001\000\001\000\001\000\001\000\001\000\001"]
+  end
+end
+
+describe FontRecord do
+  it "should pack correctly" do
+    
+    b = FontRecord.new(200,0,32767,400,0,0,0,204,"Arial")
+    b.record_data.should === "\310\000\000\000\377\177\220\001\000\000\000\000\314\000\005\000Arial" 
+  end
+end
+
+# describe XFRecord do
+#   it "should pack correctly" do
+#     b = XFRecord.new([1,1,Alignment.new,Borders.new,Pattern.new,Protection.new])
+#     puts binary_string_to_hex_array(b.record_data)
+#     b.record_data.should === "\001\000\001\000\001\000"
+#     b.to_biff.unpack('A*').should === ["\257\001\002"]
+#   end
+# end
+
+describe StyleRecord do
+  it "should pack correctly" do
+    b = StyleRecord.new
+    b.record_data.should ===  "\000\200\000\377"
+    b.to_biff.unpack('A*').should === ["\223\002\004\000\000\200\000\377"]
+  end
+end
+
+describe BoundSheetRecord do
+  it "should pack correctly" do
+    b = BoundSheetRecord.new(0, 0, "x")
+    b.record_data.should ===  "\000\000\000\000\000\000\001\000x"
+    b.to_biff.unpack('A*').should === ["\205\000\t\000\000\000\000\000\000\000\001\000x"]
+  end
+end
+
+# describe ExtSSTRecord do
+#   it "should pack correctly" do
+#     b = ExtSSTRecord.new(1,[1],1)
+#     b.record_data.should === "\000\000"
+#     b.to_biff.unpack('A*').should === ["\257\001\002"]
+#   end
+# end
+
+describe DimensionsRecord do
+  it "should pack correctly" do
+    b = DimensionsRecord.new(0,0,5,5)
+    b.record_data.should === "\000\000\000\000\001\000\000\000\005\000\006\000\000\000"
+    b.to_biff.unpack('A*').should === ["\000\002\016\000\000\000\000\000\001\000\000\000\005\000\006"]
+  end
+end
+
+# describe MergedCellsRecord do
+#   it "should pack correctly" do
+#     b = MergedCellsRecord.new([[1,1,2,2]])
+#     b.record_data.should ===  "\345\000\n\000\001\000\001\000\001\000\002\000\002\000"
+#     b.to_biff.unpack('A*').should === ["\345\000\n\000\001\000\001\000\001\000\002\000\002"] 
+#   end
+# end

data/spec/cell_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe NumberCell, "to_biff" do
+  before(:all) do
+    @w = Workbook.new
+    @s = @w.add_sheet('rk_tests')
+  end
+  
+  it "should encode with rk_encode" do
+    TEST_VALUES.each_with_index do |x, i|
+      # Write original test values
+      @s.write(i, 0, x)
+
+      # Write test values divided by 100
+      @s.write(i, 3, x/100.00)
+
+      # Write negative of test values
+      @s.write(i, 6, x)
+
+      # Write negative test values divided by 100
+      @s.write(i, 9, -x/100.00)
+    end
+  end
+  
+  after(:all) do
+    @w.save("spec/output/cells-rk.xls")
+  end
+end
+
+TEST_VALUES = [
+    130.63999999999999,
+    130.64,
+    -18.649999999999999,
+    -18.65,
+    137.19999999999999,
+    137.20,
+    -16.079999999999998,
+    -16.08,
+    0,
+    1,
+    2,
+    3,
+    0x1fffffff,
+    0x20000000,
+    0x20000001,
+    1000999999,
+    0x3fffffff,
+    0x40000000,
+    0x40000001,
+    0x7fffffff,
+    0x80000000,
+    0x80000001,
+    0xffffffff,
+    0x100000000,
+    0x100000001
+]