voruby 1.0.1

data/lib/voruby/plastic/applications.rb

@@ -0,0 +1,174 @@
+require 'voruby/plastic/loader'
+
+module VORuby
+  module Plastic
+    module Application
+    
+      class Base
+        attr_reader :name, :description, :icon_url, :ivorn, :plastic_version, :config, :hub_id, :app_id
+      
+        def initialize(name=nil, description=nil, icon_url=nil, ivorn=nil, plastic_version=0.5)
+          initialize_config()
+        
+          @hub = ::XMLRPC::Client.new_from_uri(@config['plastic.xmlrpc.url'])
+        
+          @name = name
+          @hub_id = URI.parse(call('plastic.hub.getHubId'))
+        
+          @description = description
+          @icon_url = icon_url
+          @ivorn = ivorn
+          @plastic_version = plastic_version
+        end
+      
+        def initialize_config
+          begin
+            @config = Misc::PropertyFile::SimpleReader.new("#{ENV['HOME']}/.plastic")
+          rescue Errno::ENOENT => e
+            puts "Unable to find .plastic file.  Is a PLASTIC hub running? #{e}"
+          end
+        
+          raise 'Unable to determine value of XMLRPC URL' if !@config['plastic.xmlrpc.url']
+          @config['plastic.xmlrpc.url'].gsub!(/\\:/, ':')
+        end
+      
+        def register
+          @app_id = call('plastic.hub.registerNoCallBack', self.name)
+        end
+      
+        def get_registered_ids
+          call('plastic.hub.getRegisteredIds').collect{ |uri| URI.parse(uri) }
+        end
+      
+        def get_understood_messages(app_id)
+          call('plastic.hub.getUnderstoodMessages', app_id.to_s).collect{ |uri| URI.parse(uri) }
+        end
+      
+        def get_message_registered_ids(msg)
+          call('plastic.hub.getMessageRegisteredIds', msg.to_s).collect{ |uri| URI.parse(uri) }
+        end
+      
+        def get_name(app_id)
+          name = call('plastic.hub.getName', app_id.to_s)
+          (name != '')? name: nil
+        end
+      
+        def unregister
+          call('plastic.hub.unregister', self.app_id.to_s) if self.app_id
+        end
+      
+        def request(msg, *args)
+          responses = {}
+          call('plastic.hub.request', self.app_id.to_s, msg.to_s, args).each do |app_id, response|
+            responses[URI.parse(app_id)] = response
+          end
+        
+          responses
+        end
+      
+        def request_to_subset(msg, args, *recipients)
+          responses = {}
+          call('plastic.hub.requestToSubset', self.app_id.to_s, msg.to_s, args,
+                recipients.collect{ |id| id.to_s }).each do |app_id, response|
+            responses[URI.parse(app_id)] = response   
+          end
+        
+          responses
+        end
+      
+        def request_asynch(msg, *args)
+          call_async('plastic.hub.requestAsynch', self.app_id.to_s, msg.to_s, args)
+        end
+      
+        def request_to_subset_asynch(msg, args, recipients)
+          call_async('plastic.hub.requestToSubsetAsynch', self.app_id.to_s, msg.to_s, args, recipients.collect{ |id| id.to_s })
+        end
+      
+        def call(method_name, *args)
+          begin
+            @hub.call(method_name, *args)
+          rescue ::XMLRPC::FaultException => e
+            puts "XMLRPC Error while calling #{method_name} (#{e.faultCode}): #{e.faultString}"
+          end
+        end
+      
+        def call_async(method_name, *args)
+          begin
+            @hub.call_async(method_name, *args)
+          rescue ::XMLRPC::FaultException => e
+            puts "XMLRPC Error while calling #{method_name} (#{e.faultCode}): #{e.faultString}"
+          end
+        end
+    
+        private :initialize_config, :call, :call_async
+      end
+    
+      class Full < Base
+        attr_reader :supported_messages, :call_back_url, :xmlrpc_server, :http_server
+    
+        def initialize(supported_messages={}, port=8080, mount_point='/RPC2',
+                       name=nil, description=nil, icon_url=nil, ivorn=nil, plastic_version=0.5)
+          super(name, description, icon_url, ivorn, plastic_version)
+        
+          initialize_core_messages()
+          @supported_messages = @core_messages.merge(supported_messages)
+        
+          initialize_xmlrpc_server(port, mount_point)
+        end
+      
+        def initialize_core_messages
+          @core_messages = {
+            Messages::TEST_ECHO => Proc.new{ |sender_id, args| args[0] },
+            Messages::INFO_GET_IVORN => Proc.new{ |sender_id, args| self.ivorn.to_s },
+            Messages::INFO_GET_NAME => Proc.new{ |sender_id, args| self.name },
+            Messages::INFO_GET_VERSION => Proc.new{ |sender_id, args| self.plastic_version.to_s },
+            Messages::INFO_GET_ICON_URL => Proc.new{ |sender_id, args| self.icon_url.to_s },
+            Messages::INFO_GET_DESCRIPTION => Proc.new{ |sender_id, args| self.description },
+            Messages::HUB_EVENT_APPLICATION_REGISTERED => Proc.new{ |sender_id, args| '' },
+            Messages::HUB_EVENT_APPLICATION_UNREGISTERED => Proc.new{ |sender_id, args| '' },
+            Messages::HUB_EVENT_HUB_STOPPING => Proc.new{ |sender_id, args| '' }
+          }
+        end
+      
+        def initialize_xmlrpc_server(port=8080, mount_point='/RPC2')
+           @xmlrpc_server = ::XMLRPC::WEBrickServlet.new 
+           @xmlrpc_server.set_default_handler do |action, *args|
+             sending_app_id = URI.parse(args[0])
+             msg = URI.parse(args[1])
+             msg_args = args[2..-1]
+
+             return false if !self.supported_messages.has_key?(msg) or action != 'perform'
+             self.supported_messages[msg].call(sending_app_id, msg_args)
+           end
+
+           @http_server = ::WEBrick::HTTPServer.new(:Port => port)
+           @http_server.mount(mount_point, @xmlrpc_server)
+           trap('INT'){ @http_server.shutdown }
+
+           @call_back_url = URI::Generic.new('http', nil, @http_server.config[:ServerName], @http_server.config[:Port],
+            nil, mount_point,
+            nil, nil, nil, false)
+          
+           @server_thread = Thread.new { @http_server.start }
+         end
+      
+        def register
+          @app_id = call('plastic.hub.registerXMLRPC', self.name,
+                          self.supported_messages.keys.collect{ |msg| msg.to_s }, self.call_back_url.to_s)
+        end
+      
+        def wait_for_requests
+          @server_thread.join
+        end
+      
+        def shutdown
+          self.unregister
+          self.http_server.shutdown
+        end
+      
+        private :initialize_core_messages, :initialize_xmlrpc_server
+      end
+    
+    end
+  end
+end

data/lib/voruby/plastic/constants.rb

@@ -0,0 +1,30 @@
+module VORuby
+  module Plastic
+    module Messages
+      PREFIX = 'ivo://votech.org'
+  
+      # Core messages
+      TEST_ECHO = URI.parse("#{PREFIX}/test/echo")
+      INFO_GET_IVORN = URI.parse("#{PREFIX}/info/getIVORN")
+      INFO_GET_NAME = URI.parse("#{PREFIX}/info/getName")
+      INFO_GET_VERSION = URI.parse("#{PREFIX}/info/getVersion")
+      INFO_GET_ICON_URL = URI.parse("#{PREFIX}/info/getIconURL")
+      INFO_GET_DESCRIPTION = URI.parse("#{PREFIX}/info/getDescription")
+      HUB_EVENT_APPLICATION_REGISTERED = URI.parse("#{PREFIX}/hub/event/ApplicationRegistered")
+      HUB_EVENT_APPLICATION_UNREGISTERED = URI.parse("#{PREFIX}/hub/event/ApplicationUnregistered")
+      HUB_EVENT_HUB_STOPPING = URI.parse("#{PREFIX}/hub/event/HubStopping")
+      CORE_MESSAGES = [TEST_ECHO,
+                       INFO_GET_IVORN, INFO_GET_NAME, INFO_GET_VERSION, INFO_GET_ICON_URL, INFO_GET_DESCRIPTION,
+                       HUB_EVENT_APPLICATION_REGISTERED, HUB_EVENT_APPLICATION_UNREGISTERED, HUB_EVENT_HUB_STOPPING]
+    
+      # Agreed messages
+      VOTABLE_LOAD = URI.parse("#{PREFIX}/votable/load")
+      VOTABLE_LOAD_FROM_URL = URI.parse("#{PREFIX}/votable/loadFromURL")
+      VOTABLE_SHOW_OBJECTS = URI.parse("#{PREFIX}/votable/showObjects")
+
+      # Image related messages
+      FITS_IMAGE_LOAD_FROM_URL = URI.parse("#{PREFIX}/fits/image/loadFromURL")
+      SKY_POINTS_AT_COORDS = URI.parse("#{PREFIX}/sky/pointsAtCoords")
+    end
+  end
+end

data/lib/voruby/plastic/loader.rb

@@ -0,0 +1,10 @@
+require 'uri'
+require 'xmlrpc/client'
+require 'xmlrpc/server'
+require 'webrick'
+
+#require 'rubygems'
+#require 'propertyfile'
+
+require 'voruby/misc/propertyfile'
+require 'voruby/plastic/constants'

data/lib/voruby/plastic/plastic.rb

@@ -0,0 +1 @@
+require 'voruby/plastic/applications'

data/lib/voruby/resources/conesearch/conesearch.rb

@@ -0,0 +1,9 @@
+require 'voruby/resources/conesearch/conesearch_v1_0'
+
+module VORuby
+  module Resources
+    module ConeSearch
+      #include ConeSearch::V1_0
+    end
+  end
+end

data/lib/voruby/resources/conesearch/conesearch_v0_2.rb

@@ -0,0 +1,55 @@
+require 'voruby/resources/conesearch/loader'
+
+require 'voruby/resources/voresource/voresource_v0_9'
+require 'voruby/resources/vodataservice/vodataservice_v0_4'
+
+include VORuby::Resources::VOResource::V0_9
+include VORuby::Resources::VODataService::V0_4
+
+module VORuby
+  module Resources
+    module ConeSearch
+      module V0_2
+        
+        # Forward declarations
+        class ConeSearchType < CapabilityType; end
+        class ConeSearch < ConeSearchType; end
+        class MaxRecords; end
+        class MaxSR; end
+        class Verbosity; end
+        
+        # The capabilities of a Cone Search implementation.  It includes
+        # the listing of the columns that appear in image query
+        # output VOTable and Cone Search-specific metadata.
+        class ConeSearch; end
+        class ConeSearchType
+          object_node :max_sr, 'MaxSR', :class => MaxSR, :optional => false
+          object_node :max_records, 'MaxRecords', :class => MaxRecords, :optional => false
+          object_node :verbosity, 'Verbosity', :class => Verbosity, :optional => false
+        end
+        
+        # The largest number of records that the service will return.
+        class MaxRecords
+          include XML::Mapping
+          
+          numeric_node :value, '', :optional => false
+        end
+        
+        # The largest search radius, in degrees, that will be accepted by the service without returning an error condition.
+        class MaxSR
+          include XML::Mapping
+          
+          numeric_node :value, '', :optional => false
+        end
+        
+        # True if the service supports the VERB keyword; false, otherwise.
+        class Verbosity
+          include XML::Mapping
+          
+          boolean_node :value, '', 'true', 'false', :optional => false
+        end
+        
+      end
+    end
+  end
+end

data/lib/voruby/resources/conesearch/conesearch_v0_3.rb

@@ -0,0 +1,50 @@
+require 'voruby/resources/conesearch/loader'
+
+require 'voruby/resources/voresource/voresource_v0_10'
+require 'voruby/resources/vodataservice/vodataservice_v0_5'
+
+include VORuby::Resources::VOResource::V0_10
+include VORuby::Resources::VODataService::V0_5
+
+module VORuby
+  module Resources
+    module ConeSearch
+      module V0_3
+        
+        # Forward declarations
+        class ConeSearch < TabularSkyService; end
+        class CSCapRestriction < Capability; end
+        class ConeSearchCapability < CSCapRestriction; end
+        
+        # A standard service that returns catalog entries with a
+        # position falling within a cone on the sky (given by a position 
+        # and a radius).
+        class ConeSearch
+          # a description of how this particular ConeSearch service behaves
+          object_node :capability, 'capability', :class => ConeSearchCapability, :optional => false
+        end
+        
+        # An abstract capability that sets the standardURL to the ConeSearch standard definition.
+        class CSCapRestriction
+          object_node :standard_id, '@standardID', :class => IdentifierURI, :optional => true
+          object_node :standard_url, '@standardURL', :class => AnyURI, :optional => true,
+            :default_value => 'http://www.us-vo.org/metadata/conesearch.html'
+        end
+        
+        # The capabilities of a Cone Search implementation.  It includes
+        # the listing of the columns that appear in image query
+        # output VOTable and Cone Search-specific metadata.
+        class ConeSearchCapability
+          # the largest search radius, in degrees, that will be accepted by the service without returning an error condition
+          numeric_node :max_sr, 'maxSR', :optional => false
+          # the largest number of records that the service will return
+          numeric_node :max_records, 'maxRecords', :optional => false
+          
+          # true if the service supports the VERB keyword; false, otherwise
+          boolean_node :verbosity, 'verbosity', 'true', 'false', :optional => false
+        end
+        
+      end
+    end
+  end
+end

data/lib/voruby/resources/conesearch/conesearch_v1_0.rb

@@ -0,0 +1,72 @@
+require 'voruby/resources/conesearch/loader'
+
+require 'voruby/resources/voresource/voresource_v1_0'
+require 'voruby/resources/vodataservice/vodataservice_v1_0'
+
+include VORuby::Resources::VOResource::V1_0
+include VORuby::Resources::VODataService::V1_0
+
+module VORuby
+  module Resources
+    module ConeSearch
+      module V1_0
+        
+        # Forward declarations
+        class CSCapRestriction < Capability; end
+        class ConeSearch < CSCapRestriction; end
+        class Query; end
+        
+        # An abstract capability that fixes the standardID to the IVOA ID for the ConeSearch standard.
+        class CSCapRestriction
+          text_node :description, 'description', :optional => true
+          
+          object_node :standard_id, '@standardID', :class => IdentifierURI, :optional => false,
+            :default_value => 'ivo://ivoa.net/std/ConeSearch'
+          
+          array_node :validation_levels, 'validationLevel', :class => Validation, :optional => true, :default_value => []
+          array_node :interfaces, 'interface', :unmarshaller => $InterfaceUnmarshaller, :optional => true, :default_value => []
+        end
+        
+        # The capabilities of a Cone Search implementation.  It includes
+        # the listing of the columns that appear in image query
+        # output VOTable and Cone Search-specific metadata.
+        class ConeSearch
+          # the largest search radius, in degrees, that will be
+          # accepted by the service without returning an error 
+          # condition
+          numeric_node :max_sr, 'maxSR', :optional => false
+          # the largest number of records that the service will return
+          numeric_node :max_records, 'maxRecords', :optional => false
+          
+          # true if the service supports the VERB keyword; false, otherwise
+          boolean_node :verbosity, 'verbosity', 'true', 'false', :optional => false
+          
+          # a query that will result in at least on matched record that can be used to test the service
+          object_node :test_query, 'testQuery', :class => Query
+        end
+        
+        # A query to be sent to the service.
+        class Query
+          include XML::Mapping
+          
+          # the right ascension of the search cone's center in decimal degree
+          numeric_node :ra, 'ra', :optional => false
+          # the declination of the search cone's center in decimal degrees
+          numeric_node :dec, 'dec', :optional => false
+          # the radius of the search cone in decimal degrees
+          numeric_node :sr, 'sr', :optional => false
+          # the verbosity level to use where 1 means the bare minimum set of columns and 3 means the full set of 
+          # available columns.
+          numeric_node :verb, 'verb', :optional => true
+          
+          # the catalog to query
+          text_node :catalog, 'catalog', :optional => true
+          # any extra (non-standard) parameters that must be provided (apart from what is part of base URL given 
+          # by the accessURL element).
+          text_node :extras, 'extras', :optional => true
+        end
+        
+      end
+    end
+  end
+end

data/lib/voruby/resources/conesearch/loader.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'xml/mapping'
+
+require 'voruby/loader'

data/lib/voruby/resources/loader.rb

@@ -0,0 +1,50 @@
+require 'voruby/loader'
+
+module VORuby
+  module Resources
+    NAMESPACE_MODULE_MAP =
+      { 
+        'http://www.ivoa.net/xml/VOResource/v0.10' => 'VORuby::Resources::VOResource::V_10',
+        'http://www.ivoa.net/xml/VOResource/v0.9' => 'VORuby::Resources::VOResource::V0_9',
+        'http://www.ivoa.net/xml/VOResource/v1.0' => 'VORuby::Resources::VOResource::V1_0',
+        'http://www.ivoa.net/xml/VODataService/v0.4' => 'VORuby::Resources::VODataService',
+        'http://www.ivoa.net/xml/VODataService/v0.5' => 'VORuby::Resources::VODataService::V0_5',
+        'http://www.ivoa.net/xml/VODataService/v1.0' => 'VORuby::Resources::VODataService::V1_0',
+        'http://www.ivoa.net/xml/OpenSkyNode/v0.1' => 'VORuby::OpenSkyNode',
+        'http://www.ivoa.net/xml/VORegistry/v0.2' => 'VORuby::Resources::VORegistry::V0_2',
+        'http://www.ivoa.net/xml/VORegistry/v0.3' => 'VORuby::Resources::VORegistry::V0_3',
+        'http://www.ivoa.net/xml/VORegistry/v1.0' => 'VORuby::Resources::VORegistry::V1_0',
+        'http://www.ivoa.net/xml/SIA/v0.6' => 'VORuby::Resources::SIA::V0_6',
+        'http://www.ivoa.net/xml/SIA/v0.7' => 'VORuby::Resources::SIA::V0_7',
+        'http://www.ivoa.net/xml/SIA/v1.0' => 'VORuby::Resources::SIA::V1_0',
+        'http://www.ivoa.net/xml/ConeSearch/v0.2' => 'VORuby::Resources::ConeSearch::V0_2',
+        'http://www.ivoa.net/xml/ConeSearch/v0.3' => 'VORuby::Resources::ConeSearch::V0_3',
+        'http://www.ivoa.net/xml/ConeSearch/v1.0' => 'VORuby::Resources::ConeSearch::V1_0'
+      }
+      
+      # Dynamically dispatches a request to a class using the determined XML
+      # namespace.
+      def self.namespace_dispatcher(default_module, default_type, default_class)
+         return Proc.new{ |xml|
+           the_module = type = nil
+           if xml.attributes['type']
+             ns_prefix, type = xml.attributes['type'].split(':')
+             type = ns_prefix if !type
+
+             the_module = NAMESPACE_MODULE_MAP[xml.namespace(ns_prefix)]
+             the_module = default_module if !the_module
+           else
+             the_module = default_module
+             type = default_type
+           end
+
+           # The name of the appropriate class corresponds to the type.
+           begin
+             eval("#{the_module}::#{type}.load_from_xml(xml)") # Would like to get rid of this eval somehow...
+           rescue NameError
+             default_class.load_from_xml(xml)
+           end
+         }
+       end
+  end
+end

data/lib/voruby/resources/nodes.rb

@@ -0,0 +1,190 @@
+require 'xml/mapping'
+require 'date'
+require 'time'
+
+module VORuby
+  module VOResource
+   module Mapping
+   
+    class DateTimeNode < XML::Mapping::SingleAttributeNode
+      def initialize_impl(path)
+        @path = XML::XXPath.new(path)
+      end
+     
+      def extract_attr_value(xml)
+        txt = default_when_xpath_err{ @path.first(xml).text }
+        DateTime.parse(txt)
+      end
+      
+      def set_attr_value(xml, value)
+        raise RuntimeError, "Not a date/time: #{value}" unless Time === value
+        @path.first(xml, :ensure_created => true).text = value.to_s
+      end
+    end
+    
+    class JulianDateTimeNode < DateTimeNode
+      def extract_attr_value(xml)
+        txt = default_when_xpath_err{ @path.first(xml).text }
+        DateTime.jd(txt.to_i)
+      end
+    end
+    
+    class UtcTimestampNode < DateTimeNode
+      def set_attr_value(xml, value)
+        raise RuntimeError, "Not a date/time: #{value}" unless Time === value
+        @path.first(xml, :ensure_created => true).text = value.to_s
+      end
+    end
+    
+    class UtcDateTimeNode < DateTimeNode
+      def set_attr_value(xml, value)
+        raise RuntimeError, "Not a date/time: #{value}" unless Time === value
+        @path.first(xml, :ensure_created => true).text = value.getutc.xmlschema
+      end
+    end
+    
+    module Misc
+      def raise_error(value)
+        raise RuntimeError, "Not a valid choice: #{value}.  Choose one of: #{@options[:choices].join(', ')}"
+      end
+    end
+    
+    class TextEnumerationNode < XML::Mapping::TextNode
+      include Misc
+      
+      def extract_attr_value(xml)
+        txt = default_when_xpath_err{ @path.first(xml).text }
+        self.raise_error("#{txt} in #{xml.parent}") if !@options[:choices].include?(txt)
+
+        return txt
+      end
+
+      def set_attr_value(xml, value)
+        self.raise_error(value) unless @options[:choices].include?(value)
+        @path.first(xml, :ensure_created => true).text = value.to_s
+      end
+    end
+    
+    class NumericEnumerationNode < XML::Mapping::NumericNode
+      include Misc
+      
+      def extract_attr_value(xml)
+        txt = default_when_xpath_err{ @path.first(xml).text }
+        
+        num = nil
+        begin
+          num = Integer(txt)
+        rescue ArgumentError
+          num = Float(txt) 
+        end
+        
+        self.raise_error(txt) if !@options[:choices].include?(num)
+        
+        return num
+      end
+
+      def set_attr_value(xml, value)
+        raise RuntimeError, "Not an integer: #{value}" unless Numeric === value
+        self.raise_error(value) unless @options[:choices].include?(value)
+        @path.first(xml,:ensure_created=>true).text = value.to_s
+      end
+    end
+    
+    # This is a copy of ObjectNode, but using REXML's full XPath
+    # implementation (i.e. not pre-compiling expressions).  It's
+    # potentially slower but necessary for some schema.
+    class FullObjectNode < XML::Mapping::SubObjectBaseNode 
+      # Initializer. _path_ (a string denoting an XPath expression) is
+      # the location of the subtree.
+      def initialize_impl(path)
+        super
+        @path_str = path
+      end
+      
+      def extract_attr_value(xml) # :nodoc:
+        paths = []
+        @path_str.split(/\s*\|\s*/).each{ |path|
+          paths << path
+          xml.prefixes.each{ |prefix|
+            paths << "#{prefix}:#{path}"
+          }
+        }
+        xpath = paths.join('|')
+        
+        result = default_when_xpath_err{REXML::XPath.first(xml, xpath)}
+        result ? @options[:unmarshaller].call(result): nil
+      end
+      
+      def set_attr_value(xml, value) # :nodoc:
+        @options[:marshaller].call(@path.first(xml,:ensure_created=>true), value)     
+      end
+    end
+    
+    class FullArrayNode < XML::Mapping::SubObjectBaseNode
+      # Initializer, delegates to do_initialize. Called with keyword
+      # arguments and either 1 or 2 paths; the hindmost path argument
+      # passed is delegated to _per_arrelement_path_; the preceding
+      # path argument (if present, "" by default) is delegated to
+      # _base_path_.
+      def initialize_impl(path,path2=nil)
+        super
+	      if path2
+	        do_initialize(path,path2)
+	      else
+	        do_initialize("",path)
+	      end
+      end
+      
+      # "Real" initializer.
+      def do_initialize(base_path, per_arrelement_path)
+        @base_path = base_path
+        @per_arrelement_path = per_arrelement_path
+      end
+      
+      def extract_attr_value(xml) # :nodoc:
+        paths = []
+        @per_arrelement_path.split(/\s*\|\s*/).each{ |path|
+          paths << path
+          xml.prefixes.each{ |prefix|
+            paths << "#{prefix}:#{path}"
+          }
+        }
+        xpath = @base_path + '(' + paths.join('|') + ')'
+        
+        result = []
+        default_when_xpath_err{REXML::XPath.match(xml, xpath)}.each do |elt|
+          result << @options[:unmarshaller].call(elt)
+        end
+        
+        result
+      end
+      
+      def set_attr_value(xml, value) # :nodoc:
+	      base_elt = @base_path.first(xml,:ensure_created=>true)
+	      value.each do |arr_elt|
+            @options[:marshaller].call(@per_arrelement_path.create_new(base_elt), arr_elt)
+	        end
+      end
+    end
+    
+    class TextFloatArrayNode < XML::Mapping::TextNode
+      def extract_attr_value(xml)
+        txt = default_when_xpath_err{ @path.first(xml).text }
+        
+        nums = []
+        txt.split(/\s+/).each do |str|
+          nums << str.to_f
+        end
+        
+        return nums
+      end
+      
+      def set_attr_value(xml, value)
+        raise RuntimeError, "Not an array: #{value}" unless Array === value
+        @path.first(xml, :ensure_created=>true).text = value.join(' ')
+      end
+    end
+    
+   end 
+  end
+end

data/lib/voruby/resources/openskynode/loader.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'xml/mapping'
+
+require 'voruby/loader'

data/lib/voruby/resources/openskynode/openskynode.rb

@@ -0,0 +1,9 @@
+require 'voruby/resources/openskynode/openskynode_v0_1'
+
+module VORuby
+  module Resources
+    module OpenSkyNode
+      #include OpenSkyNode::V0_1
+    end
+  end
+end