voruby 1.1.1 → 2.0.0

data/lib/voruby/adql/ext.rb

@@ -1,14 +0,0 @@
-class REXML::Element
-  def find_attribute(attr_name, ns=nil)
-    if !ns
-      return self.attributes[attr_name]
-    else
-      ns_prefix = self.namespaces.index(ns)
-      if ns_prefix
-        return self.attributes["#{ns_prefix}:#{attr_name}"]
-      else
-        return nil
-      end
-    end
-  end
-end

data/lib/voruby/adql/loader.rb

@@ -1,6 +0,0 @@
-require 'rexml/element'
-require 'cgi'
-
-require 'voruby/loader'
-require 'voruby/votables/misc'
-require 'voruby/adql/ext'

data/lib/voruby/adql/operations.rb

@@ -1,54 +0,0 @@
-# This class gives a set of operations
-module VORuby
-  module ADQL
-    
-    class Operations
-    
-      # This method returns an array of column names. For now, it reads
-      # a file from somewhere path. In the future we'll have a service
-      # that will return a xml file with similar information.
-      #[_path_]
-      # It's temporal param
-      def self.get_columns(path)
-        columns_array = [{'name'=>'All'}]
-      
-        document = REXML::Document.new(File.new(path))#This is temporal way
-        raise "Document haven't elements" if document.root == nil
-      
-        document.root.elements.each('String') do |element|
-          columns_array.push({'name'=>element.text})
-        end
-      
-        return columns_array
-      end
-    
-      # This method returns an array of column info. For now, it reads 
-      # a file from somewhere path. In the future we'll have a service
-      # that will return a xml file with similar information.
-      #[_path_]
-      # It's temporal param
-      def self.get_meta_columns(path)
-        columns_array = []
-      
-        document = REXML::Document.new(File.new(path))#This is temporal way
-        raise "Document haven't elements" if document.root == nil
-      
-        document.root.elements.each('MetaColumn') do |meta_element|      
-          node_name = REXML::XPath.first(meta_element, 'Name')
-          node_unit = REXML::XPath.first(meta_element, 'Unit')
-          node_des = REXML::XPath.first(meta_element, 'Description')
-          node_ucd = REXML::XPath.first(meta_element, 'UCD')
-        
-          columns_array.push({'name'=> node_name.text,
-                              'unit'=> node_unit.text,
-                              'description'=> node_des.text,
-                              'ucd'=>node_ucd.text})
-        end
-      
-        return columns_array
-      end
-    
-    end
-  end
-  
-end

data/lib/voruby/adql/parser.rb

@@ -1,160 +0,0 @@
-require 'voruby/adql/transforms'
-require 'rexml/document'
-
-module VORuby
-  
-  module ADQL
-    class Item
-      def self.from_xml(node)
-        #type_s = node.attributes['xsi:type']
-        type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
-        item = ObjectBuilder.get_class_for(type_s).from_xml(node)
-      end
-    end
-  
-    class Qualifier
-      def self.from_xml(node)
-        return JointTableQualifier.from_xml(node)
-      end
-    end
-  
-    class Arg
-      def self.from_xml(node)
-        #type_s = node.attributes['xsi:type']
-        type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
-        arg = ObjectBuilder.get_class_for(type_s).from_xml(node)
-      end
-    end
-  
-    class Allow
-      def self.from_xml(node)
-        return SelectionOption.from_xml(node)
-      end
-    end
-  
-    class Restrict
-      def self.from_xml(node)
-        return SelectionLimit.from_xml(node)
-      end
-    end
-  
-    class Unit
-      attr_accessor :unit
-    
-      def initialize(unit)
-        self.unit = unit
-      end
-    
-      def self.from_xml(node)
-        return Unit.new(node.text)
-      end
-    
-      def to_s
-        "{unit=#{self.unit}}"
-      end
-    end
-  
-    class Expression
-      def self.from_xml(node)
-        return ScalarExpression.from_xml(node)
-      end
-    end
-  
-    class Condition
-      def self.from_xml(node)
-        return Search.from_xml(node)
-      end
-    end
-  
-    class Pattern
-      def self.from_xml(node)
-        literal_node = REXML::XPath.first(node, 'Literal')
-        return LiteralType.from_xml(literal_node)
-      end
-    end
-  
-    class Set
-      def self.from_xml(node)
-        return InclusionSet.from_xml(node)
-      end
-    end
-  
-    class Tables
-      def self.from_xml(node)
-        return ArrayOfFromTable.from_xml(node)
-      end
-    end
-  
-    class Nature
-      def self.from_xml(node)
-        return Comparison.from_xml(node)
-      end
-    end
-  
-    class Sigma
-      def self.from_xml(node)
-        return NumberType.from_xml(node)
-      end
-    end
-  
-    class Column
-      def self.from_xml(node)
-        return ColumnReference.from_xml(node)
-      end
-    end
-  
-    class TableName
-      def self.from_xml(node)
-        return node.text
-      end
-    end
-
-    class StartComment
-      def self.from_xml(node)
-        return node.text
-      end
-    end
-  
-    class EndComment
-      def self.from_xml(node)
-        return node.text
-      end
-    end
-  
-    class OrderBy
-      def self.from_xml(node)
-        return OrderExpression.from_xml(node)
-      end
-    end
-  
-    class Name
-      def self.from_xml(node)
-        return node.text
-      end
-    end
-  
-    class Params
-      def self.from_xml(node)
-        return ScalarExpression.from_xml(node)
-      end
-    end
-  
-    class Parser
-      attr_reader :select_doc
-    
-      def initialize(src)
-        @select_doc = REXML::Document.new(src)
-      end
-    
-      def parse
-        return Select.from_xml(self.select_doc.root)
-      end
-    
-      def self.convert_to_adqls(src)
-        return Parser.new(src).parse.to_adqls
-      end
-    
-    end
-  end
-  
-end

data/lib/voruby/adql/transforms.rb

@@ -1,573 +0,0 @@
-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