lxl 0.1.0

data/README

@@ -0,0 +1,46 @@
+LXL README
+============
+
+LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas.
+Easily extended with new constants and functions.
+
+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");
+  }
+  
+  # single formula
+  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"]
+  
+  See API docs for more information.
+
+Requirements
+------------
+
+  * Ruby 1.8.2
+
+Install
+-------
+
+  gem install lxl
+
+License
+-------
+
+  LXL uses John Carter's LittleLexer for parsing.
+  Distributes under the same terms as LittleLexer.
+  http://www.rubyforge.org/projects/littlelexer/
+
+Kevin Howe <kh@newclear.ca>

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/lxl.rb

@@ -0,0 +1,309 @@
+# LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas.
+# Easily extended with new constants and functions.
+#
+# =Constants
+#
+#  TRUE  # true
+#  FALSE # false
+#  NULL  # nil
+#
+# =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
+#
+# =Logical Functions
+#
+#   AND (a,b)
+#   OR  (a,b)
+#   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
+#
+# =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)
+#
+# =Notes
+#
+#  * The number zero is interpereted as FALSE
+#  * Return multiple results in an array by separating formulas with a semi-colon (;)
+#
+# =Lexical Types
+#
+#  w  Whitespace (includes Commas)
+#  ;  Semi-Colon (statement separator)
+#  o  Operator
+#  i  Integer
+#  f  Float
+#  t  Token
+#  s  String (single quoted)
+#  S  String (double quoted)
+#  (  Open (
+#  )  Close )
+#  C  Constant
+#  F  Function
+#
+module LXL
+
+  module_function
+
+  # Evaluate a formula
+  #
+  def eval(formula)
+    LXL::Parser.eval(formula)
+  end
+
+end
+
+class LXL::Parser
+
+  attr_reader :constants, :functions, :lexer, :tokens, :types
+
+  RUBY_OPERATORS  = ['+', '-', '*', '/', '<=', '>=', '==', '!=', '<', '>']
+  EXCEL_OPERATORS = ['+', '-', '*', '/', '<=', '>=', '=',  '<>', '<', '>']
+
+  # Evaluate a formula
+  #
+  def self.eval(formula)
+    self.new.eval(formula)
+  end
+
+  # Initialize parser
+  #
+  def initialize
+
+    # Constants
+    @constants = {
+      :TRUE  => true,
+      :FALSE => false,
+      :NULL  => nil,
+    }
+    
+    # Functions
+    @functions = Hash.new
+    register(:AND)   { |a,b| to_b(a) && to_b(b) }
+    register(:OR)    { |a,b| to_b(a) || to_b(b) }
+    register(:IF)    { |v,a,b| to_b(v) ? a : b }
+    register(:LIST)  { |*args| args }
+    register(:IN)    { |n,h| h.respond_to?(:include?) ? h.include?(n) : false }
+    register(:TODAY) { Date.today.ajd.to_f }
+    register(:NOW)   { DateTime.now.ajd.to_f }
+    register(:DATE)  { |y,m,d| Date.new(y,m,d).ajd.to_f }
+    register(:TIME)  { |h,m,s|
+      DateTime.valid_time?(h,m,s) ? DateTime.valid_time?(h,m,s).to_f : raise(ArgumentError, 'invalid time')
+    }
+    register(:DATETIME) { |value| DateTime.parse(value).ajd.to_f }
+
+    # Lexer
+    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,?s],    # String (single quoted)
+                        [/\A('[^\']*')/m,?S],    # String (double quoted)
+                        [/\A\w+/,?t],            # Token
+                        [/\A\(/,?(],             # Open (
+                        [/\A\)/,?)],             # Close )
+                      ], false)
+
+    # Other
+    @tokens = Array.new
+    @types = Array.new
+  end
+
+  # 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
+  end
+
+  protected
+  
+  # Register a function
+  #
+  # * Converts name to symbol
+  # * Wraps function with a debugging procedure
+  #
+  def register(name, &block)
+    @functions[name.to_sym] = debug(name.to_sym, &block)
+  end
+
+  # Wrap a procedure in a debugging procedure
+  #
+  # * Raise an error unless given the correct number of arguments
+  #
+  def debug(name, &func)
+    raise ArgumentError, 'block not given to debug' unless block_given?
+    Proc.new { |*args|
+      if func.arity >= 0 and func.arity != args.size
+        raise ArgumentError, "wrong number of arguments (#{args.size} for #{func.arity}) for #{name}"
+      end
+      func.call(*args)
+    }
+  end
+  
+  # Tokenize formula (String => Array)
+  #
+  def tokenize(formula)
+    ops = Hash[*EXCEL_OPERATORS.zip(RUBY_OPERATORS).flatten]
+
+    # Parse formula
+    types, @tokens = @lexer.scan(formula)
+    @types = types.split(//)
+    raise SyntaxError, 'unbalanced parentheses' unless balanced?
+
+    # 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'
+      if type == 't'
+        token = token.to_sym
+        if @functions.key?(token)
+          if @tokens[i+1] != '('
+            raise ArgumentError, "wrong number of arguments for #{token}"
+          else
+            @types[i] = 'F'
+            token = '@functions['+token.inspect+'].call'
+          end
+        elsif @constants.key?(token)
+          @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
+    end
+
+    @tokens
+  end
+  
+  # Check that parentheses are balanced
+  #
+  def balanced?
+    @tokens.find_all { |t| ['(', ')'].include?(t) }.size % 2 == 0
+  end
+
+  # False if nil, false or zero
+  #
+  def to_b(value)
+    [nil,false,0].include?(value) ? false : true
+  end
+
+end
+
+# John Carter's LittleLexer
+#
+# http://www.rubyforge.org/projects/littlelexer
+#
+class LXL::LittleLexer #: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
+  end
+
+  def scan(string,string_token_list=nil)
+    result_string  = ''
+    token_list = []
+    
+    if string_token_list
+      next_token(string) do |t,token, tail|
+        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_string << t
+        token_list << token
+      end
+    end
+    return result_string, token_list
+  end
+
+  private
+
+  def next_token( string)
+    match_data = nil
+    while string != ''
+      failed = true
+      @regex_to_char.each do |regex,char|
+        match_data = regex.match(string)
+        next unless match_data
+        token = match_data[0]
+        yield char,token, match_data.end(0) unless char == ?\s && @skip_white_space 
+        string = match_data.post_match
+        failed = false
+        break
+      end
+      raise LexerJammed, string if failed
+    end
+    
+  rescue RegexpError => details
+    raise RegexpError, "Choked while '#{@scanner}' was trying to match '#{string}' : #{details}"
+  end
+
+end
+
+# Test
+#
+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");
+  }
+  
+  # single formula
+  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"]
+
+end

data/test/lxl_test.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift('../lib')
+require 'test/unit'
+require 'lxl'
+
+class LXLTest < Test::Unit::TestCase
+
+  def test_single_formula
+    assert_equal(10, LXL.eval('5+5'))
+  end
+
+  def test_multiple_formula
+    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");
+    }
+    expected = [6, true, true, [1, "two", 3.0], true, false, true, "yes"]
+    results = LXL.eval(formulas)
+    expected.each_index { |i| assert_equal(expected[i], results[i]) }
+  end
+
+end

metadata

@@ -0,0 +1,42 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.3
+specification_version: 1
+name: lxl
+version: !ruby/object:Gem::Version 
+  version: 0.1.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: 
+  - lib
+email: kh@newclear.ca
+homepage: lxl.rubyforge.org
+rubyforge_project: lxl
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Kevin Howe
+files: 
+  - lib
+  - test
+  - README
+  - VERSION
+  - lib/lxl.rb
+  - test/lxl_test.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []