voruby2-preview 1.0.0

data/lib/symphony.rb

@@ -0,0 +1 @@
+require 'symphony/symphony'

data/lib/symphony/symphony.rb

@@ -0,0 +1,247 @@
+class HomogeneousArray < Array
+  attr_reader :klass
+  
+  def initialize(of_class, *spec)
+    of_class = [of_class] if !of_class.is_a?(Array)
+    @klass = of_class
+    
+    spec.flatten.each { |obj| raise_type_error(obj) if !self.acceptable_type?(obj) }
+ 
+    super(*spec)
+  end
+  
+  def raise_type_error(obj)
+    raise TypeError, "wrong argument type of #{obj.class} #{obj.inspect} (expected #{self.klass})"
+  end
+  
+  def []=(*assign_spec)
+    raise_type_error(assign_spec.last) if !self.acceptable_type?(assign_spec.last)
+    super(*assign_spec)
+  end
+  
+  def <<(obj)
+    raise_type_error(obj) if !self.acceptable_type?(obj)
+    super(obj)
+  end
+  
+  def replace(array_of_obj)
+    array_of_obj.each { |obj| raise_type_error(obj) if !self.acceptable_type?(obj) }
+    super(array_of_obj)
+  end
+  
+  def ==(ary)
+    return false if !ary.respond_to?(:size)
+    return false if self.size != ary.size
+    
+    self.each_with_index do |el, i|
+      return false if !(el == ary[i])
+    end
+    
+    return true
+  end
+  
+  protected
+  def acceptable_type?(obj)
+    self.klass.find_all{ |k| obj.is_a?(k) }.size > 0
+  end
+end
+
+class MinimumSizedHomogeneousArray < HomogeneousArray
+  attr_reader :min_size
+  
+  def initialize(min_size, of_class, *spec)
+    raise_size_error(spec.last.size, min_size) if spec.last.size < min_size
+    
+    super(of_class, *spec)
+    @min_size = min_size
+  end
+  
+  def delete(obj)
+    raise_size_error(self.size - 1, self.min_size) if self.size - 1 < self.min_size
+    super(obj)
+  end
+  
+  def delete_at(index)
+    raise_size_error(self.size - 1, self.min_size) if self.size - 1 < self.min_size
+    super(index)
+  end
+  
+  private
+  def raise_size_error(size, min_size=nil)
+    raise ArgumentError, "array of size #{size} can not shrink below a capacity of #{min_size || self.min_size}"
+  end
+end
+
+class AtLeastTwoArray < MinimumSizedHomogeneousArray
+  def initialize(of_class, *spec)
+    super(2, of_class, *spec)
+  end
+end
+
+class FixedSizedHomogeneousArray < HomogeneousArray
+  attr_reader :capacity
+  
+  def initialize(capacity, of_class, *spec)
+    raise_capacity_error(spec.last.size, capacity) if spec.last.size != capacity
+    
+    super(of_class, *spec)
+    @capacity = capacity
+  end
+  
+  def []=(*assign_spec)
+    super(*assign_spec)
+    raise_capacity_error(self.size) if self.size != self.capacity
+  end
+  
+  def <<(obj)
+    raise_capacity_error(self.size + 1) if self.size + 1 != self.capacity
+    super(obj)
+  end
+  
+  def replace(array_of_obj)
+    aise_capacity_error(self.size + array_of_obj.size) if self.size + array_of_obj.size != self.capacity
+    super(array_of_obj)
+  end
+  
+  def delete(obj); end
+  def delete_at(index); end
+  
+  private
+  def raise_capacity_error(size, capacity=nil)
+    raise ArgumentError, "array incorrect size of #{size} (expected #{capacity || self.capacity})"
+  end
+end
+
+class Array
+  def to_homogeneous(of_type)
+    harray = HomogeneousArray.new(of_type)
+    self.each{ |item| harray << item }
+    harray
+  end
+end
+
+module Symphony
+  module ClassMethods
+    DEFAULT_OPTIONS = {
+      :of => Object,
+      :optional => false,
+      :nillable => false
+    }
+    
+    attr_reader :symphony_definitions
+    
+    def initialize_symphony_definitions
+      @symphony_definitions ||= []
+    end
+    
+    def has(multiplicity, name, options={})
+      initialize_symphony_definitions()
+      
+      raise ArgumentError, "multiplicity must be an integer or a symbol (i.e. :many)" if !multiplicity.is_a?(Integer) and !multiplicity.is_a?(Symbol)
+      
+      options = DEFAULT_OPTIONS.merge(options)
+      defn = {:multiplicity => multiplicity, :method_name => name.to_sym, :options => options}
+      @symphony_definitions << defn
+    
+      create_methods(defn)
+    end
+    
+    def has_one(name, options)
+      has 1, name, options
+    end
+    
+    def has_many(name, options)
+      has :many, name, options
+    end
+    
+    def create_methods(defn)
+      # reader
+      class_eval "
+        def #{defn[:method_name]}
+          puts '#{defn[:method_name]}:' + self.class.symphony_definitions.find{ |d| d[:method_name] == :#{defn[:method_name]} }.inspect
+          @#{defn[:method_name]} || self.class.symphony_definitions.find{ |d| d[:method_name] == :#{defn[:method_name]} }[:options][:default]
+        end
+      "
+
+      # writer
+      check_method = (defn[:multiplicity] == :many or defn[:multiplicity] > 1) ? 'check_made_of_only' : 'check_type'
+      class_eval "
+        def #{defn[:method_name]}=(obj)
+          raise TypeError, \"#{defn[:method_name]} is not nillable\" if !#{defn[:options][:nillable]} and obj == nil
+          #{check_method}(#{defn[:options][:of]}, obj) if obj != nil or !#{defn[:options][:nillable]}
+
+          @#{defn[:method_name]} = obj
+        end
+      "
+    end
+    
+  end
+  
+  class << self
+    def included(klass)
+      super
+      klass.__send__(:extend, ClassMethods)
+    end
+  end
+end
+
+class Symphony::Base
+  include Symphony
+  
+  def initialize(args={})
+    self.class.initialize_symphony_definitions()
+    validate(args)
+    assign_initial_values(args)
+  end
+  
+  def ==(obj)
+    return false if !obj.is_a?(self.class)
+    
+    self.class.symphony_definitions.each do |defn|
+      return false if self.send(defn[:method_name]) != obj.send(defn[:method_name])
+    end
+    
+    return true
+  end
+  
+  private
+  
+  def check_type(klass, o)
+    raise TypeError, "wrong argument type of #{o.class} #{o.inspect} (expected #{klass})" if !o.is_a?(klass)
+  end
+  
+  def check_made_of_only(klass, list)
+    list.each { |o| check_type(klass, o) }
+  end
+  
+  def validate(args)
+    self.class.symphony_definitions.each do |defn|
+      raise ArgumentError, "#{defn[:method_name]} is missing but is required" if !defn[:options][:optional] and !args.has_key?(defn[:method_name])
+      raise TypeError, "#{defn[:method_name]} is not nillable" if args.has_key?(defn[:method_name]) and args[defn[:method_name]] == nil and !defn[:options][:nillable]
+      
+      values = args[defn[:method_name]]
+      values = values.is_a?(Array) ? values : [values]
+      
+      # if defn[:multiplicity].is_a?(Integer)
+      #   raise ArgumentError, "wrong number of arguments for #{defn[:method_name]} (#{values.size} for #{defn[:multiplicity]})" if values.size != defn[:multiplicity]
+      # elsif defn[:multiplicity].is_a?(Symbol)
+      #   raise ArgumentError, "don't know what a multiplicity of #{defn[:multiplicity]} means" if defn[:multiplicity] != :many
+      # end
+      
+      raise ArgumentError, "don't know what a multiplicity of #{defn[:multiplicity]} means" if !defn[:multiplicity].is_a?(Integer) and defn[:multiplicity] != :many
+    end
+  end
+  
+  def assign_initial_values(args)
+    self.class.symphony_definitions.each do |defn|
+      values = if !args[defn[:method_name]].is_a?(HomogeneousArray) and args[defn[:method_name]].is_a?(Array)
+        args[defn[:method_name]].to_homogeneous(defn[:options][:of])
+      else
+        check_type(defn[:options][:of], args[defn[:method_name]]) if !defn[:options][:optional] and (!defn[:options][:nillable] and args[defn[:method_name]] != nil)
+        args[defn[:method_name]]
+      end
+      
+      send("#{defn[:method_name]}=", values)
+    end
+  end
+end

data/lib/voruby.rb

@@ -0,0 +1,186 @@
+module VORuby
+  begin
+    require 'rfits'
+  rescue LoadError
+    @@rfits_available = false
+  else
+    @@rfits_available = true
+  end
+  
+  # Reports whether the RFits[http://rubyforge.org/projects/rfits]
+  # FITS reading/writing package is installed or not.
+  def self.rfits?
+    @@rfits_available
+  end
+  
+  # An array-like class that uses an XML::Node to back itself.
+  # Designed to work in concert with a VOTable::Base object
+  # or at least something with a _node_ method and a _new_
+  # method that takes a XML::Node object.
+  # Mixes in Enumerable for added functionality.
+  class HomogeneousNodeList
+    include Enumerable
+    
+    # The XPath expression to the child node(s) of the list.
+    attr_reader :xpath
+    
+    # The class of the sub-objects allowed in the list.
+    attr_reader :klass
+    
+    # Create a new node list.
+    # _node_ is the XML::Node that all operation will be mirrored on.
+    # _xpath_ is the the XPath expression used to retrieve the
+    # children of _node_ that make up the list.
+    # _klass_ is the class of those children.
+    #
+    #  vot = VOTable.new({
+    #   :version => '1.1',
+    #   :id => 'my_test_votable',
+    #   :description => Description.new,
+    #   :definitions => Definitions.new,
+    #   :coordinate_systems => [Coosys.new],
+    #   :params => [Param.new],
+    #   :infos => [Info.new],
+    #   :resources => [Resource.new]
+    #  })
+    #  node_list = HomogeneousNodeList.new(vot, 'COOSYS', VOTable::V_1::Coosys)
+    def initialize(node, xpath, klass)
+      @node = node.is_a?(XML::Node) ? node : node.node
+      @xpath = xpath
+      @klass = klass
+    end
+    
+    # Iterate through each member of the list.
+    #   node_list.each do |obj|
+    #     puts obj
+    #   end
+    def each
+      @node.find(*self.xpath).each do |e|
+        yield klass.new(e)
+      end
+    end
+    
+    # Replace the current member of the list with
+    # those specified.
+    #   node_list.replace(Coosys.new, Coosys.new, Coosys.new)
+    def replace(*args)
+      self.clear
+      args.flatten.each do |a|
+        self << a
+      end
+    end
+    
+    # Append a new member to the end of the list.
+    #   node_list << Coosys.new
+    def <<(obj)
+      raise "Expected item of type #{@klass} but was #{obj.class}" if !obj.is_a?(@klass)
+      
+      obj.node.name = self.xpath.first.split(':').last if self.xpath.is_a?(Array)
+      
+      last_in_list = @node.find_first("*[local-name()='#{obj.node.name}'][last()]")
+      last_in_list ? last_in_list.next = obj.node : @node.child_add(obj.node)
+    end
+    
+    # Prepend a new member to the beginning of the list.
+    #  node_list.prepend(Coosys.new)
+    def prepend(obj)
+      raise "Expected item of type #{@klass} but was #{obj.class}" if !obj.is_a?(@klass)
+      
+      obj.node.name = self.xpath.first.split(':').last if self.xpath.is_a?(Array)
+      
+      first_in_list = @node.find_first("*[local-name()='#{obj.node.name}'][1]")
+      first_in_list ? first_in_list.prev = obj.node : @node.child_add(obj.node)
+    end
+    
+    # Retrieve the ith member of the list. i may be less than one.
+    #  coosys2 = node_list[1]
+    def [](i)
+      i = self.length + i if i < 0 # support negative indices
+      
+      expr = self.xpath.is_a?(Array) ?
+         ["#{self.xpath.first}[#{i+1}]", self.xpath.last] :
+         ["#{self.xpath}[#{i+1}]"]
+      
+      klass.new(@node.find_first(*expr))
+    end
+    
+    # Set the ith member of the list.  Setting a member to a location
+    # longer than the current list, appends that member to the end
+    # of the list.  In other words, there are no nil members allowed.
+    #   node_list[1] = Coosys.new
+    def []=(i, obj)
+      raise "Expected item of type #{@klass} but was #{obj.class}" if !obj.is_a?(@klass)
+      
+      i = self.length + i if i < 0 # support negative indices
+      
+      expr = self.xpath.is_a?(Array) ?
+        ["#{self.xpath.first}[#{i+1}]", self.xpath.last] :
+        ["#{self.xpath}[#{i+1}]"]
+      
+      obj.node.name = self.xpath.first.split(':').last if self.xpath.is_a?(Array)
+      
+      this_node = @node.find_first(*expr)
+      this_node ? this_node.replace_with(obj.node) : self << obj
+    end
+    
+    # Delete the ith member in the list.
+    #   node_list.delete_at(1)  # delete the second coordinate system
+    def delete_at(i)
+      expr = self.xpath.is_a?(Array) ?
+        ["#{self.xpath.first}[#{i+1}]", self.xpath.last] :
+        ["#{self.xpath}[#{i+1}]"]
+      @node.find_first(*expr).remove!
+    end
+    
+    # Clear the list of all its members.
+    #   node_list.clear
+    def clear
+      @node.find(*self.xpath).each do |el|
+        el.remove!
+      end
+    end
+    
+    # Pick the first member of the list.
+    #   coosys1 = node_list.first
+    def first
+      expr = self.xpath.is_a?(Array) ?
+        ["#{self.xpath.first}[1]", self.xpath.last] :
+        ["#{self.xpath}[1]"]
+      klass.new(@node.find_first(*expr))
+    end
+    
+    # Pick the last member of the list
+    #   coosys_last = node_list.last
+    def last
+      expr = self.xpath.is_a?(Array) ?
+        ["#{self.xpath.first}[last()]", self.xpath.last] :
+        ["#{self.xpath}[last()]"]
+      klass.new(@node.find_first(*expr))
+    end
+    
+    # Find the number of members in the list.
+    #   node_list.length  # => 4
+    def length
+      @node.find(*self.xpath).length
+    end
+    
+    # Alias for #length.
+    def size
+      length
+    end
+    
+    # Two lists are equivalent if their lengths are equal
+    # and the members of the lists are equal to each other
+    # (and in the same order).
+    def ==(obj)
+      return false if self.length != obj.length
+      
+      self.each_with_index do |item, i|
+        return false if obj[i] != item
+      end
+      
+      true
+    end
+  end
+  
+end

data/lib/voruby/misc/libxml_ext.rb

@@ -0,0 +1,121 @@
+class XML::Node
+   def replace_with(other)
+     self.next = other
+     remove!
+   end
+end
+
+module XML
+  module Object
+    # A (essentially abstract) class that can be used in the
+    # creation of domain objects backed by XML documents.
+    class Base
+      # The XML::Node used to store the state of the domain object.
+      attr_reader :node
+  
+      # Create a domain object from an XML file on disk.
+      # _filename_:: the name of the file to parse
+      #
+      #  votable = VOTable::V1_1::VOTable.from_file('myvotable.xml')
+      def self.from_file(filename)
+        self.new(XML::Document.file(filename))
+      end
+      
+      # Get the name of the element when serialized
+      # to XML that the object in question will take on.
+      # By default, the name of the class.
+      def self.element_name
+        self.to_s
+      end
+  
+      # Create a new domain object from a number of source formats.
+      # _xml_ may be one of
+      # * a string
+      # * an IO object (i.e. a File object)
+      # * a LibXML Document (i.e. XML::Document)
+      # * a LibXML Node (i.e. XML::Node)
+      # * nothing (to create a blank object)
+      # * a hash where the keys of the hash represent the method to call
+      #
+      # Assuming VOTable::V1_1::VOTable is a subclass of Base...
+      #
+      #  votable = VOTable::V1_1::VOTable.new('<VOTABLE version="1.1"/>')
+      #  votable = VOTable::V1_1::VOTable.new(File.new('myvotable.xml'))  # you could also use #from_file
+      #  votable = VOTable::V1_1::VOTable.new(XML::Document.file('myvotable.xml'))
+      #  votable = VOTable::V1_1::VOTable.new(XML::Node.new('VOTABLE'))
+      #  votable = VOTable::V1_1::VOTable.new()
+      #  votable = VOTable::V1_1::VOTable.new(:version => '1.1')
+      def initialize(xml=nil)
+        @node = case xml
+          when String
+            parser = XML::Parser.new
+            parser.string = xml
+            parser.parse.root
+          when IO
+            parser = XML::Parser.new
+            parser.io = xml
+            parser.parse.root
+          when XML::Document
+            xml.root
+          when XML::Node
+            xml
+          when NilClass
+            doc = XML::Document.new
+            doc.root = XML::Node.new(self.class.element_name)
+            doc.root
+          when Hash
+            doc = XML::Document.new
+            doc.root = XML::Node.new(self.class.element_name)
+            doc.root
+          else
+            raise "XML must be a XML::Document, XML::Node, String or IO object"
+          end
+      
+          initialize_members(xml) if xml.is_a?(Hash)
+      end
+  
+      # Serialize the domain object to XML.
+      def to_s
+        self.node.to_s
+      end
+      
+      # Equality among domain objects.
+      # Always returns false, override to get less brain-dead result.
+      def ==(obj)
+        false
+      end
+      
+      protected
+  
+      # Retrieve the domain object that corresponds to
+      # the specified class.
+      def get_element(klass)
+        subnode = self.node.find_first(self.xpath_for(klass))
+        subnode ? klass.new(subnode) : nil
+      end
+  
+      # Set the specified domain object that corresponds to
+      # the specified class.
+      def set_element(klass, e)
+        descr_node = self.node.find_first(xpath_for(klass))
+        descr_node ? descr_node.replace_with(e.node) : @node.child_add(e.node)
+      end
+      
+      # Determine the xpath corresponding to the specified class.
+      # By default, this is just the name of the class.
+      #   obj.xpath_for(Field)  # => 'Field'
+      def xpath_for(klass)
+        klass.to_s
+      end
+      
+      private
+      
+      def initialize_members(args)
+        args.each do |name, value|
+          send("#{name}=", value)
+        end
+      end
+    end
+    
+  end
+end