udat 1.3.0 → 1.4.0

data/example.udat

@@ -63,6 +63,8 @@ Sample configuration file:
 
 General Information:
 
+  UDAT documents are composed of UDAT nodes.
+
   Every UDAT node can either be a scalar or a collection. Scalars have
   content represented by a single string, while collections contain other
   UDAT nodes.
@@ -70,6 +72,9 @@ General Information:
   Every UDAT node may be tagged, that means a meta-information in form of
   a string is added. This information can be seen as type information.
 
+  UDAT nodes are normally enclosed in square brackets, but if being used as
+  keys in key/value pairs, they are enclosed in angle brackets.
+
   Comments may appear anywhere in the document except in tags or scalars.
 
   The following 7 characters are to be escaped with a backslash, unless
@@ -80,11 +85,14 @@ General Information:
 
 Scalar values:
 
-  Any string without square or angle brackets or the tilde symbol is
-  considered to be a scalar:
+  Any string enclosed in square or angle brackets, which doesn't contain
+  square or angle brackets or the tilde symbol inside is considered to be a
+  scalar:
 
   [Hello World!]
 
+  However, angle brackets may only be used for keys in key/value lists.
+
   You may add an additional tag, by preceding the string with the tag and
   the pipe symbol:
 
@@ -109,10 +117,10 @@ Scalar values:
 
 Collections:
 
-  Any string which includes either square or angle brackets or a tilde
-  symbol is considered to be a collection. Each entry in a collection
+  If the contents contain either square or angle brackets or a tilde symbol
+  the node is considered to be a collection. Each entry in a collection
   consists of a value and optionally a key associated with that value.
-  The key is written in angle brackets and being followed by the value in
+  The key is written with angle brackets and being followed by the value in
   square brackets. If the value has no key, the angle brackets are not
   written.
 
@@ -178,6 +186,16 @@ Collections:
      < <red>[off] <yellow>[on]  <green>[off] >  [prepare to stop]  ]
 
 
+Tags:
+
+  There are no standard tags defined, each application or protocol can use
+  their own tags. It is recommended to not use an at-symbol (@) in the tag,
+  unless wanting to create a globally unique tag in the form of
+  "localpart@domain", e.g.:
+
+  [example@udat.org|Scalar having a unique tag.]
+
+
 Structured meta information:
 
   Don't abuse tags to store complicated meta information like this:

data/lib/udat.rb

@@ -1,6 +1,9 @@
 #!/usr/bin/env ruby
 
 require 'monitor'
+require 'resolv'
+require 'socket'
+require 'timeout'
 
 # Copyright (c) 2007 FlexiGuided GmbH, Berlin
 #
@@ -16,90 +19,41 @@ require 'monitor'
 # The format is comparable to formats like XML or YAML, but due to its
 # simplicity is much more easy to parse.
 #
-# UDAT documents can be generated by converting any Object to a Udat::Node,
+# UDAT documents can be generated by converting an Object to a Udat::Node,
 # by calling Object#to_udat, and then encoding them by calling
-# Udat::Node#encode_document.
+# Udat::Node#encode.
 #
-# UDAT documents can be parsed by calling String#parse_udat_document.
+# UDAT documents can be parsed by calling String#parse_udat.
+#
+# There are methods providing useful IO functions for UDAT documents:
+# IO#read_udat, IO#write_udat, Udat::Node#rpc and Udat.run_rpc_server.
 module Udat
 
-  # Error raised by Udat::Collection#fetch,
-  # when a fetched value doesn't have the expected tag (i.e. type).
-  class UdatTagMismatch < StandardError; end
-  # Error raised by Udat::Collection#fetch,
-  # when a fetched value is a collection instead of a scalar or vice versa.
-  class UdatTypeMismatch < StandardError; end
+  module_function
+
+  # Error raised, when a fetched Udat::Node doesn't have expected
+  # properties.
+  class UdatPropertyMismatch < StandardError; end
+  # Error raised, when a fetched Udat::Node doesn't have the expected tag
+  # (i.e. type).
+  class UdatTagMismatch < UdatPropertyMismatch; end
+  # Error raised, when a fetched Udat::Node is a collection instead of a
+  # scalar or vice versa.
+  class UdatTypeMismatch < UdatPropertyMismatch; end
+  # Error raised, when an Udat::Node could not be found by
+  # Udat::Collection#fetch.
+  class UdatIndexError < IndexError; end
   # UDAT parsing error
   class ParseError < StandardError; end
 
-  # Special argument passed to Udat::Node#to_udat, if the tag is to be
-  # kept.
-  KeepTag = Object.new
-
-  # A string containing an UDAT example document.
-  ExampleDocument = <<-'END_OF_EXAMPLE'
-  [sample config v1.0|
-
-    <network> [
-      <max connections> [256]
-      <reverse lookups> [yes]
-    ]
-
-    <locale> [
-      <language> [de]    german language
-      <timezone> [CET]   and CET timezone
-      Comments can appear almost anywhere.
-    ]
-
-    <access control> [
-      <allowed> [
-        [user|martin]
-        [user|max]
-        [group|admins]
-        [ip4network|
-          <address> [192.168.0.0]
-          <netmask> [255.255.255.0]
-        ]
-      ]
-      <blocked> [~]   The tilde symbol denotes an empty collection.
-    ]
-
-    <misc> [
-      <symbol for homedir> [\~]   Not an empty collection but the scalar
-                                  value "~".
-    ]
-
-    <address mappings> [
-
-      <email|
-        <user>   [jan.behrens]
-        <domain> [flexiguided.de]
-      >
-      [mbox|jan]
-
-      <email|
-        <user>   [glob|*]
-        <domain> [flexiguided.de]
-      >
-      [mbox|catchall]
-
-    ]
-
-    <logging> [
-      <verbosity>   [high]
-  \## <verbosity>   [debug] ##   Uncomment this for debug output.
-      <destination> [file|/var/log/sample.log]
-    ]
-
-  ]
-  END_OF_EXAMPLE
+  # Special argument used as an argument default, do not use it directly.
+  AnyTag = Object.new
 
   # Returns an escaped version of a string, where backslashes are
   # preceding certain reserved characters.
   def escape_string(string)
     string.to_s.gsub /([<>\[\]|~\\])/, "\\\\\\1"
   end
-  module_function :escape_string
 
   # The abstract class to represent any UDAT data is a Udat::Node.
   # Udat::Node's basically consist of a tag and the content. The tag can be
@@ -111,12 +65,14 @@ module Udat
   # Udat::Node's can most easily be constructed from other ruby objects by
   # using the Object#to_udat method.
   #
-  # By calling the method Udat::Node#encode_document, the Node and its
-  # children are encoded in a both easily human readable and easily machine
-  # readable format. The output can be later parsed by
-  # String#parse_udat_document or IO#read_udat.
+  # By calling the method Udat::Node#encode, the Node and its children are
+  # encoded in a both easily human readable and easily machine readable
+  # format. The output can be later parsed by String#parse_udat or
+  # IO#read_udat.
   class Node
 
+    public
+
     include MonitorMixin
 
     private_class_method :new
@@ -139,62 +95,109 @@ module Udat
     end
 
     # Returns true, if the Udat::Node represents a scalar value.
-    # Shortcut for Udat::Node#kind_of? Udat::Scalar.
     def scalar?
-      kind_of? Scalar
+      false
     end
     # Returns true, if the Udat::Node represents a collection.
-    # Shortcut for Udat::Node#kind_of? Udat::Collection.
     def collection?
-      kind_of? Collection
+      false
+    end
+
+    # Returns self, if the tag is matching the argument,
+    # otherwise an Udat::UdatTagMismatch exception is raised.
+    def require_tag(tag)
+      synchronize do
+        if self.tag == tag.to_s
+          return self
+        else
+          raise UdatTagMismatch, "UDAT tag mismatch."
+        end
+      end
+    end
+    # Returns self, if the Udat::Node represents a scalar,
+    # otherwise an Udat::UdatTypeMismatch exception is raised.
+    # If an optional tag is given as an argument,
+    # it is checked by calling Udat::Node#require_tag.
+    def require_scalar(tag = AnyTag)
+      if scalar?
+        if tag == AnyTag
+          return self
+        else
+          return require_tag(tag)
+        end
+      elsif collection?
+        raise UdatTypeMismatch,
+          "UDAT collection found where a scalar was expected."
+      else
+        raise "Internal error in UDAT library."
+      end
+    end
+    # Returns self, if the Udat::Node represents a collection,
+    # otherwise an Udat::UdatTypeMismatch exception is raised.
+    # If an optional tag is given as an argument,
+    # it is checked by calling Udat::Node#require_tag.
+    def require_collection(tag = AnyTag)
+      if collection?
+        if tag == AnyTag
+          return self
+        else
+          return require_tag(tag)
+        end
+      elsif scalar?
+        raise UdatTypeMismatch,
+          "UDAT scalar found where a collection was expected."
+      else
+        raise "Internal error in UDAT library."
+      end
     end
 
-    # Returns the data (including it's tag) encoded in the UDAT format. The
-    # result is not enclosed by square brackets, so not intended to be
-    # used externally. This method is public for backwards compatiblity
-    # only, and will be declared protected in future.
-    # Use Udat::Node#encode_document instead.
-    def encode_part
+    # Returns the encoded form of the content as a string.
+    # This method is used by Udat::Node#encode_without_brackets.
+    def encode_content
+    end
+    protected :encode_content
+    # Returns the data (including it's tag) encoded in the UDAT format.
+    # The result is not enclosed by square brackets, so not intended to be
+    # used directly externally.
+    def encode_without_brackets
       synchronize do
         if tag
-          return "#{Udat::escape_string tag}|#{encoded_content}"
+          return "#{Udat::escape_string tag}|#{encode_content}"
         else
-          return encoded_content
+          return encode_content
         end
       end
     end
+    protected :encode_without_brackets
     # Returns the data (including it's tag) encoded in the UDAT format and
-    # enclosed in square brackets. This is the preferred form of encoding,
-    # when storing the data in files or over streams.
+    # enclosed in square brackets.
     #
     # Note: The UDAT format doesn't contain information, whether contained
     # collections are ordered or unordered. This information is lost during
     # the encoding process, and has to be restored in an application
     # specific way, if neccessary.
-    def encode_document
-      "[#{encode_part}]"
-    end
-    # Deprecated. This method is an alias for Udat::Node#encode_part, but
-    # it is planned to be changed to Udat::Node#encode_document.
     def encode
-      encode_part
+      "[#{encode_without_brackets}]"
     end
-    # Here the method does the same as Udat::Node#encode_part, but this
-    # method is overwritten in Udat::Scalar! It is also planned to change
-    # the behaviour to Udat::Node#encode_document in future.
+    # Alias for Udat::Node#encode, will be removed in future versions.
+    def encode_document
+      encode
+    end
+    # Here the method does the same as Udat::Node#encode,
+    # but this method is overwritten in Udat::Scalar!
     def to_s
-      encode_part
+      encode
     end
-    # Does the same as Udat::Node#encode_document, but preceds the result
-    # with "udat".
+    # Does the same as Udat::Node#encode,
+    # but preceds the result with "udat".
     def inspect
-      "udat#{self.encode_document}"
+      "udat#{self.encode}"
     end
 
     # Returns self, or a duplicate of self with a different tag set, if an
     # argument is passed.
-    def to_udat(tag = KeepTag)
-      if tag == KeepTag
+    def to_udat(tag = AnyTag)
+      if tag == AnyTag
         return self
       else
         obj = nil
@@ -379,41 +382,37 @@ module Udat
     end
     private_class_method :parse_intern
 
-    # Deprecated. Parses a string encoded by Udat::Node#encode_part. This
-    # method might be removed in future versions. Use
-    # Udat::Node#encode_document in combination with
-    # Udat::Node.parse_document instead.
-    def self.parse_part(input)
+    # Parses a given UDAT document string and returns a structure of
+    # Udat::Node's.
+    #
+    # Note: When parsing UDAT data, no information is gained, whether
+    # collections are ordered or unordered. After parsing, all collections
+    # will be marked as unordered, unless changed later by the application.
+    def self.parse(input)
       input = input.to_s
       pos = 0
       begin
-        return (
+        collection = (
           parse_intern(:normal, nil) do
             char = input[pos, 1]
             pos += 1
             next char.empty? ? nil : char
           end
         )
+        unless collection.collection? and not collection.empty?
+          raise ParseError, "No valid UDAT object found."
+        end
+        return collection.first
       rescue EOFError
         raise ParseError, $!.message
       end
     end
-    # Parses a given UDAT document string and returns a structure of
-    # Udat::Node's. It does the same as Udat::Node.parse_part(input).first.
-    #
-    # Note: When parsing UDAT data, no information is gained, whether
-    # collections are ordered or unordered. After parsing, all collections
-    # will be marked as unordered, unless changed later by the application.
+    # Alias for Udat::Node.parse, will be removed in future versions.
     def self.parse_document(input)
-      parse(input).first or raise ParseError, "No UDAT object found."
-    end
-    # Deprecated. This method is an alias for Udat::Node.parse_part, but
-    # in future it might be changed to Udat::Node.parse_document.
-    def self.parse(input)
-      parse_part(input)
+      parse(input)
     end
 
-    # Reads Udat::Node encoded by Udat::Node#encode_document from a stream.
+    # Reads an encoded Udat::Node from a stream.
     def self.read_from_stream(io)
       return (
         parse_intern(:one_value, nil) do
@@ -421,16 +420,52 @@ module Udat
         end
       )
     end
-
-    # Encodes an object by calling Object#to_udat followed by
-    # Udat::Node#encode_document, and writes it to a stream. Returns self.
+    # Encodes an object in the UDAT format by calling Object#to_udat
+    # followed by Udat::Node#encode, and writes it to a stream.
+    # Returns self.
     def write_to_stream(io)
-      io << self.to_udat.encode_document
+      io << self.to_udat.encode
       return self
     end
 
-  end
+    # Sends the object in encoded form through a TCP connection to a given
+    # host and port, or if no port is supplied to the host and port
+    # specified in a DNS SRV record "_udat-rpc._tcp.<domain>". Returns the
+    # UDAT object received as a reply. As this method can block for an
+    # unlimited amount of time, it might be useful to enclose the call in a
+    # Timeout.timeout call.
+    def rpc(domain, port = nil)
+      domain = domain.to_str
+      port = port.to_int if port
+      socket_args = nil
+      result = nil
+      Resolv::DNS.open do |dns|
+        if port.nil?
+          srv_rr = dns.getresource(
+            "_udat-rpc._tcp.#{domain}",
+            Resolv::DNS::Resource::IN::SRV
+          )
+          socket_args = [srv_rr.target.to_s, srv_rr.port.to_i]
+        else
+          socket_args = [domain, port]
+        end
+      end
+      socket = nil
+      begin
+        socket = TCPSocket.new(*socket_args)
+        socket.write_udat(self)
+        socket.close_write
+        result = socket.read_udat
+      ensure
+        socket.close if socket
+      end
+      unless result
+        raise EOFError, "End of file before reading UDAT RPC result."
+      end
+      return result
+    end
 
+  end
 
   # Class of Udat::Node's holding an ordered or unordered collection of
   # values (where each value can optionally have a key associated with it).
@@ -442,6 +477,8 @@ module Udat
   # methods of this class to Udat::Node's using Object#to_udat.
   class Collection < Node
 
+    public
+
     # Internally used wrapper class for Udat::Node's, to lookup
     # Udat::Collection's in Hash'es, while ignoring the order of their
     # content.
@@ -509,6 +546,11 @@ module Udat
       content.to_ary.each { |entry| self << entry }
     end
 
+    # Returns true.
+    def collection?
+      true
+    end
+
     # Deletes the internal index hashes.
     # They are automatically reconstructed once a lookup is done.
     # This method should be called by the user, if contained Udat objects
@@ -793,54 +835,41 @@ module Udat
         return value_by_key(key)
       end
     end
-    # Same as Udat::Collection#[], but raises an error, if no value was
-    # found. If an additional second argument is passed, an error will also
-    # be raised if the tag (i.e. type) of the value is not equal to the
-    # second argument.
-    def fetch(*args)
-      if args.length == 1
-        value = self[args[0]]
-        unless value
-          raise IndexError, "Value for the given key or index not found."
-        end
-        return value
-      elsif args.length == 2
-        value = fetch(args[0])
-        unless value.tag == args[1]
-          raise UdatTagMismatch, "UDAT tag mismatch."
-        end
-        return value
-      else
-        raise ArgumentError, "Wrong number of arguments supplied."
+    # Same as Udat::Collection#[], but raises an Udat::UdatIndexError, if
+    # no value was found. If an additional second argument is passed, an
+    # error will also be raised if the tag (i.e. type) of the value is not
+    # equal to the second argument.
+    def fetch(key, tag = AnyTag)
+      value = self[key]
+      unless value
+        raise UdatIndexError, "UDAT node not found."
       end
+      value.require_tag(tag) unless tag == AnyTag
+      return value
     end
     # Same as Udat::Collection#fetch, but raises an error, if the value is
-    # not an Udat::Collection.
-    def fetch_collection(*args)
-      value = fetch(*args)
-      if value.scalar?
-        raise UdatTypeMismatch,
-          "Scalar value found, where a collection was expected."
-      end
+    # not an Udat::Scalar.
+    def fetch_scalar(key, tag = AnyTag)
+      value = fetch(key)
+      value.require_scalar
+      value.require_tag(tag) unless tag == AnyTag
       return value
     end
     # Same as Udat::Collection#fetch, but raises an error, if the value is
-    # not an Udat::Scalar.
-    def fetch_scalar(*args)
-      value = fetch(*args)
-      if value.collection?
-        raise UdatTypeMismatch,
-          "Collection found, where a scalar value was expected."
-      end
+    # not an Udat::Collection.
+    def fetch_collection(key, tag = AnyTag)
+      value = fetch(key)
+      value.require_collection
+      value.require_tag(tag) unless tag == AnyTag
       return value
     end
     # Returns the first value of the collection, or nil if empty.
     def first
-      self[0]
+      value_by_index(0)
     end
     # Returns the last value of the collection, or nil if empty.
     def last
-      self[-1]
+      value_by_index(-1)
     end
 
     # Returns the number of values in the collection.
@@ -927,32 +956,14 @@ module Udat
       return self
     end
 
-    # Returns the encoded form of the content as a string.
-    # This method is used by Udat::Node#encode_part and will be declared
-    # protected in future.
-    def encoded_content
-      synchronize do
-        return (
-          @entries.empty? ? "~" :
-          @entries.collect do |key, value|
-            if key
-              "<#{key.encode_part}>[#{value.encode_part}]"
-            else
-              "[#{value.encode_part}]"
-            end
-          end.join
-        )
-      end
-    end
-
     # Same as Udat::Collection#ordered?.
     def ordered
       synchronize do
         return @ordered
       end
     end
-    # Returns false, if the order of the contents of this collection is to
-    # be ignored for comparisons.
+    # Returns true, if the order of the contents of this collection is
+    # significant for comparisons.
     def ordered?
       self.ordered
     end
@@ -983,6 +994,23 @@ module Udat
       return self
     end
 
+    # Returns the encoded form of the content as a string.
+    # This method is used by Udat::Node#encode_without_brackets.
+    def encode_content
+      synchronize do
+        return (
+          @entries.empty? ? "~" :
+          @entries.collect do |key, value|
+            if key
+              "<#{key.encode_without_brackets}>" <<
+              "[#{value.encode_without_brackets}]"
+            else
+              "[#{value.encode_without_brackets}]"
+            end
+          end.join
+        )
+      end
+    end
     # Same as Udat::Node#inspect, but in case of unordered collections it
     # prepends "udat-unordered" instead of just "udat".
     def inspect
@@ -1012,6 +1040,8 @@ module Udat
   # Class of Udat::Node's holding scalar values (stored as a String).
   class Scalar < Node
 
+    public
+
     public_class_method :new
     # Creates a new Udat::Scalar with a given tag (which may be nil) and a
     # given content, which is transformed to a string (via Object#to_s).
@@ -1021,6 +1051,11 @@ module Udat
       self.content = content
     end
 
+    # Returns true.
+    def scalar?
+      true
+    end
+
     # Content of the scalar (a String).
     attr_reader :content
     # Sets the content. The content is casted to a string.
@@ -1036,6 +1071,10 @@ module Udat
     def to_i
       content.to_i
     end
+    # Returns the content casted to a Float.
+    def to_f
+      content.to_f
+    end
 
     # Returns true, if the (String representation of the) content is empty.
     def empty?
@@ -1043,18 +1082,189 @@ module Udat
     end
 
     # Returns the encoded form of the content as a string. In this case
-    # this is simply an escaped version of the String. This method will be
-    # declared protected in future versions.
-    def encoded_content
+    # this is simply an escaped version of the String.
+    def encode_content
       Udat::escape_string(self.to_s)
     end
 
   end
 
+  # Waits in an endless loop for incoming TCP connections on the given port
+  # and runs a new thread for each incoming connection, reads and parses
+  # UDAT objects, passes them each to a given block (by calling yield) and
+  # writes the result of the called block in form of an encoded UDAT object
+  # back to the TCP socket. A timeout can be specified, to determine how
+  # long it may take to read an object.
+  def run_rpc_server(port, timeout = 180)
+    server = nil
+    begin
+      server = TCPServer.new(port)
+      while true
+        Thread.new(server.accept) do |socket|
+          begin
+            while true
+              query = nil
+              begin
+                Timeout.timeout(timeout) do
+                  query = socket.read_udat
+                end
+              rescue Timeout::Error
+              end
+              break unless query
+              socket.write_udat(yield(query))
+            end
+          ensure
+            socket.close
+          end
+        end
+      end
+    ensure
+      server.close if server
+    end
+  end
+
+  # Module containing some demonstration functions.
+  module Demo
+
+    module_function
+
+    # A string containing an UDAT example document.
+    ExampleDocument = <<-'END_OF_EXAMPLE'
+    [sample config v1.0|
+
+      <network> [
+        <max connections> [256]
+        <reverse lookups> [yes]
+      ]
+
+      <locale> [
+        <language> [de]    german language
+        <timezone> [CET]   and CET timezone
+        Comments can appear almost anywhere.
+      ]
+
+      <access control> [
+        <allowed> [
+          [user|martin]
+          [user|max]
+          [group|admins]
+          [ip4network|
+            <address> [192.168.0.0]
+            <netmask> [255.255.255.0]
+          ]
+        ]
+        <blocked> [~]   The tilde symbol denotes an empty collection.
+      ]
+
+      <misc> [
+        <symbol for homedir> [\~]   Not an empty collection but the scalar
+                                    value "~".
+      ]
+
+      <address mappings> [
+
+        <email|
+          <user>   [jan.behrens]
+          <domain> [flexiguided.de]
+        >
+        [mbox|jan]
+
+        <email|
+          <user>   [glob|*]
+          <domain> [flexiguided.de]
+        >
+        [mbox|catchall]
+
+      ]
+
+      <logging> [
+        <verbosity>   [high]
+    \## <verbosity>   [debug] ##   Uncomment this for debug output.
+        <destination> [file|/var/log/sample.log]
+      ]
+
+    ]
+    END_OF_EXAMPLE
+
+    # Runs a demo server, not for production use.
+    def run_rpc_demo_server(port, timeout = 180)
+      Udat::run_rpc_server(port, timeout) do |query|
+        begin
+          case query.tag
+          when "echo request"
+            query.tag = "echo reply"
+            next query
+          when "calculation request"
+            begin
+              query.require_collection
+              operands = query.fetch_collection("operands")
+              operand1 = operands.fetch_scalar(0).to_f
+              operand2 = operands.fetch_scalar(1).to_f
+            end
+            operand1 = operands[0].to_f
+            operand2 = operands[1].to_f
+            operator = query.fetch_scalar("operator")
+            case operator
+            when "+".to_udat
+              next (operand1 + operand2).to_udat("calculation result")
+            when "-".to_udat
+              next (operand1 - operand2).to_udat("calculation result")
+            when "*".to_udat
+              next (operand1 * operand2).to_udat("calculation result")
+            when "/".to_udat
+              next (operand1.quo operand2).to_udat("calculation result")
+            else
+              next([["message", "Unknown operator."]].to_udat("error")
+              )
+            end
+          when "time request"
+            next Time.now.strftime("%Y-%m-%d %H:%M:%S %Z").to_udat('time')
+          else
+            raise Udat::UdatTagMismatch, "Unknown UDAT tag."
+          end
+        rescue Udat::UdatPropertyMismatch, UdatIndexError
+          next [["message", $!.message]].to_udat("error")
+        end
+      end
+    end
+
+    # Method to test the RPC mechanism, not for production use.
+    def rpc_selftest(port = 10330)
+      a = rand(100) + 1
+      b = rand(100) + 1
+      demo_server_thread = nil
+      begin
+        demo_server_thread = Thread.new do
+          Udat::Demo::run_rpc_demo_server(port)
+        end
+        sleep 0.5
+        udat_result = nil
+        Timeout.timeout(15) do
+          udat_result = {'operands' => [a, b], 'operator' => '+'}.
+                        to_udat("calculation request").
+                        rpc('localhost', port)
+        end
+        if udat_result.tag == "error"
+          raise "RPC call returned with an error: " <<
+            udat_result.fetch_scalar("message").to_s
+        end
+        result = udat_result.require_scalar("calculation result").to_f
+      ensure
+        demo_server_thread.kill
+      end
+      unless result == a + b
+        raise "Calculation error during UDAT RPC selftest."
+      end
+      return "Test done: #{a} + #{b} == #{result}"
+    end
+
+  end
+
 end
 
 
 class Object
+  public
   # Casts the Object to an Udat::Scalar object, optionally with a given
   # tag. Unless overwritten by sub classes, only the string representation
   # (as returned by Object#to_s) will be stored as content in the
@@ -1065,6 +1275,7 @@ class Object
 end
 
 class Array
+  public
   # Casts the Array to an Udat::Collection object, optionally with a given
   # tag. The Udat::Collection object is marked to be ordered. Each element
   # of the array may be an Array of size 2, in which case the 2 entries are
@@ -1076,6 +1287,7 @@ class Array
 end
 
 class Hash
+  public
   # Casts the Hash to an Udat::Collection object, optionally with a given
   # tag. The Udat::Collection object is marked to be unordered.
   def to_udat(tag = nil)
@@ -1084,18 +1296,19 @@ class Hash
 end
 
 class String
-  # Deprecated. Calls Udat::Node.parse_part(self).
-  # Use String#parse_udat_document instead.
+  public
+  # Calls Udat::Node.parse(self).
   def parse_udat
-    Udat::Node.parse_part(self)
+    Udat::Node.parse(self)
   end
-  # Calls Udat::Node.parse_document(self).
+  # Alias for Udat::Node.parse, will be removed in future versions.
   def parse_udat_document
     Udat::Node.parse_document(self)
   end
 end
 
 class IO
+  public
   # Calls Udat::Node.read_from_stream(self).
   def read_udat
     Udat::Node.read_from_stream(self)
@@ -1108,11 +1321,3 @@ class IO
   end
 end
 
-# Deprecated constant for backwards compatibility.
-UdatCollection = Udat::Collection
-
-# Deprecated constant for backwards compatibility.
-UdatScalar = Udat::Scalar
-
-
-

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: udat
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
-date: 2007-05-28 00:00:00 +00:00
+  version: 1.4.0
+date: 2007-05-30 00:00:00 +00:00
 summary: Parser and generator for UDAT documents, a generic data format similar to XML or YAML.
 require_paths: 
 - lib/