sdl4r 0.9.9 → 0.9.11

data/test/sdl4r/tag_test.rb

@@ -18,15 +18,23 @@
 # 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 #++
 
+# Work-around a bug in NetBeans (http://netbeans.org/bugzilla/show_bug.cgi?id=188653)
+if ENV["NB_EXEC_EXTEXECUTION_PROCESS_UUID"]
+  $:[0] = File.join(File.dirname(__FILE__),'../../lib')
+  $:.unshift(File.join(File.dirname(__FILE__),'../../test'))
+end
+
 module SDL4R
 
   require 'test/unit'
   require "rexml/document"
 
   require 'sdl4r/tag'
-  
+
+  require "sdl4r/sdl_test_case"
 
   class TagTest < Test::Unit::TestCase
+    include SdlTestCase
 
     public
 
@@ -357,6 +365,9 @@ module SDL4R
 
       tag.set_attributes("", {}) # removes all attributes in the default namespace
       assert_equal({"ns1:a2" => 12, "ns1:a3" => 13}, tag.attributes)
+
+      tag.set_attributes("ns1", {})
+      assert_equal({}, tag.attributes)
     end
 
     def test_to_child_hash
@@ -452,7 +463,7 @@ module SDL4R
       assert !(tag1 == tag2)
       assert !(tag1.equal?(tag2))
       assert_not_equal tag1.hash, tag2.hash
-     end
+    end
 
     def test_children_values
       root = Tag.new "root"
@@ -504,7 +515,7 @@ EOF
       assert_equal "ns1", xml_doc[0].namespace
 
       tag = Tag.new "tag1" do
-        self << 123
+        self << "123"
       end
       xml_doc = REXML::Document.new(tag.to_xml_string(options))
       assert_equal "tag1", xml_doc[0].name
@@ -618,9 +629,9 @@ EOF
       root.write(output, true)
       assert_equal(
         "root 1876/07/01 1592/09/13 09:05:00 1592/09/13 09:05:07" +
-          " -98/06/15 13:47:12.340 3112/01/10 00:00:00+01:00",
+          " -98/06/15 13:47:12.340 3112/01/10 00:00:00-GMT+01:00",
         output)
-   end
+    end
 
     # Check that having a timespan after a date in a tag values doesn't fail when loaded.
     #
@@ -642,5 +653,73 @@ EOF
       assert_equal "square", tag1.attribute("type")
     end
 
+    def test_symbol_as_identifier
+      # Tag identifiers
+      tag = Tag.new(:my_tag)
+      assert_equal "my_tag", tag.name
+
+      tag = Tag.new(:ns, :my_tag)
+      assert_equal "ns", tag.namespace
+      assert_equal "my_tag", tag.name
+
+      tag.namespace = :ns2
+      tag.name = :your_tag
+      assert_equal "ns2", tag.namespace
+      assert_equal "your_tag", tag.name
+
+      child = tag.new_child(:ns, :my_child)
+      assert_equal "ns", child.namespace
+      assert_equal "my_child", child.name
+
+      assert_equal child, tag.child(:ns, :my_child)
+      assert_equal [child], tag.children(false, :ns, :my_child)
+      assert tag.has_child?(:ns, :my_child)
+      assert !tag.has_child?(:ns2, :my_child)
+
+      child << 123
+      assert_equal [123], tag.children_values(:my_child)
+
+      # Attribute identifiers
+      tag.set_attribute(:ns1, :attr1, 2)
+      tag.set_attribute(:attr1, 1)
+      tag.set_attribute(:ns2, :attr1, 3)
+      assert_equal 1, tag.attribute(:attr1)
+      assert_equal 2, tag.attribute(:ns1, :attr1)
+      assert_equal 3, tag.attribute(:ns2, :attr1)
+      assert_equal({"attr1" => 1, "ns1:attr1" => 2, "ns2:attr1" => 3}, tag.attributes)
+      assert_equal({"attr1" => 2}, tag.attributes(:ns1))
+
+      tag.set_attributes(:attr2 => 20, :attr4 => 40)
+      tag.set_attributes(:ns1, :attr3 => 30)
+      assert_equal(
+        {"attr2" => 20, "ns1:attr3" => 30, "attr4" => 40, "ns2:attr1" => 3}, tag.attributes)
+      assert_equal({"attr3" => 30}, tag.attributes(:ns1))
+      assert tag.has_attribute?(:attr2)
+      assert tag.has_attribute?(:ns1, :attr3)
+      assert !tag.has_attribute?(:attr3)
+
+      tag.remove_attribute(:attr2)
+      assert_equal nil, tag.attribute(:attr2)
+      assert tag.has_attribute?(:ns1, :attr3)
+      tag.remove_attribute(:ns1, :attr3)
+      assert !tag.has_attribute?(:ns1, :attr3)
+
+      tag.clear_attributes()
+
+      tag.set_attributes(:ns2, :attr2 => 50, :attr3 => 60, :attr4 => 70)
+      assert_equal({"ns2:attr2" => 50, "ns2:attr3" => 60, "ns2:attr4" => 70}, tag.attributes)
+
+      tag.clear_attributes(:ns1)
+      assert_equal({"ns2:attr2" => 50, "ns2:attr3" => 60, "ns2:attr4" => 70}, tag.attributes)
+      tag.clear_attributes(:ns2)
+      assert !tag.has_attribute?
+      assert !tag.has_attributes?
+
+      tag.clear_attributes
+
+      tag << {:attr10 => 100, :"ns20:attr20" => 200}
+      assert_equal({"attr10" => 100, "ns20:attr20" => 200}, tag.attributes)
+    end
+
   end
 end

data/test/sdl4r/tokenizer_test.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+
+#--
+# Simple Declarative Language (SDL) for Ruby
+# Copyright 2005 Ikayzo, inc.
+#
+# This program is free software. You can distribute or modify it under the
+# terms of the GNU Lesser General Public License version 2.1 as published by
+# the Free Software Foundation.
+#
+# This program is distributed AS IS and WITHOUT WARRANTY. OF ANY KIND,
+# INCLUDING MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, contact the Free Software Foundation, Inc.,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#++
+
+# Work-around a bug in NetBeans (http://netbeans.org/bugzilla/show_bug.cgi?id=188653)
+if ENV["NB_EXEC_EXTEXECUTION_PROCESS_UUID"]
+  $:[0] = File.join(File.dirname(__FILE__),'../../../lib')
+  $:.unshift(File.join(File.dirname(__FILE__),'../../../test'))
+end
+
+if RUBY_VERSION < '1.9.0'
+  $KCODE = 'u'
+  require 'jcode'
+end
+
+module SDL4R
+  module Parser
+
+    require 'stringio'
+    require 'test/unit'
+
+    require 'sdl4r/tag'
+    require 'sdl4r/tokenizer'
+
+    require 'sdl4r/sdl_test_case'
+
+
+    class TokenizerTest < Test::Unit::TestCase
+      include SdlTestCase
+
+      # Fully tokenizes 's' and returns an array of the found token types plus an array of the found
+      # tokens
+      #
+      def tokenize(s)
+        tokenizer = Tokenizer.new(StringIO.new(s))
+        token_types = []
+        tokens = []
+        
+        while tokenizer.read
+          token_types << tokenizer.token_type
+          tokens << tokenizer.token
+        end
+
+        assert_equal :EOF, token_types.last
+        assert_equal nil, tokens.last
+
+        token_types.pop
+        tokens.pop
+
+        return token_types, tokens
+      end
+      private :tokenize
+
+      def test_backquote_strings
+        types, tokens = tokenize("``")
+        assert_equal [:INLINE_BACKQUOTE_STRING], types
+        assert_equal [""], tokens
+
+        types, tokens = tokenize("` `")
+        assert_equal [:INLINE_BACKQUOTE_STRING], types
+        assert_equal [" "], tokens
+
+        types, tokens = tokenize("`abc\\\ndef`")
+        assert_equal(
+          [:MULTILINE_BACKQUOTE_STRING_START, :MULTILINE_BACKQUOTE_STRING_END], types)
+        assert_equal ["abc\\\n", "def"], tokens
+
+        types, tokens = tokenize("`abc\\\n  def`")
+        assert_equal(
+          [:MULTILINE_BACKQUOTE_STRING_START, :MULTILINE_BACKQUOTE_STRING_END], types)
+        assert_equal ["abc\\\n", "  def"], tokens
+
+        types, tokens = tokenize("`\ndef`")
+        assert_equal(
+          [:MULTILINE_BACKQUOTE_STRING_START, :MULTILINE_BACKQUOTE_STRING_END], types)
+        assert_equal ["\n", "def"], tokens
+
+        types, tokens = tokenize("`abc\n  def \n ghi`")
+        assert_equal [
+          :MULTILINE_BACKQUOTE_STRING_START,
+          :MULTILINE_BACKQUOTE_STRING_PART,
+          :MULTILINE_BACKQUOTE_STRING_END],
+          types
+        assert_equal ["abc\n", "  def \n", " ghi"], tokens
+
+
+        types, tokens = tokenize("`abc\n  def \n ghi\n`")
+        assert_equal [
+          :MULTILINE_BACKQUOTE_STRING_START,
+          :MULTILINE_BACKQUOTE_STRING_PART,
+          :MULTILINE_BACKQUOTE_STRING_PART,
+          :MULTILINE_BACKQUOTE_STRING_END],
+          types
+        assert_equal ["abc\n", "  def \n", " ghi\n", ""], tokens
+      end
+
+      def test_double_quote_string
+        types, tokens = tokenize('""')
+        assert_equal [:INLINE_DOUBLE_QUOTE_STRING], types
+        assert_equal [""], tokens
+
+        types, tokens = tokenize('"tutu"')
+        assert_equal [:INLINE_DOUBLE_QUOTE_STRING], types
+        assert_equal ["tutu"], tokens
+
+        types, tokens = tokenize('"\\t"')
+        assert_equal [:INLINE_DOUBLE_QUOTE_STRING], types
+        assert_equal ["\\t"], tokens
+      end
+    end
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 9
-  version: 0.9.9
+  - 11
+  version: 0.9.11
 platform: ruby
 authors: 
 - Philippe Vosges
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-19 00:00:00 +09:00
+date: 2010-12-26 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
-description: "  The Simple Declarative Language provides an easy way to describe lists, maps,\n  and trees of typed data in a compact, easy to read representation.\n  For property files, configuration files, logs, and simple serialization\n  requirements, SDL provides a compelling alternative to XML and Properties\n  files.\n"
+description: "    The Simple Declarative Language provides an easy way to describe lists, maps,\n    and trees of typed data in a compact, easy to read representation.\n    For property files, configuration files, logs, and simple serialization\n    requirements, SDL provides a compelling alternative to XML and Properties\n    files.\n"
 email: sdl-users@ikayzo.org
 executables: []
 
@@ -29,29 +29,84 @@ extra_rdoc_files: []
 
 files: 
 - lib/sdl4r.rb
-- lib/sdl4r/parser/reader.rb
-- lib/sdl4r/parser/time_span_with_zone.rb
-- lib/sdl4r/parser/token.rb
-- lib/sdl4r/parser/tokenizer.rb
-- lib/sdl4r/parser.rb
+- lib/sdl4r/abbreviation_timezone_proxy.rb
+- lib/sdl4r/constant_timezone.rb
+- lib/sdl4r/element.rb
+- lib/sdl4r/reader.rb
+- lib/sdl4r/relative_timezone.rb
 - lib/sdl4r/sdl4r.rb
+- lib/sdl4r/sdl4r_tzinfo.rb
+- lib/sdl4r/sdl4r_version.rb
 - lib/sdl4r/sdl_binary.rb
 - lib/sdl4r/sdl_parse_error.rb
 - lib/sdl4r/sdl_time_span.rb
 - lib/sdl4r/serializer.rb
 - lib/sdl4r/tag.rb
+- lib/sdl4r/token.rb
+- lib/sdl4r/tokenizer.rb
+- lib/sdl4r/tz_abbreviation_db.rb
 - CHANGELOG
 - LICENSE
 - Rakefile
 - README
+- read_jprof.html
+- read_jprof_pull.html
+- read_prof.html
+- read_prof_pull.html
 - TODO
 - test/sdl4r/parser_test.rb
+- test/sdl4r/reader_test.rb
+- test/sdl4r/read_jprof.rb
+- test/sdl4r/read_prof.rb
+- test/sdl4r/relative_timezone_test.rb
 - test/sdl4r/sdl4r_test.rb
-- test/sdl4r/sdl_test.rb
+- test/sdl4r/sdl4r_tzinfo_test.rb
+- test/sdl4r/sdl_test_case.rb
 - test/sdl4r/serializer_test.rb
 - test/sdl4r/tag_test.rb
 - test/sdl4r/test_basic_types.sdl
 - test/sdl4r/test_structures.sdl
+- test/sdl4r/tokenizer_test.rb
+- doc/classes/SDL4R/AbbreviationTimezoneProxy.html
+- doc/classes/SDL4R/ConstantTimezone.html
+- doc/classes/SDL4R/Element.html
+- doc/classes/SDL4R/Reader.html
+- doc/classes/SDL4R/RelativeTimezone.html
+- doc/classes/SDL4R/SdlBinary.html
+- doc/classes/SDL4R/SdlParseError.html
+- doc/classes/SDL4R/SdlTimeSpan.html
+- doc/classes/SDL4R/Serializer/Ref.html
+- doc/classes/SDL4R/Serializer.html
+- doc/classes/SDL4R/Tag.html
+- doc/classes/SDL4R/Token.html
+- doc/classes/SDL4R/TZAbbreviationDB/Record.html
+- doc/created.rid
+- doc/files/CHANGELOG.html
+- doc/files/lib/sdl4r/abbreviation_timezone_proxy_rb.html
+- doc/files/lib/sdl4r/constant_timezone_rb.html
+- doc/files/lib/sdl4r/element_rb.html
+- doc/files/lib/sdl4r/reader_rb.html
+- doc/files/lib/sdl4r/relative_timezone_rb.html
+- doc/files/lib/sdl4r/sdl4r_rb.html
+- doc/files/lib/sdl4r/sdl4r_tzinfo_rb.html
+- doc/files/lib/sdl4r/sdl4r_version_rb.html
+- doc/files/lib/sdl4r/sdl_binary_rb.html
+- doc/files/lib/sdl4r/sdl_parse_error_rb.html
+- doc/files/lib/sdl4r/sdl_time_span_rb.html
+- doc/files/lib/sdl4r/serializer_rb.html
+- doc/files/lib/sdl4r/tag_rb.html
+- doc/files/lib/sdl4r/tokenizer_rb.html
+- doc/files/lib/sdl4r/token_rb.html
+- doc/files/lib/sdl4r/tz_abbreviation_db_rb.html
+- doc/files/lib/sdl4r_rb.html
+- doc/files/lib/sdl4r_tzinfo_rb.html
+- doc/files/LICENSE.html
+- doc/files/README.html
+- doc/fr_class_index.html
+- doc/fr_file_index.html
+- doc/fr_method_index.html
+- doc/index.html
+- doc/rdoc-style.css
 has_rdoc: true
 homepage: http://sdl4r.rubyforge.org/
 licenses: []
@@ -86,7 +141,10 @@ specification_version: 3
 summary: Simple Declarative Language for Ruby library
 test_files: 
 - test/sdl4r/parser_test.rb
+- test/sdl4r/reader_test.rb
+- test/sdl4r/relative_timezone_test.rb
 - test/sdl4r/sdl4r_test.rb
-- test/sdl4r/sdl_test.rb
+- test/sdl4r/sdl4r_tzinfo_test.rb
 - test/sdl4r/serializer_test.rb
 - test/sdl4r/tag_test.rb
+- test/sdl4r/tokenizer_test.rb

data/lib/sdl4r/parser.rb

@@ -1,648 +0,0 @@
-#!/usr/bin/env ruby -w
-# encoding: UTF-8
-
-#--
-# Simple Declarative Language (SDL) for Ruby
-# Copyright 2005 Ikayzo, inc.
-#
-# This program is free software. You can distribute or modify it under the
-# terms of the GNU Lesser General Public License version 2.1 as published by
-# the Free Software Foundation.
-#
-# This program is distributed AS IS and WITHOUT WARRANTY. OF ANY KIND,
-# INCLUDING MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program; if not, contact the Free Software Foundation, Inc.,
-# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#++
-
-
-module SDL4R
-
-  require 'base64'
-
-  require File.dirname(__FILE__) + '/sdl_binary'
-  require File.dirname(__FILE__) + '/sdl_time_span'
-  require File.dirname(__FILE__) + '/sdl_parse_error'
-  require File.dirname(__FILE__) + '/parser/tokenizer'
-
-  # The SDL parser.
-  #
-  # In Ruby 1.8, in order to enable UTF-8 support, you may have to declare the following lines:
-  #
-  #   $KCODE = 'u'
-  #   require 'jcode'
-  #
-  # This will give you correct input and output and correct UTF-8 "general" sorting.
-  # Alternatively you can use the following options when launching the Ruby interpreter:
-  #
-  #   /path/to/ruby -Ku -rjcode
-  #
-  # == Authors
-  # Daniel Leuck, Philippe Vosges
-  #
-  class Parser
-			
-    # Passed to parse_error() in order to specify an error that occured on no specific position
-    # (column).
-    UNKNOWN_POSITION = -2
-	 	
-    # Creates an SDL parser on the specified +IO+.
-    #
-    #   IO.open("path/to/sdl_file") { |io|
-    #     parser = SDL4R::Parser.new(io)
-    #     tags = parser.parse()
-    #   }
-    #
-    def initialize(io)
-      raise ArgumentError, "io == nil" if io.nil?
-			
-      @tokenizer = Tokenizer.new(io)
-    end
-		
-    # Parses the underlying +IO+ and returns an +Array+ of +Tag+.
-    # 
-    # ==Errors
-    # [IOError] If a problem is encountered with the IO
-    # [SdlParseError] If the document is malformed
-    def parse
-      tags = []
-			
-      while tokens = @tokenizer.read_line_tokens()
-        if tokens.last.type == :START_BLOCK
-          # tag with a block
-          tag = construct_tag(tokens[0...-1])
-          add_children(tag)
-          tags << tag
-
-        elsif tokens.first.type == :END_BLOCK
-          # we found an block end token that should have been consumed by
-          # add_children() normally
-          parse_error(
-            "No opening block ({) for close block (}).",
-            tokens.first.line,
-            tokens.first.position)
-        else
-          # tag without block
-          tags << construct_tag(tokens)
-        end
-      end
-			
-      @tokenizer.close()
-			
-      return tags
-    end
-
-    # Creates and returns the object representing a datetime (DateTime in the default
-    # implementation). Can be overriden.
-    #
-    #   def new_date_time(year, month, day, hour, min, sec, time_zone_offset)
-    #     Time.utc(year, month, day, hour, min, sec)
-    #   end
-    #
-    def new_date_time(year, month, day, hour, min, sec, time_zone_offset)
-      SDL4R::new_date_time(year, month, day, hour, min, sec, time_zone_offset)
-    end
-		
-    private
-		
-    # Parses the children tags of +parent+ until an end of block is found.
-    def add_children(parent)
-      while tokens = @tokenizer.read_line_tokens()
-        if tokens.first.type == :END_BLOCK
-          return
-					
-        elsif tokens.last.type == :START_BLOCK
-          # found a child with a block
-          tag = construct_tag(tokens[0...-1]);
-          add_children(tag)
-          parent.add_child(tag)
-					
-        else
-          parent.add_child(construct_tag(tokens))
-        end
-      end
-			
-      parse_error("No close block (}).", @tokenizer.line_no, UNKNOWN_POSITION)
-    end
-		
-    # Construct a Tag (but not its children) from a string of tokens
-    # 
-    # Throws SdlParseError if some bad syntax is found.
-    def construct_tag(tokens)
-      raise ArgumentError, "tokens == nil" if tokens.nil?
-      if tokens.empty?
-        parse_error("Internal Error: empty token list", @tokenizer.line_no, UNKNOWN_POSITION)
-      end
-			
-      first_token = tokens.first
-      if first_token.literal?
-        first_token = Token.new(ANONYMOUS_TAG_NAME)
-        tokens.insert(0, first_token)
-				
-      elsif first_token.type != :IDENTIFIER
-        expecting_but_got(
-          "IDENTIFIER",
-          "#{first_token.type} (#{first_token.text})",
-          first_token.line,
-          first_token.position)
-      end
-			
-      tag = nil
-      if tokens.size == 1
-        tag = Tag.new(first_token.text)
-				
-      else
-        values_start_index = 1
-        second_token = tokens[1]
-				
-        if second_token.type == :COLON
-          if tokens.size == 2 or tokens[2].type != :IDENTIFIER
-            parse_error(
-              "Colon (:) encountered in unexpected location.",
-              second_token.line,
-              second_token.position)
-          end
-					
-          third_token = tokens[2];
-          tag = Tag.new(first_token.text, third_token.text)
-          values_start_index = 3
-					
-        else
-          tag = Tag.new(first_token.text)
-        end
-				
-        # read values
-        attribute_start_index = add_tag_values(tag, tokens, values_start_index)
-				
-        # read attributes
-        if attribute_start_index < tokens.size
-          add_tag_attributes(tag, tokens, attribute_start_index)
-        end
-      end
-			
-      return tag
-    end
-		
-    # Return the position at the end of the value list
-    #
-    def add_tag_values(tag, tokens, start)
-      size = tokens.size()
-      i = start;
-			
-      while i < size
-        token = tokens[i]
-				
-        if token.literal?
-          # if a DATE token is followed by a TIME token combine them
-          next_token = ((i + 1) < size)? tokens[i + 1] : nil
-          if token.type == :DATE && next_token && next_token.type == :TIME
-            date = token.object_for_literal()
-            time_span_with_zone = next_token.object_for_literal()
-						
-            if time_span_with_zone.day
-              # as there are days specified, it can't be a full precision date
-              tag.add_value(date);
-              tag.add_value(
-                SdlTimeSpan.new(
-                  time_span_with_zone.day || 0,
-                  time_span_with_zone.hour,
-                  time_span_with_zone.min,
-                  time_span_with_zone.sec))
-							
-							
-              if time_span_with_zone.time_zone_offset
-                parse_error("TimeSpan cannot have a timeZone", t.line, t.position)
-              end
-							
-            else
-              tag.add_value(combine(date, time_span_with_zone))
-            end
-						
-            i += 1
-						
-          else
-            value = token.object_for_literal()
-            if value.is_a?(TimeSpanWithZone)
-              # the literal looks like a time zone
-              if value.time_zone_offset
-                expecting_but_got(
-                  "TIME SPAN",
-                  "TIME (component of date/time)",
-                  token.line,
-                  token.position)
-              end
-							
-              tag.add_value(SdlTimeSpan.new(value.day || 0, value.hour, value.min, value.sec))
-            else
-              tag.add_value(value)
-            end
-          end
-        elsif token.type == :IDENTIFIER
-          break
-        else
-          expecting_but_got(
-            "LITERAL or IDENTIFIER", token.type, token.line, token.position)
-        end
-				
-        i += 1
-      end
-			
-      return i
-    end
-		
-    #
-    # Add attributes to the given tag
-    #
-    def add_tag_attributes(tag, tokens, start)
-      i = start
-      size = tokens.size
-			
-      while i < size
-        token = tokens[i]
-        if token.type != :IDENTIFIER
-          expecting_but_got("IDENTIFIER", token.type, token.line, token.position)
-        end
-        name_or_namespace = token.text;
-				
-        if i == (size - 1)
-          expecting_but_got(
-            "\":\" or \"=\" \"LITERAL\"",
-            "END OF LINE.",
-            token.line,
-            token.position)
-        end
-				
-        i += 1
-        token = tokens[i]
-        if token.type == :COLON
-          if i == (size - 1)
-            expecting_but_got(
-              "IDENTIFIER", "END OF LINE", token.line, token.position)
-          end
-					
-          i += 1
-          token = tokens[i]
-          if token.type != :IDENTIFIER
-            expecting_but_got(
-              "IDENTIFIER", token.type, token.line, token.position)
-          end
-          name = token.text
-					
-          if i == (size - 1)
-            expecting_but_got("\"=\"", "END OF LINE", token.line, token.position)
-          end
-					
-          i += 1
-          token = tokens[i]
-          if token.type != :EQUALS
-            expecting_but_got("\"=\"", token.type, token.line, token.position)
-          end
-					
-          if i == (size - 1)
-            expecting_but_got("LITERAL", "END OF LINE", token.line, token.position)
-          end
-					
-          i += 1
-          token = tokens[i]
-          if !token.literal?
-            expecting_but_got("LITERAL", token.type, token.line, token.position)
-          end
-					
-          if token.type == :DATE and (i + 1) < size and tokens[i + 1].type == :TIME
-            date = token.get_object_for_literal()
-            time_span_with_zone = tokens[i + 1].get_object_for_literal()
-						
-            if time_span_with_zone.days != 0
-              expecting_but_got(
-                "TIME (component of date/time) in attribute value",
-                "TIME SPAN",
-                token.line,
-                token.position)
-            else
-              tag.set_attribute(name_or_namespace, name, combine(date, time_span_with_zone))
-            end
-						
-            i += 1
-          else
-            value = token.object_for_literal();
-            if value.is_a?(TimeSpanWithZone)
-              time_span_with_zone = value
-							
-              if time_span_with_zone.time_zone_offset
-                expecting_but_got(
-                  "TIME SPAN",
-                  "TIME (component of date/time)",
-                  token.line,
-                  token.position)
-              end
-							
-              time_span = SdlTimeSpan.new(
-                time_span_with_zone.day,
-                time_span_with_zone.hour,
-                time_span_with_zone.min,
-                time_span_with_zone.sec)
-							
-              tag.set_attribute(name_or_namespace, name, time_span)
-            else
-              tag.set_attribute(name_or_namespace, name, value);
-            end
-          end
-        elsif token.type == :EQUALS
-          if i == (size - 1)
-            expecting_but_got("LITERAL", "END OF LINE", token.line, token.position)
-          end
-					
-          i += 1
-          token = tokens[i]
-          if !token.literal?
-            expecting_but_got("LITERAL", token.type, token.line, token.position)
-          end
-					
-          if token.type == :DATE and (i + 1) < size and tokens[i + 1].type == :TIME
-            date = token.object_for_literal()
-            time_span_with_zone = tokens[i + 1].object_for_literal()
-						
-            if time_span_with_zone.day
-              expecting_but_got(
-                "TIME (component of date/time) in attribute value",
-                "TIME SPAN",
-                token.line,
-                token.position)
-            end
-            tag.set_attribute(name_or_namespace, combine(date, time_span_with_zone))
-						
-            i += 1
-          else
-            value = token.object_for_literal()
-            if value.is_a?(TimeSpanWithZone)
-              time_span_with_zone = value
-              if time_span_with_zone.time_zone_offset
-                expecting_but_got(
-                  "TIME SPAN",
-                  "TIME (component of date/time)",
-                  token.line,
-                  token.position)
-              end
-							
-              time_span = SdlTimeSpan.new(
-                time_span_with_zone.day || 0,
-                time_span_with_zone.hour,
-                time_span_with_zone.min,
-                time_span_with_zone.sec)
-              tag.set_attribute(name_or_namespace, time_span)
-            else
-              tag.set_attribute(name_or_namespace, value);
-            end			
-          end
-        else
-          expecting_but_got(
-            "\":\" or \"=\"", token.type, token.line, token.position)
-        end
-				
-        i += 1
-      end
-    end
-		
-    # Combines a simple Date with a TimeSpanWithZone to create a DateTime
-    #
-    def combine(date, time_span_with_zone)
-      time_zone_offset = time_span_with_zone.time_zone_offset
-      time_zone_offset = TimeSpanWithZone.default_time_zone_offset if time_zone_offset.nil?
-			
-      new_date_time(
-        date.year,
-        date.month,
-        date.day,
-        time_span_with_zone.hour,
-        time_span_with_zone.min,
-        time_span_with_zone.sec,
-        time_zone_offset)
-    end
-		
-    private
-    ############################################################################
-    ## Parsers for types
-    ############################################################################
-		
-    def Parser.parse_string(literal)
-      unless literal =~ /(^`.*`$)|(^\".*\"$)/m
-        raise ArgumentError,
-          "Malformed string <#{literal}>." +
-          "	Strings must start and end with \" or `"
-      end
-			
-      return literal[1..-2]
-    end
-		
-    def Parser.parse_character(literal)
-      unless literal =~ /(^'.*'$)/
-        raise ArgumentError,
-          "Malformed character <#{literal}>." +
-          "	Character must start and end with single quotes"
-      end
-			
-      return literal[1]
-    end
-		
-    def Parser.parse_number(literal)
-      # we use the fact that Kernel.Integer() and Kernel.Float() raise ArgumentErrors
-      if literal =~ /(.*)(L)$/i
-        return Integer($1)
-      elsif literal =~ /([^BDF]*)(BD)$/i
-        return BigDecimal($1)
-      elsif literal =~ /([^BDF]*)(F|D)$/i
-        return Float($1)
-      elsif literal.count(".e") == 0
-        return Integer(literal)
-      else
-        return Float(literal)
-      end
-    end
-		
-    # Parses the given literal into a returned array
-    # [days, hours, minutes, seconds, time_zone_offset].
-    # 'days', 'hours' and 'minutes' are integers.
-    # 'seconds' and 'time_zone_offset' are rational numbers.
-    # 'days' and 'seconds' are equal to 0 if they're not specified in +literal+.
-    # 'time_zone_offset' is equal to nil if not specified.
-    #
-    # +allowDays+ indicates whether the specification of days is allowed
-    # in +literal+
-    # +allowTimeZone+ indicates whether the specification of the timeZone is
-    # allowed in +literal+
-    #
-    # All components are returned disregarding the values of +allowDays+ and
-    # +allowTimeZone+.
-    #
-    # Raises an ArgumentError if +literal+ has a bad format.
-    def Parser.parse_time_span_and_time_zone(literal, allowDays, allowTimeZone)
-      overall_sign = (literal =~ /^-/)? -1 : +1
-
-      if literal =~ /^(([+\-]?\d+)d:)/
-        if allowDays
-          days = Integer($2)
-          time_part = literal[($1.length)..-1]
-        else
-          # detected a day specification in a pure time literal
-          raise ArgumentError, "unexpected day specification in #{literal}"
-        end
-      else
-        days = nil
-        time_part = literal
-      end
-			
-      # We have to parse the string ourselves because AFAIK :
-      #	- strptime() can't parse milliseconds
-      #	- strptime() can't parse the time zone custom offset (CET+02:30)
-      #	- strptime() accepts trailing chars
-      #		(e.g. "12:24-xyz@" ==> "xyz@" is obviously wrong but strptime()
-      #		 won't mind)
-      if time_part =~ /^([+-]?\d+):(\d+)(?::(\d+)(?:\.(\d+))?)?(?:(?:-([a-zA-Z]+))?(?:([\+\-]\d+)(?::(\d+))?)?)?$/i
-        hours = $1.to_i
-        minutes = $2.to_i
-        # seconds and milliseconds are implemented as one rational number
-        # unless there are no milliseconds
-        millisecond_part = ($4)? $4.ljust(3, "0") : nil
-        if millisecond_part
-          seconds = Rational(($3 + millisecond_part).to_i, 10 ** millisecond_part.length)
-        else
-          seconds = ($3)? Integer($3) : 0
-        end
-				
-        if ($5 or $6) and not allowTimeZone
-          raise ArgumentError, "unexpected time zone specification in #{literal}"
-        end
-				
-        time_zone_code = $5 # might be nil
-
-        if $6
-          zone_custom_minute_offset = $6.to_i * 60
-          if $7
-            if zone_custom_minute_offset > 0
-              zone_custom_minute_offset = zone_custom_minute_offset + $7.to_i
-            else
-              zone_custom_minute_offset = zone_custom_minute_offset - $7.to_i
-            end
-          end
-        end
-
-        time_zone_offset = get_time_zone_offset(time_zone_code, zone_custom_minute_offset)
-				
-        if not allowDays and $1 =~ /^[+-]/
-          # unexpected timeSpan syntax
-          raise ArgumentError, "unexpected sign on hours : #{literal}"
-        end
-
-        # take the sign into account
-        hours *= overall_sign if days # otherwise the sign is already applied to the hours
-        minutes *= overall_sign
-        seconds *= overall_sign
-				
-        return [ days, hours, minutes, seconds, time_zone_offset ]
-				
-      else
-        raise ArgumentError, "bad time component : #{literal}"
-      end
-    end
-		
-    # Parses the given literal (String) into a returned DateTime object.
-    #
-    # Raises an ArgumentError if +literal+ has a bad format.
-    def Parser.parse_date_time(literal)
-      raise ArgumentError("date literal is nil") if literal.nil?
-			
-      begin
-        parts = literal.split(" ")
-        if parts.length == 1
-          return parse_date(literal)
-        else
-          date = parse_date(parts[0]);
-          time_part = parts[1]
-					
-          days, hours, minutes, seconds, time_zone_offset =
-            parse_time_span_and_time_zone(time_part, false, true)
-					
-          return new_date_time(
-            date.year, date.month, date.day, hours, minutes, seconds, time_zone_offset)
-        end
-				
-      rescue ArgumentError
-        raise ArgumentError, "Bad date/time #{literal} : #{$!.message}"
-      end
-    end
-
-    ##
-    # Returns the time zone offset (Rational) corresponding to the provided parameters as a fraction
-    # of a day. This method adds the two offsets if they are both provided.
-    # 
-    # +time_zone_code+: can be nil
-    # +custom_minute_offset+: can be nil
-    #
-    def Parser.get_time_zone_offset(time_zone_code, custom_minute_offset)
-      return nil unless time_zone_code or custom_minute_offset
-
-      time_zone_offset = custom_minute_offset ? Rational(custom_minute_offset, 60 * 24) : 0
-      
-      return time_zone_offset unless time_zone_code
-			
-      # we have to provide some bogus year/month/day in order to parse our time zone code
-      d = DateTime.strptime("1999/01/01 #{time_zone_code}", "%Y/%m/%d %Z")
-      # the offset is a fraction of a day
-      return d.offset() + time_zone_offset
-    end
-		
-    # Parses the +literal+ into a returned Date object.
-    #
-    # Raises an ArgumentError if +literal+ has a bad format.
-    
-    def Parser.parse_date(literal)
-      # here, we're being stricter than strptime() alone as we forbid trailing chars
-      if literal =~ /^(-?\d+)\/(\d+)\/(\d+)$/
-        begin
-          return Date.strptime(literal, "%Y/%m/%d")
-        rescue ArgumentError
-          raise ArgumentError, "Malformed Date <#{literal}> : #{$!.message}"
-        end
-      end
-
-      raise ArgumentError, "Malformed Date <#{literal}>"
-    end
-		
-    # Returns a String that contains the binary content corresponding to +literal+.
-    #
-    # +literal+ : a base-64 encoded literal (e.g. "[V2hvIHdhbnRzIHRvIGxpdmUgZm9yZXZlcj8=]")
-    def Parser.parse_binary(literal)
-      clean_literal = literal[1..-2] # remove square brackets
-      return SdlBinary.decode64(clean_literal)
-    end
-		
-    # Parses +literal+ (String) into the corresponding SDLTimeSpan, which is then
-    # returned.
-    #
-    # Raises an ArgumentError if the literal is not a correct timeSpan literal.
-    def Parser.parse_time_span(literal)
-      days, hours, minutes, seconds, time_zone_offset =
-        parse_time_span_and_time_zone(literal, true, false)
-			
-      milliseconds = ((seconds - seconds.to_i) * 1000).to_i
-      seconds = seconds.to_i
-			
-      return SDLTimeSpan.new(days, hours, minutes, seconds, milliseconds)
-    end
-
-    # Close the reader and throw a SdlParseError using the format
-    # Was expecting X but got Y.
-    #
-    def expecting_but_got(expecting, got, line, position)
-      @tokenizer.expecting_but_got(expecting, got, line, position)
-    end
-
-    # Raises a SdlParseError.
-    def parse_error(description, line_no, position)
-      @tokenizer.parse_error(description, line_no, position)
-    end
-  end
-end