lxl 0.3.1 → 0.3.4

data/CHANGES

@@ -1,3 +1,15 @@
+0.3.4
+
+- Now recognizes complex Range formats
+
+   B3:D5
+   Sheet1!B3:D5
+   [Book1.xls]Sheet1!B3:D5
+   
+  LXL::Range has attr_accessors for :book and :sheet
+
+- Documentation
+
 0.3.1
 
 - LXL::LittleLexer => LXL::Lexer, types is a string again.

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.4

data/lib/lxl.rb

@@ -20,12 +20,17 @@
 # 
 # =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.
+# LXL::Range provides Excel-style ranges. 
+# 
+# <b>Valid Formats</b>
+#
+#    B3:D5
+#    Sheet1!B3:D5
+#    [Book1.xls]Sheet1!B3:D5
 # 
-#   # Standard Ruby Range
+# <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",
@@ -33,7 +38,7 @@
 # 
 #   # LXL Range
 #   LXL::Range.new("B3", "D5").collect
-#   # => ["B3", "B4", "B5", "C3", "C4", "C5", "D3", "D4", "D5"]
+#    # => ["B3", "B4", "B5", "C3", "C4", "C5", "D3", "D4", "D5"]
 # 
 # =Percentages
 # 
@@ -71,9 +76,9 @@
 #   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
+#   a ^  b # Exponential
+# 
 # =Constants
 # 
 #   TRUE  # true
@@ -98,7 +103,7 @@
 # =List Functions
 # 
 #   LIST (a,b,..)    # Variable length list
-#   IN   (find,list) # True if find is found in the given list/string
+#   IN   (find,list) # True if find is in the given list (or string)
 # 
 # =Notes
 # 
@@ -196,12 +201,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)
     @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
+      [xlr, ?r],                 # Range
       [/\A\d+(\.\d+)?%/, ?p],    # Percentage
       [/\A\d+\.\d+/, ?f],        # Float
       [/\A\d+/, ?i],             # Integer
@@ -273,9 +279,9 @@ class LXL::Parser
         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)
+          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}"
@@ -303,31 +309,91 @@ class LXL::Parser
 
 end
 
-# Excel-style ranges.
+# Excel-style ranges. 
+# 
+# =Valid formats
+#
+#    B3:D5
+#    Sheet1!B3:D5
+#    [Book1.xls]Sheet1!B3:D5
+# 
+# =Collection
 #
+#   # 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"]
-#
+#    # => ["B3", "B4", "B5", "C3", "C4", "C5", "D3", "D4", "D5"]
+# 
 class LXL::Range < Range
 
-  EXCEL_RANGE =  /[A-Z]+[1-9]+/
+  # 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
+  
+  # True if this is an Excel range.
+  attr_accessor :excel
+  
+  # Given workbook name.
+  attr_accessor :book
+
+  # Given worksheet name.
+  attr_accessor :sheet
+
+  def self.new(first, last)
+    excel = (first =~ EXCEL_VECTOR && last =~ EXCEL_VECTOR)
+    if excel
+      first =~ EXCEL_VECTOR
+      book,sheet,first = $2,$4,$5
+      obj = super(*[first.upcase,last.upcase].sort)
+      obj.excel = true
+      obj.book = book
+      obj.sheet = sheet
+    else
+      obj = super
+      obj.excel = false
+    end
+    obj
+  end
+
+  def excel?
+    @excel ? true : false
+  end
+
+  def first_column
+    first.to_s.upcase.gsub(/[^A-Z]/, '')
+  end
+
+  def last_column
+    last.to_s.upcase.gsub(/[^A-Z]/, '')
+  end
+  
+  def first_cell
+    first.to_s.gsub(/[^1-9]/, '')
+  end
+  
+  def last_cell
+    last.to_s.gsub(/[^1-9]/, '')
+  end
 
   def each
-    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 } }
+    if excel?
+      Range.new(first_column, last_column).each do |column|
+        Range.new(first_cell, last_cell).each do |cell|
+          yield column+cell
+        end
+      end
     else
       super
     end
   end
-
+  
 end
 
 # Snapshots the symbol/arguments of a function call for later use.
@@ -353,9 +419,19 @@ end
 #
 class LXL::EmptyNamespace
 
-  # Remove all unessecary methods
+  # Ensure all constants are included (inherited, extended, included, etc).
+  #
+  def self.const_defined?(symbol) #:nodoc:
+    constants.include?(symbol.to_s)
+  end
+
+  # Create instance methods for constant-related methods
   ['constants', 'const_defined?', 'const_get', 'const_set'].each { |m| define_method(m) { |s| self.class.send(m,s) } }
+
+  # Preserved methods
   METHODS = ['__id__', '__send__', 'constants', 'const_defined?', 'const_get', 'const_set', 'class', 'instance_methods', 'method', 'methods', 'respond_to?', 'to_s']
+
+  # Clear all unessecary methods
   (instance_methods-METHODS).sort.each { |m| undef_method m }
 
   # Default deferred class.
@@ -364,12 +440,6 @@ class LXL::EmptyNamespace
     LXL::Deferred
   end
 
-  # Ensure all constants are included (inherited, extended, included, etc).
-  #
-  def self.const_defined?(symbol) #:nodoc:
-    constants.include?(symbol.to_s)
-  end
-  
   # Register lowercase methods which return a Deferred function call.
   #
   #   class MyNamespace < LXL::Namespace

data/lxl.gemspec

@@ -14,6 +14,7 @@ spec = Gem::Specification.new do |s|
   s.files = Dir['**/*'].delete_if { |f| f =~ /(cvs|gem|svn)$/i }
   s.require_path = 'lib'
   s.test_file = "test/lxl_test.rb"
+  s.rdoc_options <<  '--all' << '--inline-source'
   s.has_rdoc = true
   s.rubyforge_project = "lxl"
 end

data/test/lxl_test.rb

@@ -51,10 +51,15 @@ class LXLTest < Test::Unit::TestCase
   def test_range
     lxl = LXL::Parser.new(MyNamespace.new)
     res = lxl.eval('=LIST(d5:b3, "x")')
-    assert_equal(LXL::Range, res.first.class)
-    assert_equal("B3", res.first.min)
-    assert_equal("D5", res.first.max)
-    assert_equal(res.first.collect.join(','), "B3,B4,B5,C3,C4,C5,D3,D4,D5")
+    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')
   end
   
   def test_deferred
@@ -65,6 +70,26 @@ class LXLTest < Test::Unit::TestCase
     assert_equal(:testing, res.symbol)
     assert_equal(3, res.args.last)
   end
+  
+  def test_range_naming
+    lxl = LXL::Parser.new(MyNamespace.new)
+    range = lxl.eval('=B1:D2')
+    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('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('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('Book1', range.book)
+    assert_equal('Sheet3', range.sheet)
+  end
 
   def test_ns_methods
     ns = MyNamespace.new
@@ -91,8 +116,12 @@ class LXLTest < Test::Unit::TestCase
   end
   
   def test_ns_access
-    ns = MyNamespace.new
-    assert_equal(:failed, begin ns.__get__(:class) rescue :failed end)
+    res = begin
+      LXL.eval('=CLASS()')
+    rescue NoMethodError => e
+      :failed
+    end
+    assert_equal(:failed, res)
   end
 
   class MyLXLNamespace < LXL::Namespace

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.3
 specification_version: 1
 name: lxl
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2005-02-13
+  version: 0.3.4
+date: 2005-02-14
 summary: LXL (Like Excel) is a mini-language that mimics Microsoft Excel formulas. Easily extended with new constants and functions.
 require_paths: 
   - lib
@@ -34,12 +34,13 @@ files:
   - lxl.gemspec
   - setup.rb
   - README.en
-  - lxl.rdoc
   - lib/lxl.rb
   - test/lxl_test.rb
 test_files: 
   - test/lxl_test.rb
-rdoc_options: []
+rdoc_options: 
+  - "--all"
+  - "--inline-source"
 extra_rdoc_files: []
 executables: []
 extensions: []

data/lxl.rdoc

@@ -1,114 +0,0 @@
-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.