lxl 0.2.0 → 0.2.2

data/CHANGES

@@ -1,3 +1,10 @@
+0.2.2
+
+- Seperated tokenize's text=>formula into tokenize_text
+- LittleLexer returns types as [Symbol*] vs String (tokenize updated accordingly)
+- F and C types removed (no need)
+- General refactoring (code/doc cleanup)
+
 0.2.0
 
   - Double quotes only used to define strings.

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.2

data/lib/lxl.rb

@@ -54,8 +54,6 @@
 #  t  Token
 #  (  Open (
 #  )  Close )
-#  C  Constant
-#  F  Function
 #
 module LXL
 
@@ -111,29 +109,25 @@ class LXL::Parser
     ops = EXCEL_OPERATORS.collect { |v| Regexp.quote(v) }.join('|')
     #
     @lexer = LXL::LittleLexer.new([
-                        [/\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 )
+                        [/\A[\s,]+/, ?w],          # Whitespace (includes Commas)
+                        [/\A(#{ops})/, ?o],        # Operator
+                        [/\A("([^"]|"")*")/m, ?s], # String
+                        [/\A[0-9]+\.[0-9]+/, ?f],  # Float
+                        [/\A[0-9]+/, ?i],          # Integer
+                        [/\A\w+/, ?t],             # Token
+                        [/\A\(/, ?(],              # Open (
+                        [/\A\)/, ?)],              # Close )
                       ], false)
-
-    # Other
-    @tokens = Array.new
-    @types = Array.new
   end
 
   # Evaluate formula
   #
   def eval(formula)
     formulas = formula.to_s.split(';').collect { |f| f.strip }.find_all { |f| ! f.empty? }
-    formulas.collect! { |f| Kernel.eval(tokenize(f).join, binding) }
+    formulas.collect! { |f| Kernel.eval(tokenize_text(f).join, binding) }
     formulas.size == 1 ? formulas.first : formulas
   end
-
+  
   # Register a function
   #
   # * Converts name to symbol
@@ -181,44 +175,45 @@ class LXL::Parser
     }
   end
   
+  # Translates text to a formula before tokenizing
+  #
+  def tokenize_text(text)
+    formula = (text =~ /^=/) ? text : '="'+text.gsub('"','""')+'"'
+    tokenize(formula)
+  end
+
   # Tokenize formula (String => Array)
   #
   def tokenize(formula)
     ops = Hash[*EXCEL_OPERATORS.zip(RUBY_OPERATORS).flatten]
 
     # Parse formula
-    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 = 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 = name(token)
-        if @functions.key?(token)
-          if tokens[i+1] != '('
-            raise ArgumentError, "wrong number of arguments for #{token}"
+      tokens[i] = case type
+        when :i then token.to_i
+        when :f then token.to_f
+        when :s then token.gsub(/([^\\])""/,'\1\"') # "" to \"
+        when :t then
+          name = name(token)
+          if @functions.key?(name)
+            if tokens[i+1] != '('
+              raise ArgumentError, "wrong number of arguments for #{token}"
+            else
+              "@functions[:#{name}].call"
+            end
+          elsif @constants.key?(name)
+            "@constants[:#{name}]"
           else
-            types[i] = 'F'
-            token = '@functions['+token.inspect+'].call'
+            raise NameError, "unknown constant #{token}"
           end
-        elsif @constants.key?(token)
-          types[i] = 'C'
-          token = '@constants['+token.inspect+']'
         else
-          raise NameError, "unknown constant #{token}"
-        end
+          EXCEL_OPERATORS.include?(token) ? ops[token] : token
       end
-      token = ops[token] if EXCEL_OPERATORS.include?(token)
-      tokens[i] = token
     end
 
     tokens
@@ -242,33 +237,34 @@ end
 #
 # http://www.rubyforge.org/projects/littlelexer
 #
+# CHANGE: types are returned as [Symbol*] vs String
+#
 class LXL::LittleLexer #:nodoc: all
 
   class LexerJammed < Exception; end
 
-  def initialize(regex_to_char,skip_white_space = true)
+  def initialize(regex_to_char,skip_white_space=true)
     @skip_white_space = skip_white_space
     @regex_to_char = regex_to_char
   end
 
   def scan(string,string_token_list=nil)
-    result_string  = ''
+    result_list = []
     token_list = []
-    
     if string_token_list
       next_token(string) do |t,token, tail|
-        result_string << t
+        result_list << t.chr.to_sym
         token_list << [string_token_list[0...tail], string[0...tail]]
         string = string[tail..-1]
         string_token_list = string_token_list[tail..-1]
       end
     else
       next_token(string) do |t,token, tail|
-        result_string << t
+        result_list << t.chr.to_sym
         token_list << token
       end
     end
-    return result_string, token_list
+    return result_list, token_list
   end
 
   private
@@ -317,4 +313,5 @@ if $0 == __FILE__
 
   # 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

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.8.3
 specification_version: 1
 name: lxl
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.2
 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: