voruby 1.1.1 → 2.0.0

data/lib/misc/propertyfile.rb

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

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.copy(true))
+    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