voruby 1.0.1

data/lib/voruby/votables/transforms.rb

@@ -0,0 +1,388 @@
+module VORuby
+  module VOTables
+    module VOTable
+      class VOTable
+        def self.from_soap_obj(mvot)
+          VOTable.new(
+            VOTable::_find_attr_value(mvot.__xmlattr, 'ID'),
+            VOTable::_find_attr_value(mvot.__xmlattr, 'version'),
+            (mvot.respond_to?(:dESCRIPTION))? Meta::Description.from_soap_obj(mvot.dESCRIPTION): nil,
+            (mvot.respond_to?(:dEFINITIONS))? Meta::Definitions.from_soap_obj(mvot.dEFINITIONS): nil,
+            (mvot.respond_to?(:cOOSYS))? Meta::CooSys.from_soap_obj(mvot.cOOSYS): [],
+            (mvot.respond_to?(:pARAM))? Meta::Param.from_soap_obj(mvot.pARAM): [],
+            (mvot.respond_to?(:iNFO))? Meta::Info.from_soap_obj(mvot.iNFO): [],
+            (mvot.respond_to?(:rESOURCE))? Meta::Resource.from_soap_obj(mvot.rESOURCE): []
+          )
+        end
+      end
+  
+      module Meta
+    
+        class Definitions
+          def self.from_soap_obj(mdef)
+            Definitions.new(
+               (mdef.respond_to?(:cOOSYS))? VOTable._coosys_from_soap_obj(mdef.cOOSYS): nil,
+               (mdef.respond_to?(:pARAM))? VOTable._params_from_soap_obj(mdef.pARAM): nil
+             )
+          end
+        end
+    
+        class Description
+          def self.from_soap_obj(mdesc)
+            Description.new(mdesc)
+          end
+        end
+    
+        class CooSys
+          def self.from_soap_obj(mcoosystems)
+            mcoosystems = [mcoosystems] if !mcoosystems.respond_to(:each)
+
+             coosys = []
+             mcoosystems.each do |mcoosys|
+               equinox_txt = VOTable::_find_attr_value(mcoosys.__xmlattr, 'equinox')
+               epoch_txt = VOTable::_find_attr_value(mcoosys.__xmlattr, 'epoch')
+               system_txt = VOTable::_find_attr_value(mcoosys.__xmlattr, 'system') || 'eq_FK5'
+
+               coosys.push(CooSys.new(
+                 VOTable::_find_attr_value(mcoosys.__xmlattr, 'ID'),
+                 (equinox_txt == nil)? nil: Type::AstroYear.new(equinox_txt),
+                 (epoch_txt == nil)? nil: Type::AstroYear.new(epoch_txt),
+                 Type::CoordSystemType.new(system_txt)
+               ))
+             end
+
+             coosys
+          end
+        end
+    
+        class Param
+          def self.from_soap_obj(mparams)
+            mparams = [mparams] if !mparams.respond_to?(:each)
+
+            params = []
+            mparams.each do |mparam|
+              datatype_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'datatype')
+              ucd_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'ucd')
+              precision_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'precision')
+              width_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'width')
+              arraysize_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'arraysize')
+
+              params.push(Param.new(
+                VOTable::_find_attr_value(mparam.__xmlattr, 'name'),
+                (datatype_txt == nil)? nil: Type::DataType.new(datatype_txt),
+                VOTable::_find_attr_value(mparam.__xmlattr, 'value'),
+                (ucd_txt == nil)? nil: Type::UCDType.new(ucd_txt),
+                VOTable::_find_attr_value(mparam.__xmlattr, 'unit'),
+                (mparam.respond_to?(:dESCRIPTION))? _description_from_soap_obj(mparam.dESCRIPTION): nil,
+                (mparam.respond_to?(:vALUES))? _values_from_soap_obj(mparam.vALUES): nil,
+                (mparam.respond_to?(:lINK))? _links_from_soap_obj(mapram.lINK): nil,
+                VOTable::_find_attr_value(mparam.__xmlattr, 'ID'),
+                (precision_txt == nil)? nil: Type::PrecisionType.new(precision_txt.to_i),
+                VOTable::_find_attr_value(mparam.__xmlattr, 'utype'),
+                (width_txt == nil)? nil: Type::PositiveInteger.new(width_txt.to_i),
+                VOTable::_find_attr_value(mparam.__xmlattr, 'ref'),
+                (arraysize_txt == nil)? nil: Type::ArrayDef.new(arraysize_txt)
+              ))
+            end
+        
+            params
+          end
+        end
+    
+        class Info
+          def self.from_soap_obj(minfo)
+            info = []
+            info.push(Info.new(
+              VOTable::_find_attr_value(minfo.__xmlattr, 'name'),
+              VOTable::_find_attr_value(minfo.__xmlattr, 'value'),
+              VOTable::_find_attr_value(minfo.__xmlattr, 'ID'),
+              minfo.__xmlele # text
+            ))
+        
+            info
+          end
+        end
+    
+        class Resource
+          def self.from_soap_obj(mresources)
+            mresources = [mresources] if !mresources.respond_to?(:each)
+
+            resources = []
+            mresources.each do |mres|
+              type_txt = VOTable::_find_attr_value(mres.__xmlattr, 'type') || 'results'
+
+              resources.push(Resource.new(
+                VOTable::_find_attr_value(mres.__xmlattr, 'name'),
+                VOTable::_find_attr_value(mres.__xmlattr, 'ID'),
+                VOTable::_find_attr_value(mres.__xmlattr, 'utype'),
+                Type::ResourceType.new(type_txt),
+                (mres.respond_to?(:dESCRIPTION))? Description.from_soap_obj(mres.dESCRIPTION): nil,
+                (mres.respond_to?(:iNFO))? Info.from_soap_obj(mres.iNFO): [],
+                (mres.respond_to?(:cOOSYS))? CooSys.from_soap_obj(mres.cOOSYS): [],
+                (mres.respond_to?(:pARAM))? Param.from_soap_obj(mres.pARAM): [],
+                (mres.respond_to?(:lINK))? Link.from_soap_obj(mres.lINK): [],
+                Table.from_soap_obj(mres.tABLE),
+                (mres.respond_to?(:rESOURCE))? Resource.from_soap_obj(mres.rESOURCE): []
+              ))
+            end
+
+            resources
+          end
+        end
+    
+        class Table
+          def self.from_soap_obj(mtables)
+            mtables = [mtables] if !mtables.respond_to?(:each)
+
+            tables = []
+            mtables.each do |mtable|
+              ucd_txt = VOTable::_find_attr_value(mtable.__xmlattr, 'ucd')
+              nrows_txt = VOTable::_find_attr_value(mtable.__xmlattr, 'nrows')
+
+              tables.push(Table.new(
+                VOTable::_find_attr_value(mtable.__xmlattr, 'name'),
+                VOTable::_find_attr_value(mtable.__xmlattr, 'ID'),
+                (ucd_txt == nil)? nil: Type::UCDType.new(ucd_txt),
+                VOTable::_find_attr_value(mtable.__xmlattr, 'utype'),
+                VOTable::_find_attr_value(mtable.__xmlattr, 'ref'),
+                (nrows_txt == nil)? nil: Type::NonNegativeInteger.new(nrows_txt.to_i),
+                (mtable.respond_to?(:dESCRIPTION))? Description.from_soap_obj(mtable.dESCRIPTION): nil,
+                (mtable.respond_to?(:fIELD))? Field.from_soap_obj(mtable.fIELD): [],
+                (mtable.respond_to?(:pARAM))? Param.from_soap_obj(mtable.pARAM): [],
+                (mtable.respond_to?(:gROUP))? Group.from_soap_obj(mtable.gROUP): [],
+                (mtable.respond_to?(:lINK))? Link.from_soap_obj(mtable.lINK): [],
+                (mtable.respond_to?(:dATA))? Data::Data.from_soap_obj(mtable.dATA): nil
+              ))
+            end
+
+            tables
+          end
+        end
+    
+        class Group
+          def self.from_soap_obj(mgroups)
+            mgroups = [mgroups] if !mgroups.respond_to?(:each)
+
+            groups = []
+            mgroups.each do |mgroup|
+              ucd_txt = OTable::VOTable::_find_attr_value(mgroup.__xmlattr, 'ucd')
+
+              groups.push(Group.new(
+                VOTable::_find_attr_value(mgroup.__xmlattr, 'name'),
+                (ucd_txt == nil)? nil: Type::UCDType.new(ucd_txt),
+                (mgroup.respond_to?(:dESCRIPTION))? Description.from_soap_obj(mgroup.dESCRIPTION): nil,
+                (mgroup.respond_to?(:fIELDref))? FieldRef.from_soap_obj(mgroup.fIELDref): [],
+                (mgroup.respond_to?(:pARAMref))? ParamRef.from_soap_obj(mgroup.pARAMref): [],
+                (mgroup.respond_to?(:pARAM))? Param.from_soap_obj(mgroup.pARAM): [],
+                (mgroup.respond_to?(:gROUP))? Group.from_soap_obj(mgroup.gROUP): [],
+                VOTable::_find_attr_value(mgroup.__xmlattr, 'ID'),
+                VOTable::_find_attr_value(mgroup.__xmlattr, 'ref'),
+                VOTable::_find_attr_value(mgroup.__xmlattr, 'utype')
+              ))
+            end
+
+            groups       
+          end
+        end
+    
+        class FieldRef
+          def self.from_soap_obj(mfieldrefs)
+            mfieldrefs = [mfieldrefs] if !mfieldrefs.respond_to?(:each)
+
+            fieldrefs = []
+            mfieldrefs.each do |mfieldref|
+              fieldrefs.push(FieldRef.new(
+                VOTable::_find_attr_value(mfieldref.__xmlattr, 'ref')
+              ))
+            end
+
+            fieldrefs       
+          end
+        end
+    
+        class ParamRef
+          def self.from_soap_obj(mparamrefs)
+            mparamrefs = [mparamrefs] if !mparamrefs.respond_to?(:each)
+
+            paramrefs = []
+            mparamrefs.each do |mparamref|
+              paramrefs.push(ParamRef.new(
+                VOTABLE::VOTable::_find_attr_value(mparamref.__xmlattr, 'ref')
+              ))
+            end
+
+            paramrefs        
+          end
+        end
+    
+        class Field
+          def self.from_soap_obj(mfields)
+            mfields = [mfields] if !mfields.respond_to?(:each)
+
+            fields = []
+            mfields.each do |mfield|
+              datatype_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'datatype')
+              ucd_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'ucd')
+              precision_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'precision')
+              width_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'width')
+              arraysize_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'arraysize')
+              type_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'type')
+
+              fields.push(Field.new(
+                VOTable::_find_attr_value(mfield.__xmlattr, 'name'),
+                (datatype_txt == nil)? nil: Type::DataType.new(datatype_txt),
+                (ucd_txt == nil)? nil: Type::UCDType.new(ucd_txt),
+                VOTable::_find_attr_value(mfield.__xmlattr, 'unit'),
+                (mfield.respond_to?(:dESCRIPTION))? Description.from_soap_obj(mfield.dESCRIPTION): nil,
+                (mfield.respond_to?(:vALUES))? Values.from_soap_obj(mfield.vALUES): nil,
+                (mfield.respond_to?(:lINK))? Link.from_soap_obj(mfield.lINK): [],
+                VOTable::_find_attr_value(mfield.__xmlattr, 'ID'),
+                (precision_txt == nil)? nil: Type::PrecisionType.new(precision_txt),
+                VOTable::_find_attr_value(mfield.__xmlattr, 'utype'),
+                (width_txt == nil)? nil: Type::PositiveInteger.new(width_txt.to_i),
+                VOTable::_find_attr_value(mfield.__xmlattr, 'ref'),
+                (arraysize_txt == nil)? nil: Type::ArrayDef.new(arraysize_txt),
+                (type_txt == nil)? nil: Type::FieldType.new(type_txt)
+              ))
+            end
+        
+            fields
+          end
+        end
+    
+        class Link
+          def self.from_soap_obj(mlinks)
+            mlinks = [mlinks] if !mlinks.respond_to?(:each)
+
+             links = []
+             mlinks.each do |mlink|
+               href_txt = VOTable::_find_attr_value(mlink.__xmlattr, 'href')
+               action_txt = VOTable::_find_attr_value(mlink.__xmlattr, 'action')
+               content_role_txt = VOTable::_find_attr_value(mlink.__xmlattr, 'content-role')
+
+               links.push(Link.new(
+                 (href_txt == nil)? nil: VOTABLE::Type::AnyURI.new(href_txt),
+                 VOTable::_find_attr_value(mlink.__xmlattr, 'value'),
+                 VOTable::_find_attr_value(mlink.__xmlattr, 'title'),
+                 (action_txt == nil)? nil: VOTABLE::Type::AnyURI.new(action_txt),
+                 VOTable::_find_attr_value(mlink.__xmlattr, 'ID'),
+                 VOTable::_find_attr_value(mlink.__xmlattr, 'content-type'),
+                 (content_role_txt == nil)? nil: Type::ContentRole.new(content_role_txt),
+                 VOTable::_find_attr_value(mlink.__xmlattr, 'ghref')
+               ))
+             end
+
+             links       
+          end
+        end
+    
+        class Values
+          def self.from_soap_obj(mvalues)
+            type_txt = VOTable::_find_attr_value(mvalues.__xmlattr, 'type') || 'legal'
+
+            Values.new(
+               (mvalues.respond_to?(:mIN))? Min.from_soap_obj(mvalues.mIN): nil,
+               (mvalues.respond_to?(:mAX))? Max.from_soap_obj(mvalues.mAX): nil,
+               (mvalues.respond_to?(:oPTIONS))? Option.from_soap_obj(mvalues.oPTIONS): [],
+               VOTable::_find_attr_value(mvalues.__xmlattr, 'ID'),
+               (type_txt == nil)? nil: Type::ValuesType.new(type_txt),
+               VOTable::_find_attr_value(mvalues.__xmlattr, 'null'),
+               VOTable::_find_attr_value(mvalues.__xmlattr, 'ref')
+             )       
+          end
+        end
+    
+        class Option
+          def self.from_soap_obj(moptions)
+            options = []
+            moptions.each do |moption|
+              options.push(Option.new(
+                VOTable::_find_attr_value(mvalues.__xmlattr, 'value'),
+                VOTable::_find_attr_value(mvalues.__xmlattr, 'name'),
+                (moption.respond_to?(:oPTION))? Option.from_soap_obj(moption.oPTION): []
+            ))
+            end
+        
+            options
+          end
+        end
+    
+        class Min
+          def self.from_soap_obj(mmin)
+            inclusive_txt = VOTable::_find_attr_value(mmin.__xmlattr, 'inclusive') || 'yes'
+
+            Min.new(
+              VOTable::_find_attr_value(mmin.__xmlattr, 'value'),
+              Type::YesNo.new(inclusive_txt)
+            )       
+          end
+        end
+    
+        class Max
+          def self.from_soap_obj(mmax)
+            inclusive_txt = VOTable::_find_attr_value(mmax.__xmlattr, 'inclusive') || 'yes'
+
+            Max.new(
+              VOTable::_find_attr_value(mmax.__xmlattr, 'value'),
+              Type::YesNo.new(inclusive_txt)
+            )        
+          end
+        end
+    
+      end
+  
+      module Data
+  
+        class Data
+          def self.from_soap_obj(mdata)
+            # Note that strictly one can also have a FITS or BINARY stream here
+            Data.new(
+              (mdata.respond_to?(:tABLEDATA))? TableData.from_soap_obj(mdata.tABLEDATA): nil
+            )
+          end
+        end
+  
+        class TableData
+          def self.from_soap_obj(mtbldata)
+            TableData.new(
+               (mtbldata.respond_to?(:tR))? TR.from_soap_obj(mtbldata.tR): []
+             )        
+          end
+        end
+    
+        class TR
+          def self.from_soap_obj(mtrs)
+            mtrs = [mtrs] if !mtrs.respond_to?(:each)
+
+            trs = []
+            mtrs.each do |tr|
+              trs.push(
+                (tr.respond_to?(:tD))? TR.new(TD.from_soap_obj(tr.tD)): []
+              )
+            end
+
+            trs
+          end
+        end
+    
+        class TD
+          def self.from_soap_obj(mtds)
+            mtds = [mtds] if !mtds.respond_to?(:each)
+
+            tds = []
+            mtds.each do |td|
+              tds.push(TD.new(
+                td,
+                (td.respond_to?(:__xmlattr))? VOTable::_find_attr_value(td.__xmlattr, 'encoding'): Type::EncodingType.new('none')
+              ))
+            end
+
+            tds
+          end
+        end
+    
+      end
+    end
+    
+  end
+end

data/lib/voruby/votables/tree.rb

@@ -0,0 +1,45 @@
+module VORuby
+  module VOTables
+    module VOTable
+
+      # A VOTable parsed from a file using a DOM-like implementation of
+      # an XML parser.  For example:
+      #  tree_votable = VOTable::TreeParsedVOTable.new('my_votable.xml', 'rexml')
+      #  real_votable = tree_votable.votable # Get the VOTable
+      # As you can see, TreeParsedVOTable is basically a wrapper for
+      # VOTable.
+      class TreeParsedVOTable
+        attr_reader :path, :votable, :lib
+
+    	  # [_path_:]
+    	  #  The path to a valid VOTable XML file.
+    	  # [_lib_:]
+    	  #  The underlying library used to parse the XML.  Current options are
+    	  #  'rexml' and 'libxml'.  Rexml is Ruby's all-native XML parsing solution
+    	  #  and is therefore shipped with every ruby release.  It's very convenient
+    	  #  but slow on large files.  Ruby also has available[http://rubyforge.org/projects/xml-tools/]
+    	  #  to it libxml2 bindings which can be installed separately.  This is the
+    	  #  recommended configuration for production systems as it is *much* faster.
+        def initialize(path, lib='rexml')
+          @path = path
+          @lib = lib
+
+          @votable = nil
+          if lib == 'libxml' # For a faster alternative, use libxml2
+    		    require 'voruby/votables/libxml_votable'
+    		    @votable = LibxmlParsedVOTable.new(@path)
+          else # By default, we'll use Ruby's built-in native XML parser
+    		    require 'voruby/votables/rexml_votable'
+    		    @votable = RexmlParsedVOTable.new(@path)
+          end
+        end
+
+    	  # Convert the TreeParsedVOTable to a string representation.
+        def to_s
+          "{lib=#{@lib};#{@votable}}"
+        end
+      end
+    end
+    
+  end
+end