om 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44a61e82e98c8010da9259bb94dd4c290f197fa7
-  data.tar.gz: 7386eda5bf6c846f1951cf23072ef94cab809deb
+  metadata.gz: 0a6fa4665be8a90aed771767f2a4cdb5d6f76b98
+  data.tar.gz: d723ee94c4ffee487c4351a5d41e5d7146082e9f
 SHA512:
-  metadata.gz: 79dc1948ff7370f23878e86b864da077efd9937805dff28fe31245757d14b149f18f269addafe84cb650beab61f1207b12ea780e5b690ab26950b68693b363a5
-  data.tar.gz: 561feab3a3d79d6f24f09ac66f059954487566cf6e12134e1b6c97768551bbb74c10389896adf85060ce4e72e355642db93382394968a07f917bbbc0f826de8d
+  metadata.gz: 501f8065eb893cb977490025716bc52b293cfeda24b4bfff788d9120be39aa7e6ecc926e67b5b2f3c802ef014439d2da60e440a5c8466eefca73a15859ad0279
+  data.tar.gz: 9b8a97c71fe6f9ccdaf4debd091c97c77c6608ad747fbcbef91a218ffe10ee6fac902a2ef2966b090a0a008b0713bb5a5c13364163d1b73150b7ff143d06ff4e

data/GETTING_STARTED.textile

@@ -4,7 +4,7 @@ OM allows you to define a "terminology" to ease translation between XML and ruby
 
 OM "terms" are ruby symbols you define (in the terminology) that map specific XML content into ruby object attributes.
 
-The API documentation at "http://hudson.projecthydra.org/job/om/Documentation/OM.html":http://hudson.projecthydra.org/job/om/Documentation/OM.html provides additional, more targeted information.  We will provide links to the API as appropriate.
+The API documentation at "http://rdoc.info/github/projecthydra/om":http://rdoc.info/github/projecthydra/om provides additional, more targeted information.  We will provide links to the API as appropriate.
 
 h4. What you will learn from this document
 
@@ -251,4 +251,4 @@ terminology.xpath_for(:organization)
 
 h2. Solrizing Documents
 
-The solrizer gem provides support for indexing XML documents into Solr based on OM Terminologies.  That process is documented in the "solrizer documentation":http://hudson.projecthydra.org/job/solrizer/Documentation/file.SOLRIZING_OM_DOCUMENTS.html
+The solrizer gem provides support for indexing XML documents into Solr based on OM Terminologies.  That process is documented in the "solrizer documentation":http://rdoc.info/github/projecthydra/solrizer

data/History.textile

@@ -1,3 +1,11 @@
+h3. 2.1.0 (unreleased)
+  support for element names with periods in them
+  support for 'type: :time'
+  
+
+h3. 2.0.0
+  Support new solr schema
+
 h3. 1.8.0
   Removed unused mods_article_terminology.xml
   Replacing :data_type with :type; deprecating :data_type

data/README.textile

@@ -8,20 +8,14 @@ OM allows you to define a “terminology” to ease translation between XML and
 
 OM “terms” are ruby symbols you define (in the terminology) that map specific XML content into ruby object attributes.
 
-h2. Tutorials
+h2. Tutorials & Reference
 
-* "Getting Started":https://github.com/projecthydra/om/blob/master/GETTING_STARTED.textile
-* "Querying Documents":https://github.com/projecthydra/om/blob/master/QUERYING_DOCUMENTS.textile
-* "Updating Documents":https://github.com/projecthydra/om/blob/master/UPDATING_DOCUMENTS.textile
-* "Getting Fancy":https://github.com/projecthydra/om/blob/master/GETTING_FANCY.textile
-
-h2. Common OM Patterns
-
-"Common OM Patterns":https://github.com/projecthydra/om/blob/master/COMMON_OM_PATTERNS.textile
+* "Tame Your XML with OM":https://github.com/projecthydra/om/wiki/Tame-your-XML-with-OM
+* "Common OM Patterns":https://github.com/projecthydra/om/blob/master/COMMON_OM_PATTERNS.textile
 
 h3. Solrizing Documents
 
-The solrizer gem provides support for indexing XML documents into Solr based on OM Terminologies.  That process is documented in the "solrizer documentation":http://hudson.projecthydra.org/job/solrizer/Documentation/file.SOLRIZING_OM_DOCUMENTS.html
+The solrizer gem provides support for indexing XML documents into Solr based on OM Terminologies.  That process is documented in the "solrizer documentation":http://rdoc.info/github/projecthydra/solrizer
 
 h2. OM in the Wild
 

data/lib/om/version.rb

@@ -1,3 +1,3 @@
 module Om
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/lib/om/xml/term.rb

@@ -1,147 +1,13 @@
+require 'om/xml/term_builder'
+
 # Special options:
 # type, index_as, attributes,
 # is_root_term, required
 #
 class OM::XML::Term
 
-
-
-
-  # Term::Builder Class Definition
-  #
-  # @example
-  #   tb2 = OM::XML::Term::Builder.new("my_term_name").path("fooPath").attributes({:lang=>"foo"}).index_as([:searchable, :facetable]).required(true).type(:text)
-  #
-  #
-  #
-  # When coding against Builders, remember that they rely on MethodMissing,
-  # so any time you call a method on the Builder that it doesn't explicitly recognize,
-  # the Builder will add your method & arguments to the it's settings and return itself.
-  class Builder
-
-    attr_accessor :name, :settings, :children, :terminology_builder
-
-    def initialize(name, terminology_builder=nil)
-      @name = name.to_sym
-      @terminology_builder = terminology_builder
-      @settings = {:required=>false, :type=>:string}
-      @children = {}
-    end
-
-    def add_child(child)
-      @children[child.name] = child
-    end
-
-    def retrieve_child(child_name)
-      child = @children.fetch(child_name, nil)
-    end
-
-    def lookup_refs(nodes_visited=[])
-      result = []
-      if @settings[:ref]
-        # Fail if we do not have terminology builder
-        if self.terminology_builder.nil?
-          raise "Cannot perform lookup_ref for the #{self.name} builder.  It doesn't have a reference to any terminology builder"
-        end
-        target = self.terminology_builder.retrieve_term_builder(*@settings[:ref])
-
-        # Fail on circular references and return an intelligible error message
-        if nodes_visited.include?(target)
-          nodes_visited << self
-          nodes_visited << target
-          trail = ""
-          nodes_visited.each_with_index do |node, z|
-            trail << node.name.inspect
-            unless z == nodes_visited.length-1
-              trail << " => "
-            end
-          end
-          raise OM::XML::Terminology::CircularReferenceError, "Circular reference in Terminology: #{trail}"
-        end
-        result << target
-        result.concat( target.lookup_refs(nodes_visited << self) )
-      end
-      return result
-    end
-
-    # If a :ref value has been set, looks up the target of that ref and merges the target's settings & children with the current builder's settings & children
-    # operates recursively, so it is possible to apply refs that in turn refer to other nodes.
-    def resolve_refs!
-      name_of_last_ref = nil
-      lookup_refs.each_with_index do |ref,z|
-        @settings = two_layer_merge(@settings, ref.settings)
-        @children.merge!(ref.children)
-        name_of_last_ref = ref.name
-      end
-      if @settings[:path].nil? && !name_of_last_ref.nil?
-        @settings[:path] = name_of_last_ref.to_s
-      end
-      @settings.delete :ref
-      return self
-    end
-
-    # Returns a new Hash that merges +downstream_hash+ with +upstream_hash+
-    # similar to calling +upstream_hash+.merge(+downstream_hash+) only it also merges
-    # any internal values that are themselves Hashes.
-    def two_layer_merge(downstream_hash, upstream_hash)
-      up = upstream_hash.dup
-      dn = downstream_hash.dup
-      up.each_pair do |setting_name, value|
-        if value.kind_of?(Hash) && downstream_hash.has_key?(setting_name)
-          dn[setting_name] = value.merge(downstream_hash[setting_name])
-          up.delete(setting_name)
-        end
-      end
-      return up.merge(dn)
-    end
-
-    # Builds a new OM::XML::Term based on the Builder object's current settings
-    # If no path has been provided, uses the Builder object's name as the term's path
-    # Recursively builds any children, appending the results as children of the Term that's being built.
-    # @param [OM::XML::Terminology] terminology that this Term is being built for
-    def build(terminology=nil)
-      self.resolve_refs!
-      if term.self.settings.has_key?(:proxy)
-        term = OM::XML::NamedTermProxy.new(self.name, self.settings[:proxy], terminology, self.settings)
-      else
-        term = OM::XML::Term.new(self.name, {}, terminology)
-
-        self.settings.each do |name, values|
-          if term.respond_to?(name.to_s+"=")
-            term.instance_variable_set("@#{name}", values)
-          end
-        end
-        @children.each_value do |child|
-          term.add_child child.build(terminology)
-        end
-        term.generate_xpath_queries!
-      end
-
-      return term
-    end
-
-    # We have to add this method so it will play nice with ruby 1.8.7
-    def type value
-      @settings[:type] = value
-      return self
-    end
-
-
-    # Any unknown method calls will add an entry to the settings hash and return the current object
-    def method_missing method, *args, &block
-      if args.length == 1
-        args = args.first
-      end
-      @settings[method] = args
-      return self
-    end
-  end
-
-  #
-  # Class Definition for Term
-  #
-
   include OM::TreeNode
+  include OM::XML::TermBuilder
 
   attr_accessor :name, :xpath, :xpath_constrained, :xpath_relative, :path, :index_as, :required, :type, :variant_of, :path, :default_content_path, :is_root_term
   attr_accessor :children, :internal_xml, :terminology
@@ -185,7 +51,7 @@ class OM::XML::Term
   # @option opts [String] :path partial xpath that points to the node.  
   # @option opts [Hash]   :attributes xml attributes to match in the selector 
   # @option opts [String] :namespace_prefix xml namespace for this node. If not provided, the default namespace set in the terminology will be used. 
-  # @option opts [Symbol] :type one of :string, :date, :integer. Defaults to :string
+  # @option opts [Symbol] :type one of :string, :date, :time :integer. Defaults to :string
   def initialize(name, opts={}, terminology=nil)
     opts = {:ancestors=>[], :children=>{}}.merge(opts)
     [:children, :ancestors,:path, :index_as, :required, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |accessor_name|
@@ -228,6 +94,8 @@ class OM::XML::Term
     case type
     when :date, :integer
       val.to_s
+    when :time
+      val.to_time.utc.iso8601 
     when :boolean
       val.to_s
     else 
@@ -242,6 +110,9 @@ class OM::XML::Term
     when :date
       #TODO use present?
       val.map { |v| !v.empty? ? Date.parse(v) : nil}
+    when :time
+      #TODO use present?
+      val.map { |v| !v.empty? ? DateTime.parse(v) : nil}
     when :integer
       #TODO use blank?
       val.map { |v| v.empty? ? nil : v.to_i}
@@ -327,20 +198,29 @@ class OM::XML::Term
         node_options << "\'#{k}\'=>\'#{v}\'" unless v == :none
       end
     end
-    builder_ref = "xml"
-    builder_method = self.path
-    if builder_method.include?(":")
-      builder_ref = "xml['#{self.path[0..path.index(":")-1]}']"
-      builder_method = self.path[path.index(":")+1..-1]
+
+    builder_ref = if self.path.include?(":")
+      "xml['#{self.path[0..path.index(":")-1]}']"
     elsif !self.namespace_prefix.nil? and self.namespace_prefix != 'oxns'
-      builder_ref = "xml['#{self.namespace_prefix}']"
-    elsif self.path.kind_of?(Hash) && self.path[:attribute]
-      builder_method = "@#{self.path[:attribute]}"
+      "xml['#{self.namespace_prefix}']"
+    else
+      "xml"
     end
-    if Nokogiri::XML::Builder.method_defined? builder_method.to_sym
-      builder_method += "_"
+
+    attribute = OM::XML.delimited_list(node_options)
+
+    builder_method = if self.path.include?(":")
+      "#{self.path[path.index(":")+1..-1]}( #{attribute} )"
+    elsif self.path.include?(".")
+      "send(:\\\"#{self.path}\\\",  #{attribute} )"
+    elsif self.path.kind_of?(Hash) && self.path[:attribute]
+      "@#{self.path[:attribute]}( #{OM::XML.delimited_list(node_options)} )"
+    elsif Nokogiri::XML::Builder.method_defined? self.path.to_sym
+      "#{self.path}_( #{OM::XML.delimited_list(node_options)} )"
+    else
+      "#{self.path}( #{OM::XML.delimited_list(node_options)} )"
     end
-    template = "#{builder_ref}.#{builder_method}( #{OM::XML.delimited_list(node_options)} )" + node_child_template
+    template = "#{builder_ref}.#{builder_method}#{node_child_template}"
     return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }
   end
 

data/lib/om/xml/term_builder.rb

@@ -0,0 +1,131 @@
+# Term::Builder Class Definition
+#
+# @example
+#   tb2 = OM::XML::Term::Builder.new("my_term_name").path("fooPath").attributes({:lang=>"foo"}).index_as([:searchable, :facetable]).required(true).type(:text)
+#
+#
+#
+# When coding against Builders, remember that they rely on MethodMissing,
+# so any time you call a method on the Builder that it doesn't explicitly recognize,
+# the Builder will add your method & arguments to the it's settings and return itself.
+#
+module OM::XML::TermBuilder
+  class Builder
+    attr_accessor :name, :settings, :children, :terminology_builder
+
+    def initialize(name, terminology_builder=nil)
+      @name = name.to_sym
+      @terminology_builder = terminology_builder
+      @settings = {:required=>false, :type=>:string}
+      @children = {}
+    end
+
+    def add_child(child)
+      @children[child.name] = child
+    end
+
+    def retrieve_child(child_name)
+      child = @children.fetch(child_name, nil)
+    end
+
+    def lookup_refs(nodes_visited=[])
+      result = []
+      if @settings[:ref]
+        # Fail if we do not have terminology builder
+        if self.terminology_builder.nil?
+          raise "Cannot perform lookup_ref for the #{self.name} builder.  It doesn't have a reference to any terminology builder"
+        end
+        target = self.terminology_builder.retrieve_term_builder(*@settings[:ref])
+
+        # Fail on circular references and return an intelligible error message
+        if nodes_visited.include?(target)
+          nodes_visited << self
+          nodes_visited << target
+          trail = ""
+          nodes_visited.each_with_index do |node, z|
+            trail << node.name.inspect
+            unless z == nodes_visited.length-1
+              trail << " => "
+            end
+          end
+          raise OM::XML::Terminology::CircularReferenceError, "Circular reference in Terminology: #{trail}"
+        end
+        result << target
+        result.concat( target.lookup_refs(nodes_visited << self) )
+      end
+      return result
+    end
+
+    # If a :ref value has been set, looks up the target of that ref and merges the target's settings & children with the current builder's settings & children
+    # operates recursively, so it is possible to apply refs that in turn refer to other nodes.
+    def resolve_refs!
+      name_of_last_ref = nil
+      lookup_refs.each_with_index do |ref,z|
+        @settings = two_layer_merge(@settings, ref.settings)
+        @children.merge!(ref.children)
+        name_of_last_ref = ref.name
+      end
+      if @settings[:path].nil? && !name_of_last_ref.nil?
+        @settings[:path] = name_of_last_ref.to_s
+      end
+      @settings.delete :ref
+      return self
+    end
+
+    # Returns a new Hash that merges +downstream_hash+ with +upstream_hash+
+    # similar to calling +upstream_hash+.merge(+downstream_hash+) only it also merges
+    # any internal values that are themselves Hashes.
+    def two_layer_merge(downstream_hash, upstream_hash)
+      up = upstream_hash.dup
+      dn = downstream_hash.dup
+      up.each_pair do |setting_name, value|
+        if value.kind_of?(Hash) && downstream_hash.has_key?(setting_name)
+          dn[setting_name] = value.merge(downstream_hash[setting_name])
+          up.delete(setting_name)
+        end
+      end
+      return up.merge(dn)
+    end
+
+    # Builds a new OM::XML::Term based on the Builder object's current settings
+    # If no path has been provided, uses the Builder object's name as the term's path
+    # Recursively builds any children, appending the results as children of the Term that's being built.
+    # @param [OM::XML::Terminology] terminology that this Term is being built for
+    def build(terminology=nil)
+      self.resolve_refs!
+      if term.self.settings.has_key?(:proxy)
+        term = OM::XML::NamedTermProxy.new(self.name, self.settings[:proxy], terminology, self.settings)
+      else
+        term = OM::XML::Term.new(self.name, {}, terminology)
+
+        self.settings.each do |name, values|
+          if term.respond_to?(name.to_s+"=")
+            term.instance_variable_set("@#{name}", values)
+          end
+        end
+        @children.each_value do |child|
+          term.add_child child.build(terminology)
+        end
+        term.generate_xpath_queries!
+      end
+
+      return term
+    end
+
+    # We have to add this method so it will play nice with ruby 1.8.7
+    def type value
+      @settings[:type] = value
+      return self
+    end
+
+
+    # Any unknown method calls will add an entry to the settings hash and return the current object
+    def method_missing method, *args, &block
+      if args.length == 1
+        args = args.first
+      end
+      @settings[method] = args
+      return self
+    end
+  end
+end

data/spec/integration/serialization_spec.rb

@@ -8,6 +8,7 @@ describe "element values" do
       set_terminology do |t|
         t.root(:path => "outer", :xmlns => nil)
         t.my_date(:type=>:date)
+        t.my_time(:type=>:time)
         t.my_int(:type=>:integer)
         t.active(:type=>:boolean)
         t.wrapper do
@@ -23,6 +24,7 @@ describe "element values" do
       ElementValueTerminology.from_xml <<-EOF
 <outer outerId="hypatia:outer" type="outer type">
   <my_date>2012-10-30</my_date>
+  <my_time>2012-10-30T12:22:33Z</my_time>
   <my_int>7</my_int>
   <active>true</active>
 </outer>
@@ -32,6 +34,9 @@ EOF
       it "should deserialize date" do
         subject.my_date.should == [Date.parse('2012-10-30')]
       end
+      it "should deserialize time" do
+        subject.my_time.should == [DateTime.parse('2012-10-30T12:22:33Z')]
+      end
       it "should deserialize ints" do
         subject.my_int.should == [7]
       end
@@ -40,11 +45,22 @@ EOF
       end
     end
     describe "Writing to xml" do
+      it "should serialize time" do
+        subject.my_time = [DateTime.parse('2011-01-30T03:45:15Z')]
+        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+         <outer outerId="hypatia:outer" type="outer type">
+           <my_date>2012-10-30</my_date>
+           <my_time>2011-01-30T03:45:15Z</my_time>
+           <my_int>7</my_int>
+           <active>true</active>
+         </outer>'
+      end
       it "should serialize date" do
         subject.my_date = [Date.parse('2012-09-22')]
         subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-09-22</my_date>
+           <my_time>2012-10-30T12:22:33Z</my_time>
            <my_int>7</my_int>
            <active>true</active>
          </outer>'
@@ -54,6 +70,7 @@ EOF
         subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-10-30</my_date>
+           <my_time>2012-10-30T12:22:33Z</my_time>
            <my_int>9</my_int>
            <active>true</active>
          </outer>'
@@ -63,6 +80,7 @@ EOF
         subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-10-30</my_date>
+           <my_time>2012-10-30T12:22:33Z</my_time>
            <my_int>7</my_int>
            <active>false</active>
          </outer>'

data/spec/unit/dynamic_node_spec.rb

@@ -8,7 +8,9 @@ describe "OM::XML::DynamicNode" do
 
         set_terminology do |t|
           t.root(:path=>"dc", :xmlns=>"http://purl.org/dc/terms/")
-          t.creator(:xmlns=>"http://www.loc.gov/mods/v3", :namespace_prefix => "dcterms")
+          t.creator( :namespace_prefix => "dcterms")
+          t.foo(:namespace_prefix => "dcterms")
+          t.date_created(:path=>'date.created', :namespace_prefix => "dcterms")
         end
 
         def self.xml_template
@@ -29,6 +31,15 @@ describe "OM::XML::DynamicNode" do
       @sample.creator = ["Foo", "Bar"]
       @sample.creator.should == ['Foo', 'Bar']
     end
+    it "should create templates for plain nodes" do
+      @sample.foo = ['in a galaxy far far away']
+      @sample.foo.should == ['in a galaxy far far away']
+    end
+
+    it "should create templates for dynamic nodes with a period in the element name" do
+      @sample.date_created = ['A long time ago']
+      @sample.date_created.should == ['A long time ago']
+    end
   end
         
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: om
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Matt Zumwalt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-28 00:00:00.000000000 Z
+date: 2013-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -229,6 +229,7 @@ files:
 - lib/om/xml/node_generator.rb
 - lib/om/xml/template_registry.rb
 - lib/om/xml/term.rb
+- lib/om/xml/term_builder.rb
 - lib/om/xml/term_value_operators.rb
 - lib/om/xml/term_xpath_generator.rb
 - lib/om/xml/terminology.rb
@@ -294,7 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: 'OM (Opinionated Metadata): A library to help you tame sprawling XML schemas