opinionated-xml 0.0.1 → 0.1.0

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/om.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+
+require 'nokogiri'
+require "facets"
+
+module OM; end
+module OM::XML; end
+
+require "om/xml"

data/lib/om/xml.rb

@@ -0,0 +1,23 @@
+require "om/xml/container"
+require "om/xml/accessors"
+require "om/xml/validation"
+require "om/xml/properties"
+require "om/xml/property_value_operators"
+
+module OM::XML
+  
+  attr_accessor :ng_xml
+  
+  # Instance Methods -- These methods will be available on instances of classes that include this module
+  
+  def self.included(klass)
+    klass.send(:include, OM::XML::Container)
+    klass.send(:include, OM::XML::Accessors)
+    klass.send(:include, OM::XML::Validation)
+    klass.send(:include, OM::XML::Properties)
+    klass.send(:include, OM::XML::PropertyValueOperators)
+
+    # klass.send(:include, OM::XML::Schema)
+  end
+  
+end

data/lib/om/xml/accessors.rb

@@ -0,0 +1,130 @@
+module OM::XML::Accessors
+  
+  module ClassMethods
+    attr_accessor :accessors
+    
+    def accessor(accessor_name, opts={})
+      @accessors ||= {}
+      insert_accessor(accessor_name, opts)
+    end
+    
+    def insert_accessor(accessor_name, accessor_opts, parent_names=[])
+      unless accessor_opts.has_key?(:relative_xpath)
+        accessor_opts[:relative_xpath] = "oxns:#{accessor_name}"
+      end
+      
+      destination = @accessors
+      parent_names.each do |parent_name|
+        destination = destination[parent_name][:children]
+      end
+      
+      destination[accessor_name] = accessor_opts
+      
+      # Recursively call insert_accessor for any children
+      if accessor_opts.has_key?(:children)
+        children_array = accessor_opts[:children].dup
+        accessor_opts[:children] = {}
+        children_array.each do |child| 
+          if child.kind_of?(Hash)
+            child_name =  child.keys.first
+            child_opts =  child.values.first
+          else
+            child_name = child
+            child_opts = {}
+          end
+          insert_accessor(child_name, child_opts, parent_names+[accessor_name] )           
+        end
+      end
+        
+    end
+    
+    # Returns the configuration info for the selected accessor.
+    # Ingores any integers in the array (ie. nodeset indices intended for use in other accessor convenience methods)
+    def accessor_info(*args)
+      # Ignore any nodeset indexes in the args array
+      keys = args.select {|x| !x.kind_of?(Integer) }
+      info = @accessors
+      keys.each do |k|
+        unless keys.index(k) == 0
+          info = info.fetch(:children, nil)
+          if info.nil?
+            debugger
+            return nil
+          end
+        end
+        
+        info = info.fetch(k, nil)
+        if info.nil?
+          return nil
+        end
+      end
+      return info
+    end
+    
+    
+    def accessor_xpath(*args)
+      keys = even_values(args)
+      indices = odd_values(args)
+      xpath = "//"
+      keys.each do |k|
+        key_index = keys.index(k)
+        accessor_info = accessor_info(*keys[0..key_index])
+        relative_path = accessor_info[:relative_xpath]
+        
+        if relative_path.kind_of?(Hash)
+          if relative_path.has_key?(:attribute)
+            relative_path = "@"+relative_path[:attribute]
+          end
+        else
+        
+          if indices[key_index]
+            add_position_predicate!(relative_path, indices[key_index])
+          end
+        
+          if accessor_info.has_key?(:default_content_path)
+            relative_path << "/"+accessor_info[:default_content_path]
+          end
+        
+        end
+        if key_index > 0
+          relative_path.insert(0, "/")
+        end
+        xpath << relative_path 
+      end
+      
+      return xpath
+    end
+    
+    def add_position_predicate!(xpath_query, array_index_value)
+      position_function = "position()=#{array_index_value + 1}"
+      
+      if xpath_query.include?("]")
+        xpath_query.insert(xpath_query.rindex("]"), " and #{position_function}")
+      else
+        xpath_query << "[#{position_function}]"
+      end
+    end
+    
+    def odd_values(array)
+      array.values_at(* array.each_index.select {|i| i.odd?})
+    end
+    def even_values(array)
+      array.values_at(* array.each_index.select {|i| i.even?})
+    end
+  end
+  
+  # Instance Methods -- These methods will be available on instances of OM classes (ie. the actual xml documents)
+  
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+  
+  # *args Variable length array of values in format [:accessor_name, index, :accessor_name ...]
+  # example: [:person, 1, :first_name]
+  # Currently, indexes must be integers.
+  def retrieve(*args)
+    xpath = self.class.accessor_xpath(*args)    
+    ng_xml.xpath(xpath, "oxns"=>"http://www.loc.gov/mods/v3")    
+  end
+  
+end

data/lib/om/xml/container.rb

@@ -0,0 +1,32 @@
+module OM::XML::Container
+  
+  attr_accessor :ng_xml
+  
+  # Class Methods -- These methods will be available on classes that include this Module 
+  
+  module ClassMethods
+    
+    # @xml Sting, File or Nokogiri::XML::Node
+    # @tmpl ActiveFedora::MetadataDatastream
+    def from_xml(xml, tmpl=self.new) # :nodoc:
+      if xml.kind_of? Nokogiri::XML::Node
+        tmpl.ng_xml = xml
+      else
+        tmpl.ng_xml = Nokogiri::XML::Document.parse(xml)
+      end
+      return tmpl
+    end
+    
+  end
+  
+  # Instance Methods -- These methods will be available on instances of classes that include this module
+  
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+    
+  def to_xml
+    ng_xml.to_xml
+  end
+  
+end

data/lib/{opinionated-xml/ox.rb → om/xml/properties.rb}

@@ -1,14 +1,11 @@
-require "open-uri"
-require "logger"
-
-module OX
+module OM::XML::Properties
+  
+  attr_accessor :ng_xml
   
-  # Class Methods -- These methods will be available on classes that include OX (ie. the OX MODS class)
+  # Class Methods -- These methods will be available on classes that include this Module 
   
   module ClassMethods
-    
-    attr_accessor :root_property_ref, :root_config, :ox_namespaces, :schema_url
-    attr_writer :schema_file
+    attr_accessor :root_property_ref, :root_config, :ox_namespaces
     attr_reader :properties
     
     def root_property( property_ref, path, namespace, opts={})
@@ -269,45 +266,6 @@ module OX
       return property_info 
     end
     
-    ##
-    # Validation Support
-    ##
-    
-    # Validate the given document against the Schema provided by the root_property for this class
-    def validate(doc)
-      schema.validate(doc).each do |error|
-          puts error.message
-      end
-    end
-    
-    # Retrieve the Nokogiri Schema for this class
-    def schema
-      @schema ||= Nokogiri::XML::Schema(schema_file.read)
-    end
-    
-    # Retrieve the schema file for this class
-    # If the schema file is not already set, it will be loaded from the schema url provided in the root_property configuration for the class
-    def schema_file
-      @schema_file ||= file_from_url(schema_url)
-    end
-    
-    # Retrieve file from a url (used by schema_file method to retrieve schema file from the schema url)
-    def file_from_url( url )
-      # parsed_url = URI.parse( url )
-      # 
-      # if parsed_url.class != URI::HTTP 
-      #   raise "Invalid URL.  Could not parse #{url} as a HTTP url."
-      # end
-      
-      begin
-        file = open( url )
-        return file
-      rescue OpenURI::HTTPError => e
-        raise "Could not retrieve file from #{url}. Error: #{e}"
-      rescue Exception => e  
-        raise "Could not retrieve file from #{url}. Error: #{e}"
-      end
-    end
     
     def delimited_list( values_array, delimiter=", ")
       result = values_array.collect{|a| a + delimiter}.to_s.chomp(delimiter)
@@ -382,17 +340,13 @@ module OX
       @logger ||= defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : Logger.new(STDOUT)
     end
     
-    private :file_from_url, :applicable_attributes
-    
-    
-    
+    private :applicable_attributes
   end
   
-  # Instance Methods -- These methods will be available on instances of OX classes (ie. the actual xml documents)
+  # Instance Methods -- These methods will be available on instances of classes that include this module
   
   def self.included(klass)
     klass.extend(ClassMethods)
-    klass.send(:include, OX::PropertyValuesHelper)
   end
   
   # Applies the property's corresponding xpath query, returning the result Nokogiri::XML::NodeSet
@@ -402,7 +356,7 @@ module OX
     if xpath_query.nil?
       result = []
     else
-      result = xpath(xpath_query, ox_namespaces)
+      result = ng_xml.xpath(xpath_query, ox_namespaces)
     end
     
     return result
@@ -412,11 +366,7 @@ module OX
   # Returns a hash combining the current documents namespaces (provided by nokogiri) and any namespaces that have been set up by your class definiton.
   # Most importantly, this matches the 'oxns' namespace to the namespace you provided in your root property config
   def ox_namespaces
-    @ox_namespaces ||= namespaces.merge(self.class.ox_namespaces)
-  end
-  
-  def validate
-    self.class.validate(self)
+    @ox_namespaces ||= ng_xml.namespaces.merge(self.class.ox_namespaces)
   end
   
   def xpath_query_for( property_ref, query_opts={}, opts={} )
@@ -426,5 +376,5 @@ module OX
   def property_info_for(property_ref)
     self.class.property_info_for(property_ref)
   end
-
+  
 end

data/lib/om/xml/property_value_operators.rb

@@ -0,0 +1,111 @@
+require "open-uri"
+require "logger"
+
+class OM::XML::ParentNodeNotFoundError < RuntimeError; end
+module OM::XML::PropertyValueOperators
+  
+  def property_values(lookup_args)
+    result = []
+    lookup(lookup_args).each {|node| result << node.text }
+    return result
+  end
+  
+  def property_values_append(opts={})
+    parent_select = Array( opts[:parent_select] )
+    child_index = opts[:child_index]
+    template = opts[:template]
+    new_values = Array( opts[:values] )
+    
+    # If template is a string, use it as the template, otherwise use it as arguments to builder_template
+    unless template.instance_of?(String)
+      template_args = Array(template)
+      if template_args.last.kind_of?(Hash)
+        template_opts = template_args.delete_at(template_args.length - 1)
+      else
+        template_opts = {}
+      end
+      template = self.class.builder_template( template_args, template_opts )
+    end    
+    
+    parent_nodeset = lookup(parent_select[0], parent_select[1])
+    parent_node = node_from_set(parent_nodeset, child_index)
+    
+    if parent_node.nil?
+      raise OX::ParentNodeNotFoundError, "Failed to find a parent node to insert values into based on :parent_select #{parent_select.inspect} with :child_index #{child_index.inspect}"
+    end
+    
+    builder = Nokogiri::XML::Builder.with(parent_node) do |xml|
+      new_values.each do |builder_new_value|
+        builder_arg = eval('"'+ template + '"') # this inserts builder_new_value into the builder template
+        eval(builder_arg)
+      end
+    end
+        
+    # Nokogiri::XML::Node.new(builder.to_xml, foo)
+    
+    return parent_node
+    
+  end
+  
+  def property_value_update(opts={})
+    parent_select = Array( opts[:parent_select] )
+    child_index = opts[:child_index]
+    template = opts[:template]
+    new_value = opts[:value]
+    xpath_select = opts[:select]
+    
+    if !xpath_select.nil?
+      node = lookup(xpath_select, nil).first
+    else
+      parent_nodeset = lookup(parent_select[0], parent_select[1])
+      node = node_from_set(parent_nodeset, child_index)
+    end
+    
+    node.content = new_value
+    
+  end
+  
+  # def property_value_set(property_ref, query_opts, node_index, new_value)
+  # end
+  
+  def property_value_delete(opts={})
+    parent_select = Array( opts[:parent_select] )
+    parent_index = opts[:parent_index]
+    child_index = opts[:child_index]
+    xpath_select = opts[:select]
+    
+    if !xpath_select.nil?
+      node = lookup(xpath_select, nil).first
+    else
+      parent_nodeset = lookup(parent_select, parent_select)
+      # parent_nodeset = lookup(parent_select[0])
+      
+      if parent_index.nil?
+        node = node_from_set(parent_nodeset, child_index)
+      else
+        parent = node_from_set(parent_nodeset, parent_index)
+        # this next line is a hack around the fact that element_children() sometimes doesn't work.
+        node = node_from_set(parent.xpath("*"), child_index)
+      end
+    end
+    
+    node.remove
+  end
+   
+  
+  # Allows you to provide an array index _or_ a symbol representing the function to call on the nodeset in order to retrieve the node.
+  def node_from_set(nodeset, index)
+    if index.kind_of?(Integer)
+      node = nodeset[index]
+    elsif index.kind_of?(Symbol) && nodeset.respond_to?(index) 
+      node = nodeset.send(index)
+    else
+      raise "Could not retrieve node using index #{index}."
+    end
+    
+    return node
+  end
+  
+  private :node_from_set
+  
+end

data/lib/om/xml/validation.rb

@@ -0,0 +1,63 @@
+module OM::XML::Validation
+    
+  # Class Methods -- These methods will be available on classes that include this Module 
+  
+  module ClassMethods
+    attr_accessor :schema_url
+    attr_writer :schema_file
+    
+    ##
+    # Validation Support
+    ##
+    
+    # Validate the given document against the Schema provided by the root_property for this class
+    def validate(doc)
+      schema.validate(doc).each do |error|
+          puts error.message
+      end
+    end
+    
+    # Retrieve the Nokogiri Schema for this class
+    def schema
+      @schema ||= Nokogiri::XML::Schema(schema_file.read)
+    end
+    
+    # Retrieve the schema file for this class
+    # If the schema file is not already set, it will be loaded from the schema url provided in the root_property configuration for the class
+    def schema_file
+      @schema_file ||= file_from_url(schema_url)
+    end
+    
+    # Retrieve file from a url (used by schema_file method to retrieve schema file from the schema url)
+    def file_from_url( url )
+      # parsed_url = URI.parse( url )
+      # 
+      # if parsed_url.class != URI::HTTP 
+      #   raise "Invalid URL.  Could not parse #{url} as a HTTP url."
+      # end
+      
+      begin
+        file = open( url )
+        return file
+      rescue OpenURI::HTTPError => e
+        raise "Could not retrieve file from #{url}. Error: #{e}"
+      rescue Exception => e  
+        raise "Could not retrieve file from #{url}. Error: #{e}"
+      end
+    end
+    
+    private :file_from_url
+    
+  end
+  
+  # Instance Methods -- These methods will be available on instances of classes that include this module
+  
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+  
+  def validate
+    self.class.validate(self)
+  end
+    
+end