voruby 1.0.1

data/lib/voruby/votables/rexml_parser.rb

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

data/lib/voruby/votables/rexml_votable.rb

@@ -0,0 +1,67 @@
+module VORuby
+  module VOTables
+
+    module VOTable
+      require 'voruby/votables/votable'
+      require 'voruby/votables/rexml_parser'
+
+      # A wrapper around VOTable::VOTable that uses ruby's built in rexml library
+      # to parse XML.  Typically one would use VOTABLE::TreeParsedVOTable
+      # rather than using this class directly.
+      #  rexml_votable = VOTable::RexmlParsedVOTable('my_votable.xml')
+      #  votable = rexml_votable.votable
+      class RexmlParsedVOTable
+        attr_reader :path, :votable
+    
+        # [_path_:]
+        #  The path to the VOTable XML file to parse.
+        def initialize(path)
+          @path = path
+          file = File.new(path)
+      
+          doc = REXML::Document.new(file)
+          root = doc.root # Root document
+      
+          # Attributes
+          id = root.attributes['ID'] if root.attributes['ID']
+          version = root.attributes['version'] if root.attributes['version']
+      
+          # Elements
+          description =
+    		    Meta::Description.from_xml(root.elements.to_a('DESCRIPTION').first) if root.elements['DESCRIPTION']
+          definition =
+    		    Meta::Definitions.from_xml(root.elements.to_a('DEFINITIONS').first) if root.elements['DEFINITIONS']
+      
+          coosys = []
+          root.elements.each('COOSYS'){ |sys|
+            coosys.push(Meta::CooSys.from_xml(sys))
+          }
+      
+          params = []
+          root.elements.each('PARAM'){ |param|
+            params.push(Meta::Param.from_xml(param))
+          }
+      
+          info = []
+          root.elements.each('INFO'){ |inf|
+            info.push(Meta::Info.from_xml(inf))
+          }
+      
+          resources = []
+          root.elements.each('RESOURCE'){ |res|
+            resources.push(Meta::Resource.from_xml(res))
+          }
+
+         @votable = VOTable.new(id, version, description, definition, coosys, params, info, resources)
+        end
+    
+        # Convert a RexmlParsedVOTable into a string representation.
+        def to_s
+          "{file=#{@path};votable=#{@votable}}"
+        end
+      end
+
+    end
+  
+  end
+end