lxl 0.3.4 → 0.3.8

data/CHANGES

@@ -1,3 +1,28 @@
+0.3.8
+
+- Range#first_colnum and Range#last_colnum added (both use LXL#xlcolnum)
+
+- LXL#xlcolnum (maps excel column names to numeric equivalents)
+
+- New range formats
+  B3 | B3: | B3:D5 | Sheet1!B3:D5 | [Book1]Sheet1!B3:D5 | [file.xls]Sheet1!B3:D5
+  (the first two become B3:B3)
+  
+- Demo LXL interface to Jim Weirich�s SpreadSheet object.
+  http://onestepback.org/index.cgi/Tech/Ruby/SlowingDownCalculations.rdoc
+  http://onestepback.org/cgi-bin/osbwiki.pl?SpreadSheetCode
+  => test/lxl_spreadsheet_test.rb
+
+- Namespaces mow play nicely with const_missing and method_missing
+
+- Range#x_cell methods return to_i
+
+- balanced? works on both tokens and types
+
+- Argument separator ?, added
+
+- General refactoring
+
 0.3.4
 
 - Now recognizes complex Range formats

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.3.8

data/lib/lxl.rb

@@ -1,69 +1,6 @@
 # LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas
 # and is easily extended with new constants and functions.
 # 
-# =Namespaces
-# 
-# Extending the language is as easy as defining new constants
-# and methods on an LXL::Namespace class.
-# 
-#   class MyLXLNamespace < LXL::Namespace
-#     NAME = 'John Doe'
-#     def upper(text) text.to_s.upcase end
-#   end
-# 
-#   class MyLXL < LXL::Parser
-#     def self.namespace_class() MyLXLNamespace end
-#   end
-# 
-#   MyLXL.eval('=UPPER(NAME)')
-#   # => JOHN DOE
-# 
-# =Ranges
-# 
-# LXL::Range provides Excel-style ranges. 
-# 
-# <b>Valid Formats</b>
-#
-#    B3:D5
-#    Sheet1!B3:D5
-#    [Book1.xls]Sheet1!B3:D5
-# 
-# <b>Collection</b>
-#
-#   # Ruby Range
-#   Range.new("B3", "D5").collect
-#   # => ["B3", "B4", "B5", "B6", "B7", "B8", "B9",
-#         "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9",
-#         "D0", "D1", "D2", "D3", "D4", "D5"]
-# 
-#   # LXL Range
-#   LXL::Range.new("B3", "D5").collect
-#    # => ["B3", "B4", "B5", "C3", "C4", "C5", "D3", "D4", "D5"]
-# 
-# =Percentages
-# 
-#   25% => .25
-# 
-# =Deferred function calls
-# 
-# LXL::Deferred snapshots the symbol/arguments of a function call for later use.
-# 
-#   class MyNamespace < LXL::Namespace
-#     register_deferred :foo
-#   end
-#   LXL.new(MyNamespace.new).eval('=FOO(1, "two", 3)').inspect
-#   # => <LXL::Deferred @args=[1, "two", 3] @symbol=:foo>
-# 
-# =Symbol registration
-# 
-# Register uppercase constants of the same name and value.
-# 
-#   class MyNamespace < LXL::Namespace
-#     register_symbols :foo, :bar
-#   end
-#   LXL.new(MyNamespace.new).eval('=LIST(FOO, BAR)').inspect
-#   # => [:FOO, :BAR]
-# 
 # =Operators
 # 
 #   a +  b # Add
@@ -105,6 +42,70 @@
 #   LIST (a,b,..)    # Variable length list
 #   IN   (find,list) # True if find is in the given list (or string)
 # 
+# =Percentages
+# 
+#   25%   => .25
+#   25.2% => .252
+# 
+# =Ranges
+# 
+# LXL::Range provides Excel-style ranges. 
+# 
+# <b>Recognized formats</b>
+#
+#  B3 | B3: | B3:D5 | Sheet1!B3:D5 | [Book1]Sheet1!B3:D5 | [file.xls]Sheet1!B3:D5
+#
+#  (the first two become B3:B3)
+# 
+# <b>Collection</b>
+#
+#   # Ruby Range
+#   Range.new("B3", "D5").collect
+#   # => ["B3", "B4", "B5", "B6", "B7", "B8", "B9",
+#         "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9",
+#         "D0", "D1", "D2", "D3", "D4", "D5"]
+# 
+#   # LXL Range
+#   LXL::Range.new("B3", "D5").collect
+#   # => ["B3", "B4", "B5", "C3", "C4", "C5", "D3", "D4", "D5"]
+# 
+# =Namespaces
+# 
+# Extending the language is as easy as defining new constants
+# and methods on an LXL::Namespace.
+# 
+#   class MyLXLNamespace < LXL::Namespace
+#     NAME = 'John Doe'
+#     def upper(text) text.to_s.upcase end
+#   end
+# 
+#   class MyLXL < LXL::Parser
+#     def self.namespace_class() MyLXLNamespace end
+#   end
+# 
+#   MyLXL.eval('=UPPER(NAME)')
+#   # => JOHN DOE
+# 
+# =Symbol registration
+# 
+# Register uppercase constants of the same name and value.
+# 
+#   class MyNamespace < LXL::Namespace
+#     register_symbols :foo, :bar
+#   end
+#   LXL.new(MyNamespace.new).eval('=LIST(FOO, BAR)')
+#   # => [:FOO, :BAR]
+#
+# =Deferred function calls
+# 
+# LXL::Deferred snapshots the symbol/arguments of a function call for later use.
+# 
+#   class MyNamespace < LXL::Namespace
+#     register_deferred :foo
+#   end
+#   LXL.new(MyNamespace.new).eval('=FOO(1, "two", 3)')
+#   # => <LXL::Deferred @args=[1, "two", 3] @symbol=:foo>
+# 
 # =Notes
 # 
 # * Values prefixed with = are formulas, anything else is assumed to be text.
@@ -146,12 +147,28 @@ module LXL
     [nil,false,0].include?(obj) ? false : true
   end
 
+  # Convert an Excel column name to it's numeric equivalent.
+  #
+  #   ['A', 'F', 'AD', 'BK'].collect { |c| xlcolnum(c) } # => [1, 6, 30, 63]
+  #
+  def xlcolnum(colname)
+    count = 0
+    letters = colname.to_s.split(//)
+    map = Proc.new { |c| ::Range.new('A','Z').collect.index(c)+1 }
+    letters[0..-2].each { |l| count += 26*map.call(l) }
+    count += map.call(letters.last)
+    count
+  end
+
 end
 
 # =Lexical Types
 #
-#  w  Whitespace (includes commas)
-#  ;  Semi-Colon (statement separator)
+#  ;  Statement separator
+#  ,  Argument separator
+#  (  Tuple open
+#  )  Tuple close
+#  w  Whitespace
 #  o  Operator
 #  s  String
 #  r  Range
@@ -159,16 +176,12 @@ end
 #  f  Float
 #  i  Integer
 #  t  Token
-#  (  Open (
-#  )  Close )
 #
 #  F Function
 #  C Constant
 #
 class LXL::Parser
 
-  attr_reader :namespace, :lexer
-
   RUBY_OPERATORS  = ['+', '-', '*', '/', '<=', '>=', '==', '!=', '<', '>', '+', '**']
   EXCEL_OPERATORS = ['+', '-', '*', '/', '<=', '>=', '=',  '<>', '<', '>', '&', '^' ]
 
@@ -201,10 +214,13 @@ class LXL::Parser
   def initialize(namespace=self.class.namespace_class.new)
     @namespace = namespace
     ops = EXCEL_OPERATORS.collect { |v| Regexp.quote(v) }.join('|')
-    xlr = Regexp.new('\A'+LXL::Range::EXCEL_RANGE.source, true)
+    xlr = LXL::Range::EXCEL_RANGE
     @lexer = self.class.lexer_class.new([
-      [/\A[\s,]+/, ?w],          # Whitespace (includes Commas)
-      [/\A;/, ?;],               # Semi-Colon (statement separator)
+      [/\A;+/, ?;],              # Statement separator
+      [/\A,+/, ?,],              # Argument separator
+      [/\A\(/, ?(],              # Tuple open
+      [/\A\)/, ?)],              # Tuple close
+      [/\A\s+/, ?w],             # Whitespace
       [/\A(#{ops})/, ?o],        # Operator
       [/\A("([^"]|"")*")/m, ?s], # String
       [xlr, ?r],                 # Range
@@ -212,25 +228,23 @@ class LXL::Parser
       [/\A\d+\.\d+/, ?f],        # Float
       [/\A\d+/, ?i],             # Integer
       [/\A\w+/, ?t],             # Token
-      [/\A\(/, ?(],              # Open (
-      [/\A\)/, ?)],              # Close )
     ], false)
   end
 
   # Evaluate a formula.
   #
   def eval(formula)
-    formulas = [[]]
-    formula = formula.to_s.gsub(/(\n)(\s*=)/, '\1;\2') # infer statement separators
+    formulas = Array.new << Array.new
+    formula = formula.to_s.gsub(/(\n)(\s*=)/,'\1;\2') # infer statement separators
     types,tokens = tokenize(formula)
-    tokens.each_index { |i| tokens[i] == ';' ? formulas << [] : formulas.last << [types[i], tokens[i]] }
+    tokens.each_index { |i| tokens[i] == ';' ? formulas << Array.new : formulas.last << [types[i], tokens[i]] }
     formulas.collect! { |f|
       types  = f.collect { |t| t.first }
       tokens = f.collect { |t| t.last  }
       token = tokens.join.strip
-      if token =~ /^=/
+      if token =~ /\A=/
         tokens.each_index { |i| tokens[i] = translate_quotes(tokens[i]) if types[i] == ?s }
-        token = tokens.join.strip.gsub(/^=+/, '')
+        token = tokens.join.strip.gsub(/\A=+/,'')
       else
         token = translate_quotes(quote(tokens.join.strip))
       end
@@ -261,41 +275,48 @@ class LXL::Parser
   end
 
   # Tokenize a formula into <tt>[TypesString, TokensArray]</tt>.
-  #
+  #--
+  # const_missing is defined by Ruby, raises a NameError.
+  # method_missing is not, Ruby uses user-defined if present, NoMethodError otherwise.
+  #++
   def tokenize(formula)
     ops = Hash[*EXCEL_OPERATORS.zip(RUBY_OPERATORS).flatten]
 
     # Parse formula
     types,tokens = @lexer.scan(formula.to_s)
-    raise SyntaxError, 'unbalanced parentheses' unless balanced?(tokens)
+    raise SyntaxError, 'unbalanced parentheses' unless balanced?(types)
     
     # Parse tokens
     tokens.each_index do |i|
       type, token = types[i], tokens[i]
       tokens[i] = case type
         when ?o then ops[token]
-        when ?r then "self.class.range_class.new(*#{token.split(':').inspect})"
         when ?p then token.to_f/100
         when ?f then token.to_f
         when ?i then token.to_i
+        when ?r then
+          range = token.split(/:/)
+          range[1] = range[0] if range.size == 1
+          "self.class.range_class.new(*#{range.inspect})"
         when ?t then
           upper = token.to_s.upcase
           lower = token.to_s.downcase
           raise NoMethodError, "protected method `#{token}` called for #{self}" if @namespace.const_get(:METHODS).include?(lower)
-          if @namespace.respond_to?(lower)
-            if tokens[i+1] != '('
-              raise ArgumentError, "wrong number of arguments for #{token}"
-            else
+          custom_const_missing = begin [@namespace.const_get(:ConstMissing),true].last rescue false end
+          # Constants
+          if tokens[i+1] != '('
+            if @namespace.const_defined?(upper) or custom_const_missing
+              types[i] = ?C
+              "@namespace.const_get(:#{upper})"
+            else token; end
+          # Functions
+          else
+            if @namespace.respond_to?(lower) or @namespace.respond_to?(:method_missing)
               types[i] = ?F
-              "@namespace.method(:#{lower}).call"
-            end
-          elsif @namespace.const_defined?(upper)
-            types[i] = ?C
-            "@namespace.const_get(:#{upper})"
-          else token
+              "@namespace.#{lower}"
+            else token; end
           end
-        else token
-      end
+        else token; end
     end
 
     [types,tokens]
@@ -303,20 +324,20 @@ class LXL::Parser
   
   # Check that parentheses are balanced.
   #
-  def balanced?(tokens)
-    tokens.find_all { |t| ['(', ')'].include?(t) }.size % 2 == 0
+  def balanced?(list)
+    list.to_s.gsub(/[^()]/,'').size % 2 == 0
   end
 
 end
 
 # Excel-style ranges. 
 # 
-# =Valid formats
+# =Recognized formats
+#
+#  B3 | B3: | B3:D5 | Sheet1!B3:D5 | [Book1]Sheet1!B3:D5 | [file.xls]Sheet1!B3:D5
+#
+#  (the first two become B3:B3)
 #
-#    B3:D5
-#    Sheet1!B3:D5
-#    [Book1.xls]Sheet1!B3:D5
-# 
 # =Collection
 #
 #   # Ruby Range
@@ -331,35 +352,32 @@ end
 # 
 class LXL::Range < Range
 
-  # B3, Sheet1!B3, [Book1.xls]Sheet1!B3
-  EXCEL_VECTOR = /(\[([\w\.]+)\])?((\w+)!)?([A-Z]+[1-9]+)/i
-
-  # B3:D5, Sheet1!B3:D5, [Book1.xls]Sheet1!B3:D5
-  EXCEL_RANGE = /(\[([\w\.]+)\])?((\w+)!)?([A-Z]+[1-9]+):([A-Z]+[1-9]+)/i
+  # B3 | B3: | B3:D5 | Sheet1!B3:D5 | [Book1]Sheet1!B3:D5 | [file.xls]Sheet1!B3:D5
+  EXCEL_RANGE = /\A(\[([\w\.]+)\])?((\w+)!)?([A-Z]+[1-9]+)(:([A-Z]+[1-9]+)?)?/i
   
-  # True if this is an Excel range.
-  attr_accessor :excel
-  
-  # Given workbook name.
+  # Workbook name.
   attr_accessor :book
 
-  # Given worksheet name.
+  # Worksheet name.
   attr_accessor :sheet
 
   def self.new(first, last)
-    excel = (first =~ EXCEL_VECTOR && last =~ EXCEL_VECTOR)
+    excel = (first =~ EXCEL_RANGE && last =~ EXCEL_RANGE)
     if excel
-      first =~ EXCEL_VECTOR
+      first =~ EXCEL_RANGE
       book,sheet,first = $2,$4,$5
       obj = super(*[first.upcase,last.upcase].sort)
-      obj.excel = true
+      obj.excel!
       obj.book = book
       obj.sheet = sheet
+      obj
     else
-      obj = super
-      obj.excel = false
+      super
     end
-    obj
+  end
+  
+  def excel!
+    @excel = true
   end
 
   def excel?
@@ -367,26 +385,34 @@ class LXL::Range < Range
   end
 
   def first_column
-    first.to_s.upcase.gsub(/[^A-Z]/, '')
+    first.to_s.upcase.gsub(/[^A-Z]/,'')
   end
 
   def last_column
-    last.to_s.upcase.gsub(/[^A-Z]/, '')
+    last.to_s.upcase.gsub(/[^A-Z]/,'')
   end
   
+  def first_colnum
+    LXL.xlcolnum(first_column)
+  end
+
+  def last_colnum
+    LXL.xlcolnum(last_column)
+  end
+
   def first_cell
-    first.to_s.gsub(/[^1-9]/, '')
+    first.to_s.gsub(/[^1-9]/,'').to_i
   end
   
   def last_cell
-    last.to_s.gsub(/[^1-9]/, '')
+    last.to_s.gsub(/[^1-9]/,'').to_i
   end
 
   def each
     if excel?
       Range.new(first_column, last_column).each do |column|
         Range.new(first_cell, last_cell).each do |cell|
-          yield column+cell
+          yield column+cell.to_s
         end
       end
     else
@@ -401,7 +427,7 @@ end
 #   class MyNamespace < LXL::Namespace
 #     register_deferred :foo
 #   end
-#   LXL.new(MyNamespace.new).eval('=FOO(1, "two", 3)').inspect
+#   LXL.new(MyNamespace.new).eval('=FOO(1, "two", 3)')
 #   # => <LXL::Deferred @args=[1, "two", 3] @symbol=:foo>
 #
 class LXL::Deferred
@@ -445,7 +471,7 @@ class LXL::EmptyNamespace
   #   class MyNamespace < LXL::Namespace
   #     register_deferred :foo
   #   end
-  #   LXL.new(MyNamespace.new).eval('=FOO(1, "two", 3)').inspect
+  #   LXL.new(MyNamespace.new).eval('=FOO(1, "two", 3)')
   #   # => <LXL::Deferred @args=[1, "two", 3] @symbol=:foo>
   #
   def self.register_deferred(*symbols)
@@ -458,7 +484,7 @@ class LXL::EmptyNamespace
   #   class MyNamespace < LXL::Namespace
   #     register_symbols :foo, :bar
   #   end
-  #   LXL.new(MyNamespace.new).eval('=LIST(FOO, BAR)').inspect
+  #   LXL.new(MyNamespace.new).eval('=LIST(FOO, BAR)')
   #   # => [:FOO, :BAR]
   #
   def self.register_symbols(*symbols)
@@ -540,41 +566,41 @@ class LXL::Lexer #:nodoc: all
 
   class LexerJammed < Exception; end
 
-  def initialize(regex_to_char,skip_white_space=true)
-    @skip_white_space = skip_white_space
-    @regex_to_char = regex_to_char
+  def initialize(re_to_chr, skip_whitespace=true)
+    @re_to_chr = re_to_chr
+    @skip_whitespace = skip_whitespace
   end
 
-  def scan(string,string_token_list=nil)
-    result_string = String.new
-    token_list = Array.new
-    if string_token_list
-      next_token(string) do |t,token, tail|
-        result_string << t
-        token_list << [string_token_list[0...tail], string[0...tail]]
+  def scan(string, string_tokens=nil)
+    types = String.new
+    tokens = Array.new
+    if string_tokens
+      next_token(string) do |t,token,tail|
+        types << t
+        tokens << [string_tokens[0...tail], string[0...tail]]
         string = string[tail..-1]
-        string_token_list = string_token_list[tail..-1]
+        string_tokens = string_tokens[tail..-1]
       end
     else
-      next_token(string) do |t,token, tail|
-        result_string << t
-        token_list << token
+      next_token(string) do |t,token,tail|
+        types << t
+        tokens << token
       end
     end
-    return result_string, token_list
+    return types,tokens
   end
 
   private
 
-  def next_token( string)
+  def next_token(string)
     match_data = nil
     while ! string.empty?
       failed = true
-      @regex_to_char.each do |regex,char|
-        match_data = regex.match(string)
+      @re_to_chr.each do |re,chr|
+        match_data = re.match(string)
         next unless match_data
         token = match_data[0]
-        yield char,token, match_data.end(0) unless char == ?\s && @skip_white_space 
+        yield chr,token, match_data.end(0) unless chr == ?\s && @skip_whitespace 
         string = match_data.post_match
         failed = false
         break

data/test/lxl_spreadsheet_test.rb

@@ -0,0 +1,45 @@
+#--
+# LXL interface to Jim Weirich�s SpreadSheet object.
+# http://onestepback.org/index.cgi/Tech/Ruby/SlowingDownCalculations.rdoc
+# http://onestepback.org/cgi-bin/osbwiki.pl?SpreadSheetCode
+#
+# NOTE: Spreadsheet#[a,b] does single lookups only.
+#++
+
+$LOAD_PATH.unshift('../lib')
+require 'test/unit'
+require 'spreadsheet'
+require 'lxl'
+
+#--
+# Spreadsheet
+#++
+
+$ss = SpreadSheet.new
+$ss[1,1].value = 5
+$ss[1,2].value = $ss[1,1] * 6
+$ss[1,3].value = $ss[1,2] * 7
+
+#--
+# LXL Interface
+#++
+  
+class MyNamespace < LXL::EmptyNamespace
+  def lookup(range)
+    $ss[range.first_colnum, range.first_cell].value
+  end
+end
+
+class MyLXL < LXL::Parser
+  def self.namespace_class() MyNamespace end
+end
+
+#--
+# Test
+#++
+
+class SpreadsheetTest < Test::Unit::TestCase
+  def test_lookup
+    assert_equal($ss[1,3].value, MyLXL.eval('=LOOKUP(A3)'))
+  end
+end

data/test/lxl_test.rb

@@ -17,7 +17,7 @@ class LXLTest < Test::Unit::TestCase
   def test_multiple_formula
     formulas = %{
       This is some text;
-      "This is some ""quoted"" text";
+      "This is some ""quoted"" text"
       ="This is some ""quoted"" text"
       =";"=";"
       =";"=":"
@@ -40,8 +40,8 @@ class LXLTest < Test::Unit::TestCase
       ="embedded percentages 25% and semi-colons ; are working properly"
     }
     expected =  ["This is some text", "\"This is some \"quoted\" text\"", "This is some \"quoted\" text"]
-    expected += [true, false, :A, :B, false, 6, true, true, [1, "two", 3.0], true, false, true, "yes", "this and that"]
-    expected += [8, 0.502, true, true, "embedded percentages 25% and semi-colons ; are working properly"]
+    expected += [true, false, :A, :B, false, 6, true, true, [1, 'two', 3.0], true, false, true, 'yes', 'this and that']
+    expected += [8, 0.502, true, true, 'embedded percentages 25% and semi-colons ; are working properly']
     MyNamespace.register_symbols(:A, :B)
     lxl = LXL::Parser.new(MyNamespace.new)
     results = lxl.eval(formulas)
@@ -53,13 +53,19 @@ class LXLTest < Test::Unit::TestCase
     res = lxl.eval('=LIST(d5:b3, "x")')
     range = res.first
     assert_equal(LXL::Range, range.class)
-    assert_equal("B3", range.min)
-    assert_equal("D5", range.max)
-    assert_equal(range.collect.join(','), "B3,B4,B5,C3,C4,C5,D3,D4,D5")
-    assert_equal(range.first_column, 'B')
-    assert_equal(range.last_column, 'D')
-    assert_equal(range.first_cell, '3')
-    assert_equal(range.last_cell, '5')
+    assert_equal('B3', range.min)
+    assert_equal('D5', range.max)
+    assert_equal('B3,B4,B5,C3,C4,C5,D3,D4,D5', range.collect.join(','))
+    assert_equal('B', range.first_column)
+    assert_equal('D', range.last_column)
+    assert_equal(3, range.first_cell)
+    assert_equal(5, range.last_cell)
+    res = lxl.eval('=B3; =B3:; =B3:D5; =Sheet1!B3:D5; =[Book1]Sheet1!B3:D5; =[file.xls]Sheet1!B3:D5')
+    assert_equal(3, res[0].last_cell)
+    assert_equal(3, res[1].last_cell)
+    assert_equal(nil, res[2].sheet)
+    assert_equal('file.xls', res[5].book)
+    assert_equal('Sheet1', res[5].sheet)
   end
   
   def test_deferred
@@ -77,16 +83,16 @@ class LXLTest < Test::Unit::TestCase
     assert_equal('B', range.first_column)
     range = lxl.eval('=Sheet1!B3:D5')
     assert_equal('B', range.first_column)
-    assert_equal('5', range.last_cell)
+    assert_equal(5, range.last_cell)
     assert_equal('Sheet1', range.sheet)
     range = lxl.eval('=[Book.xls]Sheet2!B5:D6')
     assert_equal('B', range.first_column)
-    assert_equal('6', range.last_cell)
+    assert_equal(6, range.last_cell)
     assert_equal('Book.xls', range.book)
     assert_equal('Sheet2', range.sheet)
     range = lxl.eval('=[Book1]Sheet3!B7:D8')
     assert_equal('B', range.first_column)
-    assert_equal('8', range.last_cell)
+    assert_equal(8, range.last_cell)
     assert_equal('Book1', range.book)
     assert_equal('Sheet3', range.sheet)
   end
@@ -102,8 +108,8 @@ class LXLTest < Test::Unit::TestCase
     assert_equal('no', ns.if(false, 'yes', 'no'))
     assert_equal(true, ns.in(1, [1,2]))
     assert_equal(false, ns.in(1, [3,4]))
-    assert_equal(true, ns.in("a", "ab"))
-    assert_equal(false, ns.in("a", "cd"))
+    assert_equal(true, ns.in('a', 'ab'))
+    assert_equal(false, ns.in('a', 'cd'))
     assert_equal(true, ns.datetime('Jan 1, 2005') == ns.date(2005,1,1))
     assert_equal(false, ns.datetime('Jan 1, 2005 12:30') == ns.date(2005,1,1)+ns.time(12,30,01))
     assert_equal('[1, "two", 3]', ns.list(1,'two',3).inspect)

data/test/spreadsheet.rb

@@ -0,0 +1,85 @@
+#--
+# From Jim Weirich�s blog { | one, step, back | }
+# http://onestepback.org/index.cgi/Tech/Ruby/SlowingDownCalculations.rdoc
+# http://onestepback.org/cgi-bin/osbwiki.pl?SpreadSheetCode
+#++
+
+class BlankSlate
+  safe_methods = ['__id__', '__send__']
+  (instance_methods-safe_methods).each { |m| undef_method m }
+end
+
+module Kernel
+  def formula_value
+    self
+  end
+end
+
+class SpreadSheet
+  def initialize
+    @hash = Hash.new
+  end
+  
+  def [](r,c)
+    @hash["#{r}@#{c}"] ||= Cell.new
+  end
+end
+
+class Formula < BlankSlate
+  def method_missing(sym, *args, &block)
+    Deferred.new(self, sym, args, block)
+  end
+  
+  def coerce(other)
+    [Const.new(other), self]
+  end
+  
+  def formula_value
+    fail "Subclass Responsibility"
+  end
+end
+
+class Deferred < Formula
+  attr_reader :operation, :args, :target
+  def initialize(target, operation, args, block)
+    @target = target
+    @operation = operation
+    @args = args
+    @block = block
+  end
+  
+  def formula_value
+    @target.formula_value.send(@operation, *eval_args, &@block)
+  end
+  
+  private
+  
+  def eval_args
+    @args.collect { |a| a.formula_value }
+  end
+end
+
+class Const < Formula
+  attr_reader :formula_value
+  def initialize(value)
+    @formula_value = value
+  end
+end
+
+class Cell < Formula
+  def initialize
+    @formula = 0
+  end
+  
+  def value
+    @formula.formula_value
+  end
+  
+  def value=(new_value)
+    @formula = new_value
+  end
+  
+  def formula_value
+    @formula.formula_value
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.3
 specification_version: 1
 name: lxl
 version: !ruby/object:Gem::Version 
-  version: 0.3.4
-date: 2005-02-14
+  version: 0.3.8
+date: 2005-02-15
 summary: LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas. Easily extended with new constants and functions.
 require_paths: 
   - lib
@@ -35,7 +35,9 @@ files:
   - setup.rb
   - README.en
   - lib/lxl.rb
+  - test/spreadsheet.rb
   - test/lxl_test.rb
+  - test/lxl_spreadsheet_test.rb
 test_files: 
   - test/lxl_test.rb
 rdoc_options: