lxl 0.1.1 → 0.2.0

data/CHANGES

@@ -1,3 +1,13 @@
+0.2.0
+
+  - Double quotes only used to define strings.
+  - Embedded quote escaping by doubling them up: ="This is a ""quoted"" string."
+  - Text/Formula split. Formulas start with =, anything else is seen as a string
+  - :SYMBOL parsing removed. register_symbols added to enable symbols as constants
+  - Case insensitive function and constant names
+  - Semi-Colons no longer parsed as a token (still used as statement separator)
+  - General refactoring (code/doc cleanup)
+
 0.1.1
 
   - String tokens s/S => '/"

data/README

@@ -8,21 +8,23 @@ Usage
 -----
 
   formulas = %{
-    ((1+2)*(10-6))/2;
-    DATETIME("2004-11-22 11:11:00")=DATE(2004,11,22)+TIME(11,11,00);
-    IN(" is ", "this is a string");
-    LIST(1, "two", 3.0);
-    IN("b", LIST("a", "b", "c"));
-    AND(TRUE, NULL);
-    OR(TRUE, FALSE);
-    IF(1+1=2, "yes", "no");
+    This is some text;
+    ="This is some ""quoted"" text";
+    =((1+2)*(10-6))/2;
+    =datetime("2004-11-22 11:11:00")=DATE(2004,11,22)+TIME(11,11,00);
+    =IN(" is ", "this is a string");
+    =LIST(1, "two", 3.0);
+    =IN("b", LIST("a", "b", "c"));
+    =AND(TRUE, NULL);
+    =OR(TRUE, FALSE);
+    =IF(1+1=2, "yes", "no");
   }
-  
+
   # single formula
-  puts LXL.eval('5+5').inspect # => 10
+  puts LXL.eval('=5+5').inspect # => 10
 
   # multiple formulas separated by semi-colon
-  puts LXL.eval(formulas).inspect # => [6, true, true, [1, "two", 3.0], true, false, true, "yes"]
+  puts LXL.eval(formulas).inspect # => ["This is some text", "This is some \"quoted\" text", 6, true, true, [1, "two", 3.0], true, false, true, "yes"]
   
   See API docs for more information.
 

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/lxl.rb

@@ -43,18 +43,14 @@
 #
 #  * The number zero is interpereted as FALSE
 #  * Return multiple results in an array by separating formulas with a semi-colon (;)
-#  * A :SYMBOL token is recognized as a ruby symbol
 #
 # =Lexical Types
 #
 #  w  Whitespace (includes Commas)
-#  ;  Semi-Colon (statement separator)
 #  o  Operator
 #  f  Float
 #  i  Integer
-#  '  String (single quoted)
-#  "  String (double quoted)
-#  s  Symbol
+#  s  String
 #  t  Token
 #  (  Open (
 #  )  Close )
@@ -75,7 +71,7 @@ end
 
 class LXL::Parser
 
-  attr_reader :constants, :functions, :lexer, :tokens, :types
+  attr_reader :constants, :functions, :lexer
 
   RUBY_OPERATORS  = ['+', '-', '*', '/', '<=', '>=', '==', '!=', '<', '>']
   EXCEL_OPERATORS = ['+', '-', '*', '/', '<=', '>=', '=',  '<>', '<', '>']
@@ -115,17 +111,14 @@ class LXL::Parser
     ops = EXCEL_OPERATORS.collect { |v| Regexp.quote(v) }.join('|')
     #
     @lexer = LXL::LittleLexer.new([
-                        [/\A[\s,]+/,?w] ,        # Whitespace (includes Commas)
-                        [/\A;+/, ?;],            # Semi-Colon (statement separator)
-                        [/\A(#{ops})/,?o],       # Operator
-                        [/\A[0-9]+\.[0-9]+/,?f], # Float
-                        [/\A[0-9]+/,?i],         # Integer
-                        [/\A("[^\"]*")/m,?'],    # String (single quoted)
-                        [/\A('[^\']*')/m,?"],    # String (double quoted)
-                        [/\A:\w+/,?s],           # Symbol
-                        [/\A\w+/,?t],            # Token
-                        [/\A\(/,?(],             # Open (
-                        [/\A\)/,?)],             # Close )
+                        [/\A[\s,]+/,?w],          # Whitespace (includes Commas)
+                        [/\A(#{ops})/,?o],        # Operator
+                        [/\A[0-9]+\.[0-9]+/,?f],  # Float
+                        [/\A[0-9]+/,?i],          # Integer
+                        [/\A("([^"]|"")*")/m,?s], # String
+                        [/\A\w+/,?t],             # Token
+                        [/\A\(/,?(],              # Open (
+                        [/\A\)/,?)],              # Close )
                       ], false)
 
     # Other
@@ -136,40 +129,42 @@ class LXL::Parser
   # Evaluate formula
   #
   def eval(formula)
-    tokenize(formula.to_s.strip)
-    @tokens.pop if @tokens.last == ';'
-    if @tokens.include?(';')
-      expr = [ [] ]
-      @tokens.each do |token|
-        if token == ';'
-          expr << []
-        else
-          expr.last << token
-        end
-      end
-      expr.collect { |e| Kernel.eval(e.join, binding) }
-    else
-      Kernel.eval(@tokens.join, binding)
-    end
+    formulas = formula.to_s.split(';').collect { |f| f.strip }.find_all { |f| ! f.empty? }
+    formulas.collect! { |f| Kernel.eval(tokenize(f).join, binding) }
+    formulas.size == 1 ? formulas.first : formulas
   end
 
-  protected
+  # Register a function
+  #
+  # * Converts name to symbol
+  # * Wraps function with a debugging procedure
+  #
+  def register_function(name, &block)
+    name = name(name)
+    @functions[name] = debug(name, &block)
+  end
   
   # Register a constant
   #
   # * Converts name to symbol
   #
   def register_constant(name, value)
-    @constants[name.to_sym] = value
+    name = name(name)
+    @constants[name] = value
   end
 
-  # Register a function
+  # Registers constant for each symbol, with the same name and value
   #
-  # * Converts name to symbol
-  # * Wraps function with a debugging procedure
+  def register_symbols(*symbols)
+    symbols.each { |s| register_constant(s, s) }
+  end
+
+  protected
+  
+  # Translate to uppercase symbol
   #
-  def register_function(name, &block)
-    @functions[name.to_sym] = debug(name.to_sym, &block)
+  def name(obj)
+    obj.to_s.upcase.to_sym
   end
 
   # Wrap a procedure in a debugging procedure
@@ -192,43 +187,47 @@ class LXL::Parser
     ops = Hash[*EXCEL_OPERATORS.zip(RUBY_OPERATORS).flatten]
 
     # Parse formula
-    types, @tokens = @lexer.scan(formula)
-    @types = types.split(//)
-    raise SyntaxError, 'unbalanced parentheses' unless balanced?
+    formula = '="'+formula.gsub('"','""')+'"' unless formula =~ /^=/ # text to formula (text to ="quoted-text")
+    types, tokens = @lexer.scan(formula.gsub(/^=/,''))
+    types = types.split(//)
+    raise SyntaxError, 'unbalanced parentheses' unless balanced?(tokens)
     
     # Parse tokens
-    @tokens.each_index do |i|
-      type, token = @types[i], @tokens[i]
-      token = token.to_i if type == 'i'
-      token = token.to_f if type == 'f'
-      token = token.to_sym if type == 's'
+    tokens.each_index do |i|
+      type, token = types[i], tokens[i]
+      token = case type
+        when 'i': token.to_i
+        when 'f': token.to_f
+        when 's': token.gsub(/([^\\])""/,'\1\"') # "" to \"
+        else token
+      end
       if type == 't'
-        token = token.to_sym
+        token = name(token)
         if @functions.key?(token)
-          if @tokens[i+1] != '('
+          if tokens[i+1] != '('
             raise ArgumentError, "wrong number of arguments for #{token}"
           else
-            @types[i] = 'F'
+            types[i] = 'F'
             token = '@functions['+token.inspect+'].call'
           end
         elsif @constants.key?(token)
-          @types[i] = 'C'
+          types[i] = 'C'
           token = '@constants['+token.inspect+']'
         else
           raise NameError, "unknown constant #{token}"
         end
       end
       token = ops[token] if EXCEL_OPERATORS.include?(token)
-      @tokens[i] = token
+      tokens[i] = token
     end
 
-    @tokens
+    tokens
   end
   
   # Check that parentheses are balanced
   #
-  def balanced?
-    @tokens.find_all { |t| ['(', ')'].include?(t) }.size % 2 == 0
+  def balanced?(tokens)
+    tokens.find_all { |t| ['(', ')'].include?(t) }.size % 2 == 0
   end
 
   # False if nil, false or zero
@@ -296,24 +295,26 @@ class LXL::LittleLexer #:nodoc: all
 
 end
 
-# Test
+# Demo
 #
 if $0 == __FILE__
-  
+
   formulas = %{
-    ((1+2)*(10-6))/2;
-    DATETIME("2004-11-22 11:11:00")=DATE(2004,11,22)+TIME(11,11,00);
-    IN(" is ", "this is a string");
-    LIST(1, "two", 3.0);
-    IN("b", LIST("a", "b", "c"));
-    AND(TRUE, NULL);
-    OR(TRUE, FALSE);
-    IF(1+1=2, "yes", "no");
+    This is some text;
+    ="This is some ""quoted"" text";
+    =((1+2)*(10-6))/2;
+    =datetime("2004-11-22 11:11:00")=DATE(2004,11,22)+TIME(11,11,00);
+    =IN(" is ", "this is a string");
+    =LIST(1, "two", 3.0);
+    =IN("b", LIST("a", "b", "c"));
+    =AND(TRUE, NULL);
+    =OR(TRUE, FALSE);
+    =IF(1+1=2, "yes", "no");
   }
-  
-  puts LXL.eval('5+5').inspect # => 10
 
-  # multiple formulas separated by semi-colon
-  puts LXL.eval(formulas).inspect # => [6, true, true, [1, "two", 3.0], true, false, true, "yes"]
+  # single formula
+  puts LXL.eval('=5+5').inspect # => 10
 
+  # multiple formulas separated by semi-colon
+  puts LXL.eval(formulas).inspect # => ["This is some text", "This is some \"quoted\" text", 6, true, true, [1, "two", 3.0], true, false, true, "yes"]  
 end

data/test/lxl_test.rb

@@ -5,23 +5,30 @@ require 'lxl'
 class LXLTest < Test::Unit::TestCase
 
   def test_single_formula
-    assert_equal(10, LXL.eval('5+5'))
+    assert_equal(10, LXL.eval('=5+5'))
   end
 
   def test_multiple_formula
     formulas = %{
-      :SYMBOL;
-      ((1+2)*(10-6))/2;
-      DATETIME("2004-11-22 11:11:00")=DATE(2004,11,22)+TIME(11,11,00);
-      IN(" is ", "this is a string");
-      LIST(1, "two", 3.0);
-      IN("b", LIST("a", "b", "c"));
-      AND(TRUE, NULL);
-      OR(TRUE, FALSE);
-      IF(1+1=2, "yes", "no");
+      This is some text;
+      "This is some ""quoted"" text";
+      ="This is some ""quoted"" text";
+      =FOO;
+      =bar;
+      =((1+2)*(10-6))/2;
+      =datetime("2004-11-22 11:11:00")=DATE(2004,11,22)+TIME(11,11,00);
+      =IN(" is ", "this is a string");
+      =LIST(1, "two", 3.0);
+      =IN("b", LIST("a", "b", "c"));
+      =AND(TRUE, NULL);
+      =OR(TRUE, FALSE);
+      =IF(1+1=2, "yes", "no");
     }
-    expected = [:SYMBOL, 6, true, true, [1, "two", 3.0], true, false, true, "yes"]
-    results = LXL.eval(formulas)
+    expected = ["This is some text", "\"This is some \"quoted\" text\"", "This is some \"quoted\" text"]
+    expected += [:FOO, :BAR, 6, true, true, [1, "two", 3.0], true, false, true, "yes"]
+    lxl = LXL::Parser.new
+    lxl.register_symbols(:FOO, :BAR)
+    results = lxl.eval(formulas)
     expected.each_index { |i| assert_equal(expected[i], results[i]) }
   end
 

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.8.3
 specification_version: 1
 name: lxl
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 date: 2005-02-08
 summary: LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas. Easily extended with new constants and functions.
 require_paths: