lxl 0.3.0 → 0.3.1

data/CHANGES

@@ -1,3 +1,10 @@
+0.3.1
+
+- LXL::LittleLexer => LXL::Lexer, types is a string again.
+- Range regexp made more explicit.
+- Added the NOT function.
+- Componentized LXL classes into x_class methods
+
 0.3.0
 
 - Functions and constants moved into LXL::Namespace (major refactoring)

data/README.en

@@ -1,8 +1,8 @@
 LXL README
-============
+==========
 
-LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas.
-Easily extended with new constants and functions.
+LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas
+and is easily extended with new constants and functions.
 
 Usage
 -----

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/lib/lxl.rb

@@ -1,14 +1,66 @@
-# LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas.
-# Easily extended with new constants and functions using LXL::Namespace.
-#
-# =Constants
-#
-#  TRUE  # true
-#  FALSE # false
-#  NULL  # nil
-#
+# 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
+# 
+#   B3:D5 => LXL::Range.new("B3","D5")
+#   
+# LXL::Range is a subclass of Range which overrides
+# the #each method to return Excel-style ranges.
+# 
+#   # Standard 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
 #   a -  b # Subtract
 #   a *  b # Multiply
@@ -19,60 +71,74 @@
 #   a >  b # Greater than
 #   a <= b # Less than or equal to
 #   a >= b # Greater than or equal to
-#   a &  b # String concentation
-#   n ^ n  # Exponential
-#
+#   a & b # String concentation
+#   n ^ n # Exponential
+#   
+# =Constants
+# 
+#   TRUE  # true
+#   FALSE # false
+#   NULL  # nil
+# 
 # =Logical Functions
-#
+# 
 #   AND (a,b)
 #   OR  (a,b)
+#   NOT (cond)
 #   IF  (cond,true,false)
-#
+# 
 # =Date/Time Functions
-#
-#  TODAY    ()      # current date value
-#  NOW      ()      # current date/time value
-#  DATE     (y,m,d) # date value
-#  TIME     (h,m,s) # time value
-#  DATETIME (value) # convert a date/time string into a date/time value
-#
+# 
+#   TODAY    ()      # current date value
+#   NOW      ()      # current date/time value
+#   DATE     (y,m,d) # date value
+#   TIME     (h,m,s) # time value
+#   DATETIME (text)  # convert a date/time string into a date/time value
+# 
 # =List Functions
-#
+# 
 #   LIST (a,b,..)    # Variable length list
-#   IN   (find,list) # True if find value is found in the given list (works on strings too)
-#
+#   IN   (find,list) # True if find is found in the given list/string
+# 
 # =Notes
-#
-#  * The number zero is interpereted as FALSE
-#  * Percentages are translated: 25% => 0.25
-#  * Ranges are translated: A1:D5 => LXL::Range.new("A1", "D5")
-#  * Return multiple results in an array by separating formulas with a semi-colon (;)
-#  * Constant and Function names are case-insensitive
-#  * Values prefixed with = are formulas, anything else is assumed to be text:
-#
+# 
+# * Values prefixed with = are formulas, anything else is assumed to be text.
+# 
 #      LXL.eval("5+5")  # => '5+5'
 #      LXL.eval("=5+5") # => 10
+# 
+# * Constant and Function names are case-insensitive.
+# 
+# * The number zero is interpereted as FALSE.
+# 
+# * Separating formulas with a semi-colon returns an Array of results.
 #
 module LXL
 
   module_function
+  
+  # Default parser class.
+  #
+  def parser_class
+    LXL::Parser
+  end
 
-  # False if nil, false or zero.
+  # Create a new Parser.
   #
-  def to_b(value)
-    [nil,false,0].include?(value) ? false : true
+  def new(*args)
+    parser_class.new(*args)
   end
 
   # Evaluate a formula.
   #
   def eval(formula)
-    LXL::Parser.eval(formula)
+    parser_class.eval(formula)
   end
 
-  # Create a new Parser.
+  # False if nil, false or zero.
   #
-  def new(*args)
-    LXL::Parser.new(*args)
+  def to_b(obj)
+    [nil,false,0].include?(obj) ? false : true
   end
 
 end
@@ -107,30 +173,42 @@ class LXL::Parser
     self.new.eval(formula)
   end
   
+  # Default lexer class.
+  #
+  def self.lexer_class
+    LXL::Lexer
+  end
+
   # Default namespace class.
   #
   def self.namespace_class
     LXL::Namespace
   end
 
+  # Default range class.
+  #
+  def self.range_class
+    LXL::Range
+  end
+
   # Initialize namespace and parser.
   #
   def initialize(namespace=self.class.namespace_class.new)
     @namespace = namespace
     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("([^"]|"")*")/m, ?s], # String
-                        [/\A\w+:\w+/, ?r],         # Range
-                        [/\A\d+(\.\d+)?%/, ?p],    # Percentage
-                        [/\A\d+\.\d+/, ?f],        # Float
-                        [/\A\d+/, ?i],             # Integer
-                        [/\A\w+/, ?t],             # Token
-                        [/\A\(/, ?(],              # Open (
-                        [/\A\)/, ?)],              # Close )
-                      ], false)
+    @lexer = self.class.lexer_class.new([
+      [/\A[\s,]+/, ?w],          # Whitespace (includes Commas)
+      [/\A;/, ?;],               # Semi-Colon (statement separator)
+      [/\A(#{ops})/, ?o],        # Operator
+      [/\A("([^"]|"")*")/m, ?s], # String
+      [/\A\w+:\w+/, ?r],         # Range
+      [/\A\d+(\.\d+)?%/, ?p],    # Percentage
+      [/\A\d+\.\d+/, ?f],        # Float
+      [/\A\d+/, ?i],             # Integer
+      [/\A\w+/, ?t],             # Token
+      [/\A\(/, ?(],              # Open (
+      [/\A\)/, ?)],              # Close )
+    ], false)
   end
 
   # Evaluate a formula.
@@ -145,7 +223,7 @@ class LXL::Parser
       tokens = f.collect { |t| t.last  }
       token = tokens.join.strip
       if token =~ /^=/
-        tokens.each_index { |i| tokens[i] = translate_quotes(tokens[i]) if types[i] == :s }
+        tokens.each_index { |i| tokens[i] = translate_quotes(tokens[i]) if types[i] == ?s }
         token = tokens.join.strip.gsub(/^=+/, '')
       else
         token = translate_quotes(quote(tokens.join.strip))
@@ -158,7 +236,7 @@ class LXL::Parser
   
   protected
   
-  # Quote a text value.
+  # Quote a string.
   #
   #  quote('a "quoted" value.')
   #  # => '"a ""quoted"" value."'
@@ -167,7 +245,7 @@ class LXL::Parser
     '"'+text.to_s.gsub('"','""')+'"'
   end
   
-  # Translate "" to \" in quoted string values.
+  # Translate "" to \" in quoted strings.
   #
   #   translate_quotes('"a ""quoted"" value."')
   #   # => '"a \"quoted\" value."'
@@ -176,7 +254,7 @@ class LXL::Parser
     text.to_s.gsub(/([^\\])""/,'\1\"')
   end
 
-  # Tokenize a formula into <tt>[TypesArray, TokensArray]</tt>.
+  # Tokenize a formula into <tt>[TypesString, TokensArray]</tt>.
   #
   def tokenize(formula)
     ops = Hash[*EXCEL_OPERATORS.zip(RUBY_OPERATORS).flatten]
@@ -189,12 +267,12 @@ class LXL::Parser
     tokens.each_index do |i|
       type, token = types[i], tokens[i]
       tokens[i] = case type
-        when :o then ops[token]
-        when :r then "LXL::Range.new(*#{token.split(':').inspect})"
-        when :p then token.to_f/100
-        when :f then token.to_f
-        when :i then token.to_i
-        when :t then
+        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 ?t then
           upper = token.to_s.upcase.to_sym
           lower = token.to_s.downcase.to_sym
           raise NoMethodError, "protected method `#{token}` called for #{self}" if @namespace.const_get(:METHODS).include?(token.to_s)
@@ -202,11 +280,11 @@ class LXL::Parser
             if tokens[i+1] != '('
               raise ArgumentError, "wrong number of arguments for #{token}"
             else
-              types[i] = :F
+              types[i] = ?F
               "@namespace.method(:#{lower}).call"
             end
           elsif @namespace.const_defined?(upper)
-            types[i] = :C
+            types[i] = ?C
             "@namespace.const_get(:#{upper})"
           else token
           end
@@ -237,13 +315,14 @@ end
 #
 class LXL::Range < Range
 
+  EXCEL_RANGE =  /[A-Z]+[1-9]+/
+
   def each
-    a,b = self.begin.to_s, self.end.to_s
-    if a =~ /\D/ and b =~ /\D/
-      r = [a,b].collect{ |x| x.upcase }.sort
-      a_col,b_col = r.collect { |x| x.gsub(/\d/, '') }
-      a_cel,b_cel = r.collect { |x| x.gsub(/\D/, '') }
-      range = Range.new(a_col,b_col).each{ |col| Range.new(a_cel,b_cel).each { |cel| yield col+cel } }
+    range = [self.begin,self.end].collect! { |x| x.to_s.upcase }.sort
+    if range.first =~ EXCEL_RANGE and range.last =~ EXCEL_RANGE
+      fcol,lcol = range.collect { |x| x.gsub(/\d/, '') }
+      fcel,lcel = range.collect { |x| x.gsub(/\D/, '') }
+      Range.new(fcol,lcol).each{ |col| Range.new(fcel,lcel).each { |cel| yield col+cel } }
     else
       super
     end
@@ -279,6 +358,12 @@ class LXL::EmptyNamespace
   METHODS = ['__id__', '__send__', 'constants', 'const_defined?', 'const_get', 'const_set', 'class', 'instance_methods', 'method', 'methods', 'respond_to?', 'to_s']
   (instance_methods-METHODS).sort.each { |m| undef_method m }
 
+  # Default deferred class.
+  #
+  def self.deferred_class
+    LXL::Deferred
+  end
+
   # Ensure all constants are included (inherited, extended, included, etc).
   #
   def self.const_defined?(symbol) #:nodoc:
@@ -295,7 +380,7 @@ class LXL::EmptyNamespace
   #
   def self.register_deferred(*symbols)
     symbols.collect! { |s| s.to_s.downcase.to_sym }
-    symbols.each { |s| define_method(s) { |*args| LXL::Deferred.new(s, *args) } }
+    symbols.each { |s| define_method(s) { |*args| self.class.deferred_class.new(s, *args) } }
   end
 
   # Register uppercase constants of the same name and value.
@@ -341,10 +426,14 @@ class LXL::Namespace < LXL::EmptyNamespace
     LXL.to_b(a) || LXL.to_b(b)
   end
 
+  def not(c)
+    ! c
+  end
+
   def if(c,a,b)
     LXL.to_b(c) ? a : b
   end
-
+  
   def list(*items)
     items
   end
@@ -375,13 +464,9 @@ class LXL::Namespace < LXL::EmptyNamespace
 
 end
 
-# John Carter's LittleLexer.
+# Based on John Carter's LittleLexer (http://littlelexer.rubyforge.org).
 #
-# http://www.rubyforge.org/projects/littlelexer
-#
-# CHANGE: types are returned as [*Symbol] vs String
-#
-class LXL::LittleLexer #:nodoc: all
+class LXL::Lexer #:nodoc: all
 
   class LexerJammed < Exception; end
 
@@ -391,29 +476,29 @@ class LXL::LittleLexer #:nodoc: all
   end
 
   def scan(string,string_token_list=nil)
-    result_list = []
-    token_list = []
+    result_string = String.new
+    token_list = Array.new
     if string_token_list
       next_token(string) do |t,token, tail|
-        result_list << t.chr.to_sym
+        result_string << t
         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_list << t.chr.to_sym
+        result_string << t
         token_list << token
       end
     end
-    return result_list, token_list
+    return result_string, token_list
   end
 
   private
 
   def next_token( string)
     match_data = nil
-    while string != ''
+    while ! string.empty?
       failed = true
       @regex_to_char.each do |regex,char|
         match_data = regex.match(string)
@@ -426,7 +511,6 @@ class LXL::LittleLexer #:nodoc: all
       end
       raise LexerJammed, string if failed
     end
-    
   rescue RegexpError => details
     raise RegexpError, "Choked while '#{@scanner}' was trying to match '#{string}' : #{details}"
   end

data/lxl.gemspec

@@ -0,0 +1,19 @@
+require 'rubygems'
+
+version = File.read('VERSION').strip
+raise "no version" if version.empty?
+
+spec = Gem::Specification.new do |s|
+  s.name = 'lxl'
+  s.version = version 
+  s.author = "Kevin Howe"
+  s.email = "kh@newclear.ca"
+  s.homepage = "lxl.rubyforge.org"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas. Easily extended with new constants and functions."
+  s.files = Dir['**/*'].delete_if { |f| f =~ /(cvs|gem|svn)$/i }
+  s.require_path = 'lib'
+  s.test_file = "test/lxl_test.rb"
+  s.has_rdoc = true
+  s.rubyforge_project = "lxl"
+end

data/lxl.rdoc

@@ -0,0 +1,114 @@
+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
+
+  B3:D5 => LXL::Range.new("B3","D5")
+  
+LXL::Range is a subclass of Range which overrides
+the #each method to return Excel-style ranges.
+
+  # Standard 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
+  a -  b # Subtract
+  a *  b # Multiply
+  a /  b # Divide
+  a =  b # Equal to
+  a <> b # Not equal to
+  a <  b # Less than
+  a >  b # Greater than
+  a <= b # Less than or equal to
+  a >= b # Greater than or equal to
+  a & b # String concentation
+  n ^ n # Exponential
+  
+=Constants
+
+  TRUE  # true
+  FALSE # false
+  NULL  # nil
+
+=Logical Functions
+
+  AND (a,b)
+  OR  (a,b)
+  NOT (cond)
+  IF  (cond,true,false)
+
+=Date/Time Functions
+
+  TODAY    ()      # current date value
+  NOW      ()      # current date/time value
+  DATE     (y,m,d) # date value
+  TIME     (h,m,s) # time value
+  DATETIME (text)  # convert a date/time string into a date/time value
+
+=List Functions
+
+  LIST (a,b,..)    # Variable length list
+  IN   (find,list) # True if find is found in the given list/string
+
+=Notes
+
+* Values prefixed with = are formulas, anything else is assumed to be text.
+
+     LXL.eval("5+5")  # => '5+5'
+     LXL.eval("=5+5") # => 10
+
+* Constant and Function names are case-insensitive.
+
+* The number zero is interpereted as FALSE.
+
+* Separating formulas with a semi-colon returns an Array of results.

data/test/lxl_test.rb

@@ -23,6 +23,7 @@ class LXLTest < Test::Unit::TestCase
       =";"=":"
       =A
       =B
+      =NOT(TRUE)
       =((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")
@@ -39,7 +40,7 @@ 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, 6, true, true, [1, "two", 3.0], true, false, true, "yes", "this and that"]
+    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)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.3
 specification_version: 1
 name: lxl
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
-date: 2005-02-12
+  version: 0.3.1
+date: 2005-02-13
 summary: LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas. Easily extended with new constants and functions.
 require_paths: 
   - lib
@@ -15,7 +15,7 @@ description:
 autorequire: 
 default_executable: 
 bindir: bin
-has_rdoc: false
+has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
     - 
@@ -31,11 +31,14 @@ files:
   - VERSION
   - test
   - CHANGES
+  - lxl.gemspec
   - setup.rb
   - README.en
+  - lxl.rdoc
   - lib/lxl.rb
   - test/lxl_test.rb
-test_files: []
+test_files: 
+  - test/lxl_test.rb
 rdoc_options: []
 extra_rdoc_files: []
 executables: []