ruote 0.9.18 → 0.9.19

data/lib/openwfe/utils.rb

@@ -2,31 +2,31 @@
 #--
 # Copyright (c) 2005-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
-# 
-# Redistribution and use in source and binary forms, with or without 
+#
+# Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are met:
-# 
+#
 # . Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.  
-# 
-# . Redistributions in binary form must reproduce the above copyright notice, 
-#   this list of conditions and the following disclaimer in the documentation 
+#   list of conditions and the following disclaimer.
+#
+# . Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
 #   and/or other materials provided with the distribution.
-# 
+#
 # . Neither the name of the "OpenWFE" nor the names of its contributors may be
 #   used to endorse or promote products derived from this software without
 #   specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
@@ -37,518 +37,491 @@
 # john.mettraux@openwfe.org
 #
 
-require 'rexml/document'
+require 'openwfe/rexml'
 require 'tmpdir'
 require 'open-uri'
 
 
 module OpenWFE
 
-    #
-    # see 
-    # http://wiki.rubygarden.org/Ruby/page/show/Make_A_Deep_Copy_Of_An_Object
-    #
-    # It's not perfect (that's why fulldup() uses it only in certain cases).
-    #
-    # For example :
-    #
-    #     TypeError: singleton can't be dumped
-    #         ./lib/openwfe/utils.rb:74:in `dump'
-    #         ./lib/openwfe/utils.rb:74:in `deep_clone'
-    #
-    def OpenWFE.deep_clone (object)
+  #--
+  # see
+  # http://wiki.rubygarden.org/Ruby/page/show/Make_A_Deep_Copy_Of_An_Object
+  #
+  # It's not perfect (that's why fulldup() uses it only in certain cases).
+  #
+  # For example :
+  #
+  #   TypeError: singleton can't be dumped
+  #     ./lib/openwfe/utils.rb:74:in `dump'
+  #     ./lib/openwfe/utils.rb:74:in `deep_clone'
+  #
+  #def OpenWFE.deep_clone (object)
+  #  Marshal.load(Marshal.dump(object))
+  #end
+  #++
+
+  #--
+  # classes that shouldn't get duplicated.
+  #
+  #IMMUTABLES = [ Symbol, Fixnum, TrueClass, FalseClass, Float ]
+  #++
+
+  #
+  # an automatic dup implementation attempt
+  #
+  def OpenWFE.fulldup (object)
+
+    return object.fulldup if object.respond_to?("fulldup")
+      # trusting client objects providing a fulldup() implementation
+      # Tomaso Tosolini 2007.12.11
+
+    begin
+      return Marshal.load(Marshal.dump(object))
+        # as soon as possible try to use that Marshal technique
+        # it's quite fast
+    rescue TypeError => te
+    end
 
-        Marshal::load(Marshal.dump(object))
+    if object.kind_of?(REXML::Element)
+      d = REXML::Document.new object.to_s
+      return d if object.kind_of?(REXML::Document)
+      return d.root
     end
+      # avoiding "TypeError: singleton can't be dumped"
+
+    o = object.class.new
 
     #
-    # an automatic dup implementation attempt
+    # some kind of collection ?
+    if object.kind_of?(Array)
+      object.each { |i| o << fulldup(i) }
+    elsif object.kind_of?(Hash)
+      object.each { |k, v| o[fulldup(k)] = fulldup(v) }
+    end
     #
-    def OpenWFE.fulldup (object)
-
-        return nil if object == nil
-    
-        return object.fulldup if object.respond_to?("fulldup")
-            # trusting client objects providing a fulldup() implementation
-            # Tomaso Tosolini 2007.12.11
-
-        return object if object.kind_of?(Float)
-        return object if object.kind_of?(Fixnum)
-        return object if object.kind_of?(TrueClass)
-        return object if object.kind_of?(FalseClass)
-        return object if object.kind_of?(Symbol)
-
-        return object.dup if object.kind_of?(String)
-
-        #return deep_clone(object) if object.kind_of?(REXML::Document)
-        
-        #return REXML::Document.new(object.to_s) \
-        #    if object.kind_of? REXML::Document
-
-        if object.kind_of?(REXML::Element)
-            d = REXML::Document.new object.to_s
-            return d if object.kind_of?(REXML::Document)
-            return d.root
-        end
-
-        return deep_clone(object) if object.is_a?(Date)
-
-        return Time.at(object) if object.is_a?(Time)
-            # patch by Maarten Oelering 
+    # duplicate the attributes of the object
+    object.instance_variables.each do |v|
+      #puts "v is #{v}"
+      value = object.instance_variable_get(v)
+      #puts "value is '#{value}'"
+      value = fulldup(value)
+      begin
+        o.instance_variable_set(v, value)
+      rescue
+        # ignore, must be readonly
+      end
+    end
 
-        return Rational(object.denominator, object.numerator) \
-            if object.kind_of?(Rational)
+    o
+  end
 
-        o = nil
+  def OpenWFE.to_underscore (string)
 
-        begin
-            o = object.class.new
-        rescue ArgumentError => ae
-            return deep_clone(object)
-        end
+    string.gsub("-", "_")
+  end
 
-        #
-        # some kind of collection ?
-
-        if object.kind_of?(Array)
-            object.each do |i|
-                o << fulldup(i)
-            end
-        elsif object.kind_of?(Hash)
-            object.each do |k, v|
-                o[fulldup(k)] = fulldup(v)
-            end
-        end
+  def OpenWFE.to_dash (string)
 
-        #
-        # duplicate the attributes of the object
+    string.gsub("_", "-")
+  end
 
-        object.instance_variables.each do |v|
+  def OpenWFE.symbol_to_name (symbol)
 
-            #puts "v is #{v}"
+    to_dash(symbol.to_s)
+  end
 
-            value = object.instance_variable_get(v)
+  def OpenWFE.name_to_symbol (name)
 
-            #puts "value is '#{value}'"
+    return name if name.is_a?(Symbol)
+    to_underscore(name).intern
+  end
 
-            value = fulldup(value)
+  #
+  # Turns all the spaces in string into underscores.
+  # Returns the new String.
+  #
+  def OpenWFE.stu (s)
 
-            begin
-                o.instance_variable_set(v, value)
-            rescue
-                # ignore, must be readonly
-            end
-        end
+    s.gsub("\s", "_")
+  end
 
-        o
-    end
+  #
+  # Returns an URI if the string is one, else returns nil.
+  # No exception is thrown by this method.
+  #
+  def OpenWFE.parse_uri (string)
 
-    def OpenWFE.to_underscore (string)
+    return nil if string.split("\n").size > 1
 
-        string.gsub("-", "_")
+    begin
+      return URI::parse(string)
+    rescue Exception => e
     end
 
-    def OpenWFE.to_dash (string)
-
-        string.gsub("_", "-")
+    nil
+  end
+
+  #
+  # Returns a URI instance if the given ref is a http, https, file or ftp
+  # URI. Returns nil else.
+  # The sister method parse_uri() is OK with things like mailto:, gopher:, ...
+  #
+  def OpenWFE.parse_known_uri (ref)
+
+    uri = OpenWFE::parse_uri(ref.to_s)
+
+    return nil unless uri
+
+    return uri if uri.scheme == "file"
+    return uri if uri.scheme == "http"
+    return uri if uri.scheme == "https"
+    return uri if uri.scheme == "ftp"
+      # what else ...
+
+    nil
+  end
+
+  #
+  # Returns true if the given string starts with the 'start' string.
+  #
+  def OpenWFE.starts_with (string, start)
+    #
+    # my favourite way of doing that would be by adding this
+    # method to the String class, but that could be intrusive
+    # (as OpenWFE is meant at first as an embeddable workflow engine).
+    #
+    return false unless string
+    return false if string.length < start.length
+    string[0, start.length] == start
+  end
+
+  #
+  # Returns true if the given string ends with the '_end' string.
+  #
+  def OpenWFE.ends_with (string, _end)
+    return false unless string
+    return false if string.length < _end.length
+    string[-_end.length..-1] == _end
+  end
+
+  #
+  # Attempts at displaying a nice stack trace
+  #
+  def OpenWFE.exception_to_s (exception)
+    s = "exception : "
+    s << "#{exception}\n"
+    s << exception.backtrace.join("\n")
+    s
+  end
+
+  #
+  # Pretty printing a caller() array
+  #
+  def OpenWFE.caller_to_s (start_index, max_lines=nil)
+    s = ""
+    caller(start_index + 1).each_with_index do |line, index|
+      break if max_lines and index >= max_lines
+      s << "   #{line}\n"
     end
-
-    def OpenWFE.symbol_to_name (symbol)
-
-        to_dash(symbol.to_s)
+    s
+  end
+
+  #
+  # Sets the name of the current thread (the attribute :name if it is
+  # a ruby thread, the java thread name if we're in JRuby)
+  #
+  def OpenWFE.set_current_thread_name (name)
+
+     if defined?(JRUBY_VERSION)
+       require 'java'
+       java.lang.Thread.current_thread.name = "#{name} (Ruby Thread)"
+     end
+
+     Thread.current[:name] = name
+  end
+
+  #
+  # Some code for writing thinks like :
+  #
+  #   if async
+  #     OpenWFE::call_in_thread "launch()", self do
+  #       raw_expression.apply(wi)
+  #     end
+  #   else
+  #     raw_expression.apply(wi)
+  #   end
+  #
+  # Returns the new thread instance.
+  #
+  def OpenWFE.call_in_thread (caller_name, caller_object=nil, &block)
+
+    return unless block
+
+    Thread.new do
+
+      #Thread.current[:name] = caller_name
+      set_current_thread_name caller_name
+
+      begin
+        #$SAFE = safe_level
+          #
+          # (note)
+          # doesn't work : the block inherits the safety level
+          # of its surroundings, it's a closure, ne ?
+
+        block.call
+
+      rescue Exception => e
+        msg = "#{caller_name} caught an exception\n" + exception_to_s(e)
+        if caller_object and caller_object.respond_to? :lwarn
+          caller_object.lwarn { msg }
+        else
+          puts msg
+        end
+      end
     end
-
-    def OpenWFE.name_to_symbol (name)
-
-        return name if name.is_a?(Symbol)
-        to_underscore(name).intern
+    # returns the thread
+  end
+
+  #
+  # A small Timer class for debug purposes.
+  #
+  #   t = Time.new
+  #
+  #   # ... do something
+  #
+  #   puts "that something took #{t.duration} ms"
+  #
+  class Timer
+
+    attr_reader :start
+
+    def initialize
+      @start = Time.now.to_f
     end
 
     #
-    # Turns all the spaces in string into underscores.
-    # Returns the new String.
+    # Returns the number of milliseconds since this Timer was
+    # instantiated.
     #
-    def OpenWFE.stu (s)
-
-        s.gsub("\s", "_")
+    def duration
+      (Time.now.to_f - @start) * 1000
     end
-
-    #
-    # Returns an URI if the string is one, else returns nil.
-    # No exception is thrown by this method.
-    #
-    def OpenWFE.parse_uri (string)
-
-        return nil if string.split("\n").size > 1
-
-        begin
-            return URI::parse(string)
-        rescue Exception => e
-        end
-
-        nil
+  end
+
+
+  #
+  # (2008.03.12 Deprecated, kept here for a while
+  # for backward compatibility)
+  #
+  # A simple Hash that accepts String or Symbol as lookup keys []
+  #
+  class SymbolHash < Hash
+    def [] (key)
+      super(key.to_s)
     end
+  end
 
-    #
-    # Returns a URI instance if the given ref is a http, https, file or ftp
-    # URI. Returns nil else.
-    # The sister method parse_uri() is OK with things like mailto:, gopher:, ...
-    #
-    def OpenWFE.parse_known_uri (ref)
+  #
+  # Returns a version of s that is usable as or within a filename
+  # (removes for examples things like '/' or '\'...)
+  #
+  def OpenWFE.ensure_for_filename (s)
 
-        uri = OpenWFE::parse_uri(ref.to_s)
+    s = s.gsub(" ", "_")
+    s = s.gsub("/", "_")
+    s = s.gsub(":", "_")
+    s = s.gsub(";", "_")
+    s = s.gsub("\*", "_")
+    s = s.gsub("\\", "_")
+    s = s.gsub("\+", "_")
+    s = s.gsub("\?", "_")
 
-        return nil unless uri
+    s
+  end
 
-        return uri if uri.scheme == "file"
-        return uri if uri.scheme == "http"
-        return uri if uri.scheme == "https"
-        return uri if uri.scheme == "ftp"
-            # what else ...
+  #
+  # "my//path" -> "my/path"
+  #
+  def OpenWFE.clean_path (s)
+    s.gsub(/\/+/, "/")
+  end
 
-        nil
-    end
+  #
+  # This method is used within the InFlowWorkItem and the CsvTable classes.
+  #
+  def OpenWFE.lookup_attribute (container, key)
 
-    #
-    # Returns true if the given string starts with the 'start' string.
-    #
-    def OpenWFE.starts_with (string, start)
-        #
-        # my favourite way of doing that would be by adding this 
-        # method to the String class, but that could be intrusive
-        # (as OpenWFE is meant at first as an embeddable workflow engine).
-        #
-        return false unless string
-        return false if string.length < start.length
-        string[0, start.length] == start
-    end
+    key, rest = pop_key(key)
 
-    #
-    # Returns true if the given string ends with the '_end' string.
-    #
-    def OpenWFE.ends_with (string, _end)
-        return false unless string
-        return false if string.length < _end.length
-        string[-_end.length..-1] == _end
-    end
+    #value = nil
+    #begin
+    #  value = container[key]
+    #rescue Exception => e
+    #end
 
-    #
-    # Attempts at displaying a nice stack trace
-    #
-    def OpenWFE.exception_to_s (exception)
-        s = "exception : "
-        s << "#{exception}\n"
-        s << exception.backtrace.join("\n")
-        s
-    end
+    value = flex_lookup(container, key)
 
-    #
-    # Pretty printing a caller() array
-    #
-    def OpenWFE.caller_to_s (start_index, max_lines=nil)
-        s = ""
-        caller(start_index + 1).each_with_index do |line, index|
-            break if max_lines and index >= max_lines
-            s << "   #{line}\n"
-        end
-        s
-    end
-
-    #
-    # Sets the name of the current thread (the attribute :name if it is
-    # a ruby thread, the java thread name if we're in JRuby)
-    #
-    def OpenWFE.set_current_thread_name (name)
-
-       if defined?(JRUBY_VERSION)
-           require 'java'
-           java.lang.Thread.current_thread.name = "#{name} (Ruby Thread)"
-       end
+    return value unless rest
 
-       Thread.current[:name] = name
-    end
-
-    #
-    # Some code for writing thinks like :
-    #
-    #     if async
-    #         OpenWFE::call_in_thread "launch()", self do
-    #             raw_expression.apply(wi)
-    #         end
-    #     else
-    #         raw_expression.apply(wi)
-    #     end
-    #
-    # Returns the new thread instance.
-    #
-    def OpenWFE.call_in_thread (caller_name, caller_object=nil, &block)
+    return nil unless value
 
-        return unless block
+    lookup_attribute(value, rest)
+  end
 
-        Thread.new do
+  #
+  # This method is used within the InFlowWorkItem and the CsvTable classes.
+  #
+  def OpenWFE.has_attribute? (container, key)
 
-            #Thread.current[:name] = caller_name
-            set_current_thread_name caller_name
+    key, last_key = pop_last_key(key)
 
-            begin
-                #$SAFE = safe_level
-                    #
-                    # (note)
-                    # doesn't work : the block inherits the safety level
-                    # of its surroundings, it's a closure, ne ?
+    container = lookup_attribute(container, key) if key
 
-                block.call
+    if container.respond_to?(:has_key?)
 
-            rescue Exception => e
-                msg = "#{caller_name} caught an exception\n" + exception_to_s(e)
-                if caller_object and caller_object.respond_to? :lwarn
-                    caller_object.lwarn { msg }
-                else
-                    puts msg
-                end
-            end
-        end
-        # returns the thread
-    end
+      (container.has_key?(last_key) or container.has_key?(last_key.to_s))
 
-    #
-    # A small Timer class for debug purposes.
-    #
-    #     t = Time.new
-    #
-    #     # ... do something
-    #
-    #     puts "that something took #{t.duration} ms"
-    #
-    class Timer
+    elsif container.is_a?(Array) and last_key.is_a?(Fixnum)
 
-        attr_reader :start
+      (last_key < container.length)
 
-        def initialize
-            @start = Time.now.to_f
-        end
+    else
 
-        #
-        # Returns the number of milliseconds since this Timer was
-        # instantiated.
-        #
-        def duration
-            (Time.now.to_f - @start) * 1000
-        end
+      false
     end
-
-
-    #
-    # (2008.03.12 Deprecated, kept here for a while
-    # for backward compatibility)
-    #
-    # A simple Hash that accepts String or Symbol as lookup keys []
-    #
-    class SymbolHash < Hash
-        def [] (key)
-            super(key.to_s)
+  end
+
+  #
+  # Returns a list of lines matching the pattern in the given file.
+  #
+  # This is also possible :
+  #
+  #   OpenWFE::grep "^..) ", "path/to/file.txt" do |line|
+  #     puts " - '#{line.downcase}'"
+  #   end
+  #
+  # TODO : find a ruby library and use it instead of that code
+  #
+  def OpenWFE.grep (pattern, filepath, &block)
+
+    result = []
+    r = Regexp.new pattern
+
+    File.open filepath do |file|
+      file.readlines.each do |l|
+        if r.match l
+          if block
+            block.call l
+          else
+            result << l
+          end
         end
+      end
     end
+    result unless block
+  end
 
-    #
-    # Returns a version of s that is usable as or within a filename
-    # (removes for examples things like '/' or '\'...)
-    #
-    def OpenWFE.ensure_for_filename (s)
-
-        s = s.gsub(" ", "_")
-        s = s.gsub("/", "_")
-        s = s.gsub(":", "_")
-        s = s.gsub(";", "_")
-        s = s.gsub("\*", "_")
-        s = s.gsub("\\", "_")
-        s = s.gsub("\+", "_")
-        s = s.gsub("\?", "_")
-
-        s
-    end
-
-    #
-    # "my//path" -> "my/path"
-    #
-    def OpenWFE.clean_path (s)
-        s.gsub(/\/+/, "/")
-    end
-
-    #
-    # This method is used within the InFlowWorkItem and the CsvTable classes.
-    #
-    def OpenWFE.lookup_attribute (container, key)
+  #
+  # This method is used within the InFlowWorkItem and the CsvTable classes.
+  #
+  def OpenWFE.set_attribute (container, key, value)
 
-        key, rest = pop_key(key)
+    i = key.rindex(".")
 
-        #value = nil
-        #begin
-        #    value = container[key]
-        #rescue Exception => e
-        #end
+    if not i
+      container[key] = value
+      return
+    end
 
-        value = flex_lookup(container, key)
+    container = lookup_attribute(container, key[0..i-1])
+    container[key[i+1..-1]] = value
+  end
 
-        return value unless rest
+  #
+  # This method is used within the InFlowWorkItem and the CsvTable classes.
+  #
+  def OpenWFE.unset_attribute (container, key)
 
-        return nil unless value
+    i = key.rindex(".")
 
-        lookup_attribute(value, rest)
+    if not i
+      container.delete key
+      return
     end
 
-    #
-    # This method is used within the InFlowWorkItem and the CsvTable classes.
-    #
-    def OpenWFE.has_attribute? (container, key)
+    container = lookup_attribute container, key[0..i-1]
 
-        key, last_key = pop_last_key(key)
+    if container.is_a?(Array)
 
-        container = lookup_attribute(container, key) if key
+      container.delete_at key[i+1..-1].to_i
+    else
 
-        if container.respond_to?(:has_key?)
+      container.delete key[i+1..-1]
+    end
+  end
 
-            (container.has_key?(last_key) or container.has_key?(last_key.to_s))
+  #
+  # Returns true if this host is currently online (has access to the web /
+  # internet).
+  #
+  def online?
 
-        elsif container.is_a?(Array) and last_key.is_a?(Fixnum)
+    require 'open-uri'
 
-            (last_key < container.length)
+    begin
+      open("http://www.openwfe.org")
+      true
+    rescue SocketError => se
+      false
+    end
+  end
 
-        else
+  protected
 
-            false
-        end
+    def OpenWFE.pop_key (key)
+      i = key.index(".")
+      return narrow(key), nil unless i
+      [ narrow(key[0..i-1]), key[i+1..-1] ]
     end
 
-    #
-    # Returns a list of lines matching the pattern in the given file.
-    #
-    # This is also possible :
-    #
-    #     OpenWFE::grep "^..) ", "path/to/file.txt" do |line|
-    #         puts " - '#{line.downcase}'"
-    #     end
-    #
-    # TODO : find a ruby library and use it instead of that code
-    #
-    def OpenWFE.grep (pattern, filepath, &block)
-
-        result = []
-        r = Regexp.new pattern
-
-        File.open filepath do |file|
-            file.readlines.each do |l|
-                if r.match l
-                    if block
-                        block.call l
-                    else
-                        result << l
-                    end
-                end
-            end
-        end
-        result unless block
+    def OpenWFE.pop_last_key (key)
+      i = key.rindex(".")
+      return nil, narrow(key) unless i
+      [ key[0..i-1], narrow(key[i+1..-1]) ]
     end
 
-    #
-    # This method is used within the InFlowWorkItem and the CsvTable classes.
-    #
-    def OpenWFE.set_attribute (container, key, value)
-
-        i = key.rindex(".")
-
-        if not i
-            container[key] = value
-            return
-        end
-
-        container = lookup_attribute(container, key[0..i-1])
-        container[key[i+1..-1]] = value
+    def OpenWFE.narrow (key)
+      return 0 if key == "0"
+      i = key.to_i
+      return i if i != 0
+      key
     end
 
     #
-    # This method is used within the InFlowWorkItem and the CsvTable classes.
+    # looks up in a container (something that has a [] method)  with a key,
+    # if nothing has been found and the key is a number, turns the
+    # the number into a String a does a last lookup.
     #
-    def OpenWFE.unset_attribute (container, key)
+    def OpenWFE.flex_lookup (container, key)
 
-        i = key.rindex(".")
-
-        if not i
-            container.delete key
-            return
-        end
+      value = nil
 
-        container = lookup_attribute container, key[0..i-1]
-
-        if container.is_a?(Array)
-
-            container.delete_at key[i+1..-1].to_i
-        else
-
-            container.delete key[i+1..-1]
-        end
-    end
-
-    #
-    # Returns true if this host is currently online (has access to the web / 
-    # internet).
-    #
-    def online?
-
-        require 'open-uri'
+      begin
+        value = container[key]
+      rescue Exception => e
+      end
 
+      if value == nil and key.kind_of?(Fixnum)
         begin
-            open("http://www.openwfe.org")
-            true
-        rescue SocketError => se
-            false
-        end
-    end
-
-    protected
-
-        def OpenWFE.pop_key (key)
-            i = key.index(".")
-            return narrow(key), nil unless i
-            [ narrow(key[0..i-1]), key[i+1..-1] ]
-        end
-
-        def OpenWFE.pop_last_key (key)
-            i = key.rindex(".")
-            return nil, narrow(key) unless i
-            [ key[0..i-1], narrow(key[i+1..-1]) ]
-        end
-
-        def OpenWFE.narrow (key)
-            return 0 if key == "0"
-            i = key.to_i
-            return i if i != 0
-            key
+          value = container[key.to_s]
+        rescue Exception => e
         end
+      end
 
-        #
-        # looks up in a container (something that has a [] method)  with a key,
-        # if nothing has been found and the key is a number, turns the
-        # the number into a String a does a last lookup.
-        #
-        def OpenWFE.flex_lookup (container, key)
-
-            value = nil
-
-            begin
-                value = container[key]
-            rescue Exception => e
-            end
-
-            if value == nil and key.kind_of?(Fixnum)
-                begin
-                    value = container[key.to_s]
-                rescue Exception => e
-                end
-            end
+      value
+    end
 
-            value
-        end
-    
 end