voruby 1.0.1

data/lib/voruby/votables/libxml_parser.rb

@@ -0,0 +1,411 @@
+module VORuby
+  module VOTables
+    module VOTable
+      require 'xml/libxml'
+
+      module Meta
+
+        class Description
+          def self.from_xml(node)
+    		    return Meta::Description.new(node.to_s)
+          end
+        end
+
+        class Definitions
+          def self.from_xml(node)
+    		    systems = []
+        		node.find('COOSYS').each { |sysNode|
+        	  		systems.push(Meta::CooSys.from_xml(sysNode))
+        		}
+	
+        		params = []
+        		node.find('PARAM').each { |paramNode|
+        	  		params.push(Meta::Param.from_xml(paramNode))
+        		}
+	
+        		return self.new(systems, params)
+          end
+        end
+
+        class CooSys
+          def self.from_xml(node)
+    		    id = node['ID']
+        		equinox = Type::AstroYear.new(node['equinox']) if node['equinox']
+        		epoch = Type::AstroYear.new(node['epoch']) if node['epoch']
+        		system = Type::CoordSystemType.new(node['system']) if node['system']
+	
+        		return self.new(id, equinox, epoch, system)
+          end
+        end
+
+        class Link
+          def self.from_xml(node)
+    		    id = node['ID']
+        		content_role = Type::ContentRole.new(node['content-role']) if node['content-role']
+        		content_type = node['content-type']
+        		title = node['title']
+        		value = node['value']
+        		href = Type::AnyURI.new(node['href']) if node['href']
+        		gref = node['gref']
+        		action = Type::AnyURI.new(node['action']) if node['action']
+	
+        		return self.new(href, value, title, action, id, content_type, content_role, gref)
+          end
+        end
+
+        class Values
+          def self.from_xml(node)
+    		    # Attributes
+        		id = node['ID'] if node['ID']
+        		type = Type::ValuesType.new(node['type']) if node['type']
+        		null = node['null'] if node['null']
+        		ref = node['ref'] if node['ref']
+	
+        		# Elements
+        		min = Meta::Min.from_xml(node.find('MIN').to_a.first) if node.find('MIN').length > 0
+        		max = Meta::Max.from_xml(node.find('MAX').to_a.first) if node.find('MAX').length > 0
+
+        		options = []
+        		node.find('OPTION').each { |optNode|
+        	  		options.push(Meta::Option.from_xml(optNode))
+        		}
+	
+        		return self.new(min, max, options, id, type, null, ref)
+          end
+        end
+
+        class FieldRef
+          def self.from_xml(node)
+    		    ref = node['ref'] if node['ref']
+	
+        		return self.new(ref)
+          end
+        end
+
+        class ParamRef
+          def self.from_xml(node)
+    		    ref = node['ref'] if node['ref']
+	
+        		return self.new(ref)
+          end
+        end
+
+        class Group
+          def self.from_xml(node)
+    		    # Attributes
+        		id = node['ID'] if node['ID']
+        		name = node['name'] if node['name']
+        		ref = node['ref'] if node['ref']
+        		ucd = UCDType.new(node['ucd']) if node['ucd']
+        		utype = node['utype'] if node['utype']
+	
+        		# Elements
+        		description =
+        	  		Meta::Description.from_xml(node.find('DESCRIPTION').to_a.first) if node.find('DESCRIPTION').length > 0
+		
+        		fieldrefs = []
+        		node.find('FIELDref').each { |fref|
+        	  		fieldrefs.push(Meta::FieldRef.from_xml(fref))
+        		}
+	
+        		paramrefs = []
+        		node.find('PARAMref').each { |pref|
+        	  		paramrefs.push(Meta::ParamRef.from_xml(pref))
+        		}
+	
+        		params = []
+        		node.find('PARAM').each { |param|
+        	  		params.push(Meta::Param.from_xml(param))
+        		}
+	
+        		groups = []
+        		node.find('GROUP').each { |group|
+        	  		groups.push(Meta::Group.from_xml(group))
+        		}
+	
+        		return self.new(name, ucd, description, fieldrefs, paramrefs, params, groups,
+        						id, ref, utype)
+          end
+        end
+
+        class Param
+          def self.from_xml(node)
+    	    	# Attributes
+        		id = node['ID'] if node['ID']
+        		unit = node['unit'] if node['unit']
+        		datatype = Type::DataType.new(node['datatype']) if node['datatype']
+        		precision = Type::PrecisionType.new(node['precision']) if node['precision']
+        		width = Type::PositiveInteger.new(node['width'].to_i) if node['width']
+        		ref = node['ref'] if node['ref']
+        		name = node['name'] if node['name']
+        		ucd = Type::UCDType.new(node['ucd']) if node['ucd']
+        		utype = node['utype'] if node['utype']
+        		value = node['value'] if node['value']
+        		arraysize = Type::ArrayDef.new(node['arraysize']) if node['arraysize']
+	
+        		# Elements
+        		description =
+        	  		Meta::Description.from_xml(node.find('DESCRIPTION').to_a.first) if node.find('DESCRIPTION').length > 0
+        		values =
+        	  		Meta::Values.from_xml(node.find('VALUES').to_a.first) if node.find('VALUES').length > 0
+
+        		links = []
+        		node.find('LINK').each { |linkNode|
+        	  		links.push(Meta::Link.from_xml(linkNode))
+        		}
+	
+        		return self.new(name, datatype, value, ucd, unit, description, values, links,
+        						id, precision, utype, width, ref, arraysize)
+          end
+        end
+
+        class Field
+          def self.from_xml(node)
+    	    	# Attributes
+        		id = node['ID'] if node['ID']
+        		unit =  node['unit'] if node['unit']
+        		datatype = Type::DataType.new(node['datatype']) if node['datatype']
+        		precision = Type::PrecisionType.new(node['precision']) if node['precision']
+        		width = Type::PositiveInteger.new(node['width'].to_i) if node['width']
+        		ref = node['ref'] if node['ref']
+        		name = node['name'] if node['name']
+        		ucd = Type::UCDType.new(node['ucd']) if node['ucd']
+        		arraysize = Type::ArrayDef.new(node['arraysize']) if node['arraysize']
+        		type = Type::FieldType.new(node['type']) if node['type']
+        		utype = node['utype'] if node['utype']
+	
+        		# Elements
+        		description =
+        	  		Meta::Description.from_xml(node.find('DESCRIPTION').to_a.first) if node.find('DESCRIPTION').length > 0
+        		values =
+        	  		Meta::Values.from_xml(node.find('VALUES').to_a.first) if node.find('VALUES').length > 0
+
+        		links = []
+        		node.find('LINK').each { |link|
+        	  		links.push(Meta::Link.from_xml(link))
+        		}
+	
+        		return self.new(name, datatype, ucd, unit, description, values,
+        						links, id, precision, utype, width, ref, arraysize, type)
+          end
+        end
+
+        class Info
+          def self.from_xml(node)
+    		    id = node['ID']
+        		name = node['name']
+        		value = node['value']
+	
+        		return self.new(name, value, id)
+          end
+        end
+
+        class Table
+          def self.from_xml(node)
+    	    	# Attributes
+        		id = node['ID'] if node['ID']
+        		name = node['name'] if node['name']
+        		ref = node['ref'] if node['ref']
+        		ucd = UCDType.new(node['ucd']) if node['ucd']
+        		utype = node['utype'] if node['utype']
+        		nrows = NonNegativeInteger.new(node['nrows'].to_i) if node['nrows']
+	
+        		# Elements
+        		description =
+        	  		Meta::Description.from_xml(node.find('DESCRIPTION').to_a.first) if node.find('DESCRIPTION').length > 0
+	
+        		fields = []
+        		node.find('FIELD').each { |fieldNode|
+        	  		fields.push(Meta::Field.from_xml(fieldNode))
+        		}
+		
+        		params = []
+        		node.find('PARAM').each { |paramNode|
+        	  		params.push(Meta::Param.from_xml(paramNode))
+        		}
+	
+        		groups = []
+        		node.find('GROUP').each { |groupNode|
+        	  		params.push(Meta::Group.from_xml(groupNode))
+        		}
+	
+        		links = []
+        		node.find('LINK').each { |linkNode|
+        	  		params.push(Meta::Link.from_xml(linkNode))
+        		}
+	
+        		data = Data::Data.from_xml(node.find('DATA').to_a.first) if node.find('DATA').length > 0
+            
+        		return self.new(name, id, ucd, utype, ref, nrows, description,
+        						fields, params, groups, links, data)
+          end
+        end
+
+        class Resource
+          def self.from_xml(node)
+    	    	# Attributes
+        		name = node['name'] if node['name']
+        		id = node['ID'] if node['ID']
+        		utype = node['utype'] if node['utype']
+        		type = Type::ResourceType.new(node['type']) if node['type']
+	
+        		# Elements
+        		description =
+        	  		Meta::Description.from_xml(node.find('DESCRIPTION').to_a.first) if node.find('DESCRIPTION').length > 0
+	
+        		info = []
+        		node.find('INFO').each { |infoNode|
+        	  		info.push(Meta::Info.from_xml(infoNode))
+        		}
+	
+        		systems = []
+        		node.find('COOSYS').each { |sysNode|
+        	  		systems.push(Meta::CooSys.from_xml(sysNode))
+        		}
+             
+        		params = []
+        		node.find('PARAM').each { |paramNode|
+        	  		params.push(Meta::Param.from_xml(paramNode))
+        		}
+             
+        		resources = []
+        		node.find('RESOURCE').each { |resNode|
+        	  		resources.push(Meta::Resource.from_xml(resNode))
+        		}
+	
+        		links = []
+        		node.find('LINK').each { |linkNode|
+        	  		links.push(Meta::Link.from_xml(linkNode))
+        		}
+	
+        		tables = []
+        		node.find('TABLE').each { |tblNode|
+        	  		tables.push(Meta::Table.from_xml(tblNode))
+        		}
+	
+        		return self.new(name, id, utype, type, description,
+        						info, systems, params, links, tables, resources)
+          end
+        end
+
+        class Option
+          def self.from_xml(node)
+    	    	value = node['value'] if node['value']
+        		name = node['name'] if node['name']
+	
+        		options = []
+        		node.find('OPTION').each { |optNode|
+        	  		options.push(Meta::Option.from_xml(optNode))
+        		}
+			  
+        		return self.new(value, name, options)
+          end
+        end
+
+        class Max
+          def self.from_xml(node)
+    		    value = node['node'] if node['node']
+        		inclusive = Type::YesNo.new(node['inclusive']) if node['inclusive']
+	
+        		return self.new(value, inclusive)
+          end
+        end
+
+        class Min
+          def self.from_xml(node)
+        		value = node['node'] if node['node']
+        		inclusive = Type::YesNo.new(node['inclusive']) if node['inclusive']
+	
+        		return self.new(value, inclusive)
+          end
+        end
+
+      end
+
+      module Data
+
+        class Stream
+          def self.from_xml(node)
+    		    href = Type::AnyURI.new(node['href']) if node['href']
+        		expires = DateTime.parse(node['expires']) if node['expires']
+        		rights = node['rights']
+        		type = Type::StreamType.new(node['type']) if node['type']
+        		actuate = Actuate.new(node['actuate']) if node['actuate']
+        		encoding = Type::EncodingType.new(node['encoding']) if node['encoding']
+	
+        		return self.new(href, expires, rights, type, actuate, encoding)
+          end
+        end
+
+        class BinaryStream
+          def self.from_xml(node)
+    		    stream = Stream.from_xml(node.find('STREAM').to_a.first)
+	
+        		return self.new(stream)
+          end
+        end
+
+        class FITSStream
+          def self.from_xml(node)	
+    		    stream = Stream.from_xml(node.find('STREAM').to_a.first)
+        		extnum = Type::PositiveInteger.new(node['extnum'].to_i) if node['extnum']
+	
+        		return self.new(stream, extnum)
+          end
+        end
+
+        class TD
+          def self.from_xml(node)
+    		    value = node.to_s 
+        		encoding = Type::EncodingType.new(node['encoding']) if node['encoding']
+	
+        		return self.new(value, encoding)
+          end
+        end
+
+        class TR
+          def self.from_xml(node)
+    		    tds = []
+        		node.find('TD').each { |tdNode|
+        	  		tds.push(TD.from_xml(tdNode))
+        		}
+	
+        		return self.new(tds)
+          end
+        end
+
+        class TableData
+          def self.from_xml(node)
+    		    trs = []
+        		node.find('TR').each { |trNode|
+        	  		trs.push(TR.from_xml(trNode))
+        		}
+	
+        		return self.new(trs)
+          end
+        end
+
+        class Data
+          def self.from_xml(node)
+    		    format = nil
+        		node.find('FITS').each { |fnode|
+        	  		format = FITSStream.from_xml(fnode)
+        		}
+	
+        		node.find('BINARY').each { |bnode|
+        	  		format = BinaryStream.from_xml(bode)
+        		}
+	
+        		node.find('TABLEDATA').each { |tnode|
+        	  		format = TableData.from_xml(tnode)
+        		}
+	
+        		return self.new(format)
+          end
+        end
+
+      end
+    end
+    
+  end
+end

data/lib/voruby/votables/libxml_votable.rb

@@ -0,0 +1,67 @@
+module VORuby
+  module VOTables
+    
+    module VOTable
+      require 'voruby/votables/votable'
+      require 'voruby/votables/libxml_parser'
+
+      # A wrapper around VOTable::VOTable that uses the libxml2 library and
+      # its corresponding bindings[http://rubyforge.org/projects/xml-tools/]
+      # to parse XML.  Typically one would use VOTable::TreeParsedVOTable
+      # rather than using this class directly.
+      #  libxml_votable = VOTable::LibxmlParsedVOTable('my_votable.xml')
+      #  votable = libxml_votable.votable
+      class LibxmlParsedVOTable
+        attr_reader :path, :votable
+
+        # [_path_:]
+        #  The path to the VOTable XML file to parse.
+        def initialize(path)
+          @path = path ;
+          doc = XML::Document.file(path)
+
+          root = doc.root # Root document
+
+          # Attributes
+          id = root['ID'] if root['ID']
+          version = root['version'] if root['version']
+
+          # Elements
+          description =
+    		    Meta::Description.from_xml(root.find('DESCRIPTION').to_a.first) if root.find('DESCRIPTION').length > 0
+          definition =
+    		    Meta::Definitions.from_xml(root.find('DEFINITIONS').to_a.first) if root.find('DEFINITIONS').length > 0
+
+          coosys = []
+          root.find('COOSYS').each { |sys|
+            coosys.push(Meta::CooSys.from_xml(sys))
+          }
+
+          params = []
+          root.find('PARAM').each { |param|
+            params.push(Meta::Param.from_xml(param))
+          }
+
+          info = []
+          root.find('INFO').each { |inf|
+            info.push(Meta::Info.from_xml(inf))
+          }
+      
+          resources = []
+          root.find('RESOURCE').each { |res|
+            resources.push(Meta::Resource.from_xml(res))
+          }
+
+          @votable = VOTable.new(id, version, description, definition, coosys, params, info, resources)
+        end
+
+    	# Convert a LibxmlParsedVOTable into a string representation.
+        def to_s
+          "{file=#{@path};votable=#{@votable}}"
+        end
+      end
+
+    end
+    
+  end
+end

data/lib/voruby/votables/loader.rb

@@ -0,0 +1,10 @@
+require 'date'
+require 'uri'
+require 'xsd/qname'
+
+require 'voruby/loader'
+require 'voruby/votables/types'
+require 'voruby/votables/data'
+require 'voruby/votables/meta'
+require 'voruby/votables/misc'
+require 'voruby/votables/transforms'