voruby 1.0.1

data/lib/voruby/adql/transforms.rb

@@ -0,0 +1,573 @@
+require 'voruby/adql/adql'
+require 'rexml/element'
+
+module VORuby
+  
+  module ADQL
+  	class ScalarExpression
+  		def to_adqls
+  			self.value
+  		end
+  	end
+	
+  	class ClosedExpr
+  		def to_adqls
+  			"(#{self.value.to_adqls})"
+  		end
+  	end
+	
+  	class BinaryOperator
+  		def to_adqls
+  			self.operator
+  		end
+  	end
+	
+  	class BinaryExpr
+  		def to_adqls
+  			"#{self.arg1.to_adqls} #{self.oper.to_adqls} #{self.arg2.to_adqls}"
+  		end
+  	end
+	
+  	class UnaryOperator
+  		def to_adqls
+  			self.operator
+  		end
+  	end
+	
+  	class UnaryExpr
+  		def to_adqls
+  			"#{self.oper.to_adqls}#{self.arg.to_adqls}"
+  		end
+  	end
+	
+  	class ColumnReference
+  		def to_adqls
+  			"#{self.table}.#{self.name}"
+  		end
+		
+  		def to_adqlx(element_name)
+  		  "<#{element_name} Name=\"#{self.name}\" Table=\"#{self.table}\" " +
+                "xsi:type=\"columnReferenceType\"/>"
+  		end
+  	end
+	
+  	class Atom
+  		def to_adqls
+  		  lit_value = self.literal
+  		  if lit_value.is_a?(StringType)
+  			  "'#{lit_value.to_adqls}#{self.unit || ''}'"
+  			else
+  			  "#{lit_value.to_adqls}#{self.unit || ''}"
+  		  end
+  		end
+		
+  		def to_adqlx(element_name)
+  		  literal_type = ''
+  		  if self.literal.is_a?(ADQL::RealType)
+  		    literal_type = 'realType'
+  		  elsif self.literal.is_a?(ADQL::IntegerType)
+              literal_type = 'integerType'
+            elsif self.literal.is_a?(ADQL::StringType)
+              literal_type = 'stringType'
+            end
+		  
+  		  atom = "<#{element_name} xsi:type=\"atomType\">\n"
+  		  atom << self.literal.to_adqlx(literal_type)
+  		  atom << "\n</#{element_name}>\n"
+		  
+  		  return atom
+  		end
+  	end
+	
+  	class LiteralType
+  		def to_adqls
+  			self.value.to_s
+  		end
+		
+  		def to_adqlx(literal_type)
+  		  "<Literal xsi:type=\"#{literal_type}\" Value=\"#{self.value.to_s}\" />"
+  		end
+  	end
+	
+  	class SelectionOption
+  		def to_adqls
+  			self.option.option
+  		end
+  	end
+	
+  	class AllOrDistinct
+  		def to_adqls
+  			self.option
+  		end
+  	end
+	
+  	class TrigonometricFunctionName
+  		def to_adqls
+    	  self.value
+    	end
+  	end
+	
+  	class TrigonometricFunction
+  	  def to_adqls
+    	  if self.allow
+    		  "#{self.name.to_adqls}(#{self.allow.to_adqls} #{self.arg.to_adqls})"
+    		else
+    		  "#{self.name.to_adqls}(#{self.arg.to_adqls})" 
+    		end
+  		end
+    end
+	
+  	class MathFunctionName
+  		def to_adqls
+  			self.value
+  		end
+  	end
+	
+  	class MathFunction
+  	  def to_adqls
+  	    if self.allow
+    		  "#{self.name.to_adqls}(#{self.allow.to_adqls} #{self.arg.to_adqls})"
+    	  else
+    		  "#{self.name.to_adqls}(#{self.arg.to_adqls})" 
+    	  end
+    	end 
+    end
+	
+  	class AggregateFunctionName
+  		def to_adqls
+  			self.value
+  		end
+  	end
+
+    class AggregateFunction
+      def to_adqls
+        if self.allow
+    		  "#{self.name.to_adqls}(#{self.allow.to_adqls} #{self.arg.to_adqls})"
+    	  else
+    		  "#{self.name.to_adqls}(#{self.arg.to_adqls})" 
+    	  end
+      end
+    end
+	
+  	class AliasSelectionItem
+  		def to_adqls
+  			if self.as
+  				"#{self.expression.to_adqls} AS #{self.as}"
+  			else
+  				self.expression.to_adqls
+  			end
+  		end
+  	end
+	
+    class AllSelectionItem
+      def to_adqls
+        '*'
+      end
+    
+      def to_adqlx(element_name)
+        "<#{element_name} xsi:type=\"allSelectionItemType\"/>"
+      end
+    end
+	
+    class Comparison
+      def to_adqls
+        self.value
+      end
+    
+      def to_adqlx
+        self.value
+      end
+    end
+	
+    class ArchiveTable
+      def to_adqls
+        if self.alias_name
+          "#{self.archive}:#{self.name} #{self.alias_name}"
+        else
+          "#{self.archive}:#{self.name}"
+        end
+      end
+    
+      def to_adqlx
+        if self.alias_name
+          "<Table Name=\"#{self.name}\" Archive=\"#{self.archive}\" " +
+              "Alias=\"#{self.alias_name}\" xsi:type=\"tableType\"/>"
+        else
+          "<Table Name=\"#{self.name}\" Archive=\"#{self.archive}\" " +
+              "xsi:type=\"tableType\"/>"
+        end
+      end
+    end
+	
+  	class Table
+  		def to_adqls
+  			if self.alias_name
+  				"#{self.name} #{self.alias_name}"
+  			else
+  				self.name
+  			end
+  		end
+  	end
+	
+  	class XMatchTableAlias
+  		def to_adqls
+  			self.name
+  		end
+  	end
+	
+  	class DropTable
+  		def to_adqls
+  			"!#{self.name}"
+  		end
+  	end
+	
+    class IntersectionSearch
+      def to_adqls
+        "#{self.cond1.to_adqls} AND #{self.cond2.to_adqls}"
+      end
+    
+      def to_adqlx
+        intersection_search = "<Condition xsi:type=\"intersectionSearchType\">\n"
+        intersection_search << self.cond1.to_adqlx
+        intersection_search << self.cond2.to_adqlx
+        intersection_search << "</Condition>\n"
+        return intersection_search
+      end
+    end
+	
+    class UnionSearch
+      def to_adqls
+        "#{self.cond1.to_adqls} OR #{self.cond2.to_adqls}"
+      end
+    
+      def to_adqlx
+        union_search = "<Condition xsi:type=\"unionSearchType\">\n"
+        union_search << self.cond1.to_adqlx
+        union_search << self.cond2.to_adqlx
+        union_search << "</Condition>\n"
+        return union_search
+      end
+    end
+	
+  	class XMatch
+  		def to_adqls
+  			tables = self.tables.collect{|x| x.to_adqls}.join(', ')
+  			"XMATCH(#{tables}) #{nature.value} #{sigma.value}"
+  		end
+  	end
+	
+  	class LikePred
+  		def to_adqls
+  			"#{self.arg.to_adqls} LIKE #{self.pattern.to_adqls}"
+  		end
+		
+  		def to_adqlx
+  		  like_pred = "<Condition xsi:type=\"likePredType\">\n"
+  		  like_pred << self.arg.to_adqlx('Arg') + "\n"
+  		  like_pred << self.pattern.to_adqlx('Pattern')
+  		  like_pred << "</Condition>\n"
+		  
+  		  return like_pred
+  		end
+  	end
+	
+  	class NotLikePred
+  		def to_adqls
+  			"#{self.arg.to_adqls} NOT LIKE #{self.pattern.to_adqls}"
+  		end
+  	end
+	
+  	class SubQuerySet
+  		def to_adqls
+  			self.selection.to_adqls
+  		end
+  	end
+	
+  	class ClosedSearch
+  		def to_adqls
+  			"(#{self.condition.to_adqls})"
+  		end
+  	end
+	
+  	class ComparisonPred
+  		def to_adqls
+  			"#{self.arg1.to_adqls} #{self.comparison.to_adqls} #{self.arg2.to_adqls}"
+  		end
+		
+  		def to_adqlx
+  		  comparison_pred = "<Condition xsi:type=\"comparisonPredType\" Comparison=\"#{self.comparison.to_adqlx}\">\n"
+            comparison_pred << self.arg1.to_adqlx('Arg') + "\n"
+            comparison_pred << self.arg2.to_adqlx('Arg')
+            comparison_pred << "</Condition>\n"
+            return comparison_pred
+  		end
+  	end
+	
+  	class BetweenPred
+  		def to_adqls
+  			"#{self.arg1.to_adqls} BETWEEN #{self.arg2.to_adqls} AND #{self.arg3.to_adqls}"
+  		end
+		
+  		def to_adqlx
+  		  between_pred = "<Condition xsi:type=\"betweenPredType\">\n"
+  		  between_pred << self.arg1.to_adqlx('Arg') + "\n"
+  		  between_pred << self.arg2.to_adqlx('Arg')
+  		  between_pred << self.arg3.to_adqlx('Arg')
+  		  between_pred << "</Condition>\n"
+  		  return between_pred
+  		end
+  	end
+	
+  	class NotBetweenPred
+  		def to_adqls
+  			"#{self.arg1.to_adqls} NOT BETWEEN #{self.arg2.to_adqls} AND #{self.arg3.to_adqls}"
+  		end
+  	end
+  
+    class Circle
+      def to_adqls
+        "#{self.shape.to_adqls} #{self.system.to_adqls} #{self.ra.to_adqls} #{self.dec.to_adqls} #{self.radius.to_adqls}"
+      end
+    
+      def to_adqlx
+        circle = "xsi:type=\"reg:circleType\" unit=\"deg\">\n"
+        circle << "<reg:Center>#{self.ra.value} #{self.dec.value}</reg:Center>\n"
+        circle << "<reg:Radius>#{self.radius.value}</reg:Radius>\n"
+        return circle
+      end
+    end
+  
+    class Box
+      def to_adqls
+        "#{self.shape.to_adqls} #{self.system.to_adqls} " +
+        "#{self.ra.to_adqls} #{self.dec.to_adqls} " +
+        "#{self.dra.to_adqls} #{self.ddec.to_adqls}"
+      end
+    
+      def to_adqlx
+        box = "xsi:type=\"reg:boxType\">\n"
+        box << "<reg:Center>#{self.ra.value} #{self.dec.value}</reg:Center>\n"
+        box << "<reg:Size>#{self.dra.value} #{self.ddec.value}</reg:Size>\n"
+        return box
+      end
+    end
+  
+    class RegionSearch
+      def to_adqls
+        "Region('#{self.shape.to_adqls}')"
+      end
+    
+      def to_adqlx
+        region = "<Condition xsi:type=\"regionSearchType\" intersection=\"#{self.intersection.value}\">\n"
+        region << "<Region "
+      
+        region << self.shape.to_adqlx
+          
+        region << "</Region>\n"
+        region << "</Condition>\n"
+        return region
+      end
+    end
+	
+  	class InverseSearch
+  	  def to_adqls
+  	    "NOT #{self.condition.to_adqls}"
+      end
+    end
+	
+  	class Having
+  		def to_adqls
+  			"HAVING #{self.condition.to_adqls}"
+  		end
+  	end
+	
+  	class GroupBy
+  		def to_adqls
+  			cols = self.columns.collect{|x| x.to_adqls}.join(', ')
+  			"GROUP BY #{cols}"
+  		end
+  	end
+	
+    class Where
+      def to_adqls
+        "WHERE #{self.condition.to_adqls}" if self.condition
+      end
+    
+      def to_adqlx
+        if self.condition
+          where = "<Where>\n"
+          where << self.condition.to_adqlx
+          where << "\n</Where>\n"
+          return where
+        end
+      end
+    end
+	
+  	class From
+  	  def to_adqls
+  	    tables = self.tables.collect{|x| x.to_adqls}.join(', ')
+  	    "FROM #{tables}"
+        end
+      
+        def to_adqlx
+          from = "<From>\n"
+          from << self.tables.collect{|x| x.to_adqlx}.join("\n")
+          from << "\n</From>\n"
+        
+          return from
+        end
+      end
+  
+    class SelectionList
+        def to_adqls
+          self.items.collect{|x| x.to_adqls}.join(', ')
+        end
+      
+        def to_adqlx
+          selection_list = "<SelectionList>\n"
+          selection_list << self.items.collect{|x| x.to_adqlx('Item')}.join("\n")
+          selection_list << "\n</SelectionList>\n"
+        
+          return selection_list
+        end
+    end
+  
+    class SelectionLimit
+      def to_adqls
+        "TOP #{self.top}"
+      end
+    end
+  
+    class Into
+      def to_adqls
+        "INTO #{self.table_name}"
+      end
+    end
+  
+    class OrderDirection
+      def to_adqls
+        self.value
+      end
+    end
+  
+    class OrderOption
+      def to_adqls
+        self.direction.to_adqls
+      end
+    end
+  
+    class Order
+      def to_adqls
+        if self.order
+          "#{self.expression.to_adqls} #{self.order.to_adqls}"
+        else
+          "#{self.expression.to_adqls}"
+        end
+      end
+    end
+  
+    class OrderExpression
+      def to_adqls
+        items = self.items.collect{|x| x.to_adqls}.join(', ')
+        "ORDER BY #{items}"
+      end
+    end
+  
+    class ConstantListSet
+      def to_adqls
+        self.items.collect{ |x| 
+          if x.is_a?(NumberType)
+            x.to_adqls
+          else
+            "\"#{x.to_adqls}\""
+          end
+        }.join(', ')
+      end
+    end
+  
+    class InclusiveSearch
+      def to_adqls
+        "#{self.expression.to_adqls} IN (#{self.set.to_adqls})"
+      end
+    end
+  
+    class ExclusiveSearch
+      def to_adqls
+        "#{self.expression.to_adqls} NOT IN (#{self.set.to_adqls})"
+      end
+    end
+  
+    class Select
+      def to_adqls
+        select = 'SELECT'
+        select << " #{self.allow.to_adqls}" if self.allow
+        select << " #{self.restrict.to_adqls}" if self.restrict
+        select << " #{self.selection_list.to_adqls}"
+        select << " #{self.in_to.to_adqls}" if self.in_to
+        select << " #{self.from.to_adqls}" if self.from
+        select << " #{self.where.to_adqls}" if self.where
+        select << " #{self.group_by.to_adqls}" if self.group_by
+        select << " #{self.having.to_adqls}" if self.having
+        select << " #{self.order_by.to_adqls}" if self.order_by
+      
+        return select
+      end
+    
+      def to_adqlx
+        adqlx = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
+            "<Select xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " +
+            "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" " +
+            "xmlns=\"http://www.ivoa.net/xml/ADQL/v0.9\" " +
+            "xmlns:reg=\"http://www.ivoa.net/xml/STC/STCregion/v1.20\">\n"
+      
+  #      adqlx << " #{self.allow.to_adqlx}" if self.allow
+  #      adqlx << " #{self.restrict.to_adqlx}" if self.restrict
+        adqlx << " #{self.selection_list.to_adqlx}"
+  #      adqlx << " #{self.in_to.to_adqlx}" if self.in_to
+        adqlx << " #{self.from.to_adqlx}" if self.from
+        adqlx << " #{self.where.to_adqlx}" if self.where
+  #      adqlx << " #{self.group_by.to_adqlx}" if self.group_by
+  #      adqlx << " #{self.having.to_adqlx}" if self.having
+  #      adqlx << " #{self.order_by.to_adqlx}" if self.order_by
+        adqlx << "</Select>"
+      
+        return adqlx
+      end
+    end
+  
+    class UserDefinedFunction
+      def to_adqls
+        params = ''
+        if self.params and self.params.size > 0
+          params = self.params.collect{|x| x.to_adqls}.join(', ')
+        end
+        "#{self.name}(#{params})"
+      end
+    end
+  
+    class JointTableQualifier
+      def to_adqls
+        self.value
+      end
+    end
+  
+    class JoinTable
+      def to_adqls
+        "#{self.qualifier.to_adqls} #{self.tables.to_adqls} ON #{self.condition.to_adqls}"
+      end
+    end
+  
+    class ArrayOfFromTable
+      def to_adqls
+        self.from_tables.collect{|x| x.to_adqls}.join(', ')
+      end
+    end
+
+    class Unit
+      def to_adqls
+        self.unit
+      end
+    end
+  end
+  
+end

data/lib/voruby/ext.rb

@@ -0,0 +1,17 @@
+class Object
+  # The hidden singleton lurks behind everyone
+   def metaclass; class << self; self; end; end
+   def meta_eval(&blk)
+     metaclass.instance_eval(&blk)
+   end
+
+   # Adds methods to a metaclass
+   def meta_def(name, &blk)
+     meta_eval { define_method(name, &blk) }
+   end
+   
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method(name, &blk) }
+  end 
+end

data/lib/voruby/loader.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+
+require 'voruby/ext'
+require 'voruby/util'

data/lib/voruby/misc/propertyfile.rb

@@ -0,0 +1,36 @@
+module VORuby
+  module Misc
+    module PropertyFile
+  
+      # A *very* simple property file reader.
+      # It can only understand files with entries
+      # of the property=value format--nothing fancy.
+      class SimpleReader
+        def initialize(file_name)
+          @file_name = file_name
+          load()
+        end
+    
+        def load
+          @properties = {}
+          File.open(@file_name) do |file|
+            file.each do |line|
+              line.lstrip!
+              if line !~ /^\#/
+                key, value = line.split(/\s*=\s*/, 2)
+                @properties[key] = value
+              end
+            end
+          end
+        end
+    
+        def [](name)
+          @properties[name]
+        end
+    
+        private :load
+      end
+  
+    end
+  end
+end