om 1.0.2 → 1.1.0

data/History.textile

@@ -1,3 +1,17 @@
+1.1.0
+
+HYDRA-371: Provide a way to specify a term that points to nodes where an attribute is not set
+
+  Add support for this syntax in Terminologies, where an attribute value can be :none.  When an attribute's value is set to :none, a not() predicate is used in the resulting xpath 
+
+    t.computing_id(:path=>"namePart", :attributes=>{:type=>:none}) 
+    
+    will result in an xpath that looks like:
+    
+    //namePart[not(@type)] 
+
+namePart[not(@type)]
+
 1.0.1
 
 HYDRA-329: Allow for NamedTermProxies at root of Terminology

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.1.0

data/lib/om/samples/mods_article.rb

@@ -10,7 +10,10 @@ class OM::Samples::ModsArticle
         t.language(:path=>{:attribute=>"lang"})
       } 
       t.abstract     
-      t.topic_tag(:path=>"subject", :default_content_path=>"topic")           
+      t.subject{
+        t.topic
+      }
+      t.topic_tag(:ref=>[:subject, :topic])           
       # This is a mods:name.  The underscore is purely to avoid namespace conflicts.
       t.name_ {
         # this is a namepart
@@ -24,6 +27,7 @@ class OM::Samples::ModsArticle
         t.last_name(:path=>"namePart", :attributes=>{:type=>"family"})
         t.first_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
         t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+        t.name_content(:path=>"text()")
       }
       # lookup :person, :first_name        
       t.person(:ref=>:name, :attributes=>{:type=>"personal"})
@@ -61,4 +65,4 @@ class OM::Samples::ModsArticle
     # renamed family_name => last_name
     # start_page & end_page now accessible as [:journal, :issue, :pages, :start] (etc.)
 
-end
+end

data/lib/om/xml.rb

@@ -1,9 +1,5 @@
 require "om/xml/container"
-require "om/xml/accessors"
 require "om/xml/validation"
-require "om/xml/properties"
-require "om/xml/property_value_operators"
-require "om/xml/generator"
 
 require "om/xml/terminology"
 require "om/xml/term"
@@ -49,13 +45,8 @@ module OM::XML
   
   def self.included(klass)
     klass.extend(ClassMethods)
-  
     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::Generator)
   end
   
   

data/lib/om/xml/node_generator.rb

@@ -1,6 +1,13 @@
 module OM::XML::NodeGenerator
     
   # Module Methods -- These methods can be called directly on the Module itself
+  # @param OM::XML::Term term The term to generate a node based on
+  # @param String builder_new_value The new value to insert into the generated node
+  # @returns Nokogiri::XML::Document
+  #
+  # Ex.
+  # term = t.retrieve_term(:person, :first_name)
+  # OM::XML::NodeGenerator.generate(term, "John")
   def self.generate(term, builder_new_value, opts={})
     template = term.xml_builder_template(opts)
     builder_call_body = eval('"' + template + '"')

data/lib/om/xml/term.rb

@@ -129,6 +129,9 @@ class OM::XML::Term
   
   include OM::TreeNode
   
+  # h2. Namespaces
+  # By default, OM assumes that all terms in a Terminology have the namespace set in the root of the document.  If you want to set a different namespace for a Term, pass :namespasce_prefix into its initializer (or call .namespace_prefix= on its builder)
+  # If a node has _no_ namespace, you must explicitly set namespace_prefix to nil.
   def initialize(name, opts={})
     opts = {:namespace_prefix=>"oxns", :ancestors=>[], :children=>{}}.merge(opts)
     [:children, :ancestors,:path, :index_as, :required, :type, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |accessor_name|

data/lib/om/xml/term_value_operators.rb

@@ -7,7 +7,10 @@ module OM::XML::TermValueOperators
   # Retrieves all of the nodes from the current document that match +term_pointer+ and returns an array of their values
   def term_values(*term_pointer)
     result = []
-    find_by_terms(*term_pointer).each {|node| result << node.text }
+    xpath = self.class.terminology.xpath_with_indexes(*term_pointer)
+    #if value is on line by itself sometimes does not trim leading and trailing whitespace for a text node so will detect and fix it
+    trim_text = !xpath.nil? && !xpath.index("text()").nil?
+    find_by_terms(*term_pointer).each {|node| result << (trim_text ? node.text.strip : node.text) }
     # find_by_terms(*OM.destringify(term_pointer)).each {|node| result << node.text }
     return result
   end
@@ -128,6 +131,9 @@ module OM::XML::TermValueOperators
       template_args = OM.pointers_to_flat_array(template_args,false)
       template = self.class.terminology.xml_builder_template( *template_args )
     end
+
+    #if there is an xpath element pointing to text() need to change to just 'text' so it references the text method for the parent node
+    template.gsub!(/text\(\)/, 'text')
     
     builder = Nokogiri::XML::Builder.with(parent_node) do |xml|
       new_values.each do |builder_new_value|
@@ -240,4 +246,4 @@ module OM::XML::TermValueOperators
   
   private :node_from_set
   
-end
+end

data/lib/om/xml/term_xpath_generator.rb

@@ -1,32 +1,50 @@
 module OM::XML::TermXpathGenerator
   
-  def self.generate_relative_xpath(mapper)
+  # Generate relative xpath for a term
+  # @param [OM::XML::Term] term that you want to generate relative xpath for
+  #
+  # In most cases, the resulting xpath will be the Term's path with the appropriate namespace appended to it.
+  # If the Term specifies any attributes, 
+  # Special Case: attribute Terms
+  # If the Term's path is set to {:attribute=>attr_name}, the resulting xpath will points to a node attribute named attr_name 
+  # ie. a path fo {:attribute=>"lang"} will result in a relative xpath of "@lang"
+  # Special Case: xpath functions
+  # If the Term's path variable is text(), it will be treated as an xpath function (no namespace) and turned into "text()[normalize-space(.)]"
+  def self.generate_relative_xpath(term)
     template = ""
     predicates = []
     
-    if mapper.namespace_prefix.nil?
+    if term.namespace_prefix.nil?
       complete_prefix = ""
     else
-      complete_prefix = mapper.namespace_prefix + ":"
+      complete_prefix = term.namespace_prefix + ":"
     end
     
-    if mapper.path.kind_of?(Hash)
-      if mapper.path.has_key?(:attribute)
-        base_path = "@"+mapper.path[:attribute]
+    if term.path.kind_of?(Hash)
+      if term.path.has_key?(:attribute)
+        base_path = "@"+term.path[:attribute]
       else
-        raise "#{mapper.path} is an invalid path for an OM::XML::Term.  You should provide either a string or {:attributes=>XXX}"
+        raise "#{term.path} is an invalid path for an OM::XML::Term.  You should provide either a string or {:attributes=>XXX}"
       end
     else
-      unless mapper.namespace_prefix.nil?
-        template << complete_prefix
+      if term.path == "text()"
+        base_path = "#{term.path}[normalize-space(.)]"
+      else
+        unless term.namespace_prefix.nil?
+          template << complete_prefix
+        end
+        base_path = term.path
       end
-      base_path = mapper.path
     end
     template << base_path
     
-    unless mapper.attributes.nil?
-      mapper.attributes.each_pair do |attr_name, attr_value|
-        predicates << "@#{attr_name}=\"#{attr_value}\""
+    unless term.attributes.nil?
+      term.attributes.each_pair do |attr_name, attr_value|
+        if attr_value == :none
+          predicates << "not(@#{attr_name})"
+        else
+          predicates << "@#{attr_name}=\"#{attr_value}\""
+        end
       end
     end
     
@@ -37,29 +55,33 @@ module OM::XML::TermXpathGenerator
     return template
   end
   
-  def self.generate_absolute_xpath(mapper)
-    relative = generate_relative_xpath(mapper)
-    if mapper.parent.nil?
+  # Generate absolute xpath for a Term
+  # @param [OM::XML::Term] term that you want to generate absolute xpath for
+  #
+  # Absolute xpaths always begin with "//".  They are generated by relying on the Term's relative xpath and the absolute xpath of its parent node.
+  def self.generate_absolute_xpath(term)
+    relative = generate_relative_xpath(term)
+    if term.parent.nil?
       return "//#{relative}"
     else
-      return mapper.parent.xpath_absolute + "/" + relative
+      return term.parent.xpath_absolute + "/" + relative
     end
   end
   
-  def self.generate_constrained_xpath(mapper)
-    if mapper.namespace_prefix.nil?
+  def self.generate_constrained_xpath(term)
+    if term.namespace_prefix.nil?
       complete_prefix = ""
     else
-      complete_prefix = mapper.namespace_prefix + ":"
+      complete_prefix = term.namespace_prefix + ":"
     end
     
-    absolute = generate_absolute_xpath(mapper)
+    absolute = generate_absolute_xpath(term)
     constraint_predicates = []
     
     arguments_for_contains_function = []
 
-    if !mapper.default_content_path.nil?
-      arguments_for_contains_function << "#{complete_prefix}#{mapper.default_content_path}"
+    if !term.default_content_path.nil?
+      arguments_for_contains_function << "#{complete_prefix}#{term.default_content_path}"
     end
       
     # If no subelements have been specified to search within, set contains function to search within the current node
@@ -75,20 +97,25 @@ module OM::XML::TermXpathGenerator
     return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }.gsub('"', '\"')
   end
   
-  def self.generate_xpath(mapper, type)
+  # Generate an xpath of the chosen +type+ for the given Term.
+  # @param [OM::XML::Term] term that you want to generate relative xpath for
+  # @param [Symbol] the type of xpath to generate, :relative, :abolute, or :constrained
+  def self.generate_xpath(term, type)
     case type
     when :relative
-      self.generate_relative_xpath(mapper)
+      self.generate_relative_xpath(term)
     when :absolute
-      self.generate_absolute_xpath(mapper)
+      self.generate_absolute_xpath(term)
     when :constrained
-      self.generate_constrained_xpath(mapper)
+      self.generate_constrained_xpath(term)
     end
   end
   
   # Use the given +terminology+ to generate an xpath with (optional) node indexes for each of the term pointers.
   # Ex.  OM::XML::TermXpathGenerator.xpath_with_indexes(my_terminology, {:conference=>0}, {:role=>1}, :text ) 
   #      will yield an xpath similar to this: '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
+  # @param [OM::XML::Terminology] terminology to generate xpath based on
+  # @param [String -- OM term pointer] pointers identifying the node to generate xpath for
   def self.generate_xpath_with_indexes(terminology, *pointers)
     if pointers.first.nil?
       root_term = terminology.root_terms.first
@@ -183,7 +210,9 @@ module OM::XML::TermXpathGenerator
     return xpath
   end
   
-  
+  # Turns an Array into a String containing values separated by a delimiter.  Defaults to comma as a delimiter.
+  # @param [Array] values_array to convert
+  # @param [String] delimiter.  Default: ", "
   def self.delimited_list( values_array, delimiter=", ")
     result = values_array.collect{|a| a + delimiter}.to_s.chomp(delimiter)
   end
@@ -224,4 +253,4 @@ module OM::XML::TermXpathGenerator
     return modified_query
   end
 
-end
+end

data/om.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{om}
-  s.version = "1.0.2"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matt Zumwalt"]
-  s.date = %q{2010-12-15}
+  s.date = %q{2011-03-05}
   s.description = %q{OM (Opinionated Metadata): A library to help you tame sprawling XML schemas like MODS.  Wraps Nokogiri documents in objects with miscellaneous helper methods for doing things like retrieve generated xpath queries or look up properties based on a simplified DSL}
   s.email = %q{matt.zumwalt@yourmediashelf.com}
   s.extra_rdoc_files = [
@@ -33,14 +33,10 @@ Gem::Specification.new do |s|
     "lib/om/samples/mods_article.rb",
     "lib/om/tree_node.rb",
     "lib/om/xml.rb",
-    "lib/om/xml/accessors.rb",
     "lib/om/xml/container.rb",
     "lib/om/xml/document.rb",
-    "lib/om/xml/generator.rb",
     "lib/om/xml/named_term_proxy.rb",
     "lib/om/xml/node_generator.rb",
-    "lib/om/xml/properties.rb",
-    "lib/om/xml/property_value_operators.rb",
     "lib/om/xml/term.rb",
     "lib/om/xml/term_value_operators.rb",
     "lib/om/xml/term_xpath_generator.rb",
@@ -56,15 +52,11 @@ Gem::Specification.new do |s|
     "spec/integration/rights_metadata_integration_example_spec.rb",
     "spec/spec.opts",
     "spec/spec_helper.rb",
-    "spec/unit/accessors_spec.rb",
     "spec/unit/container_spec.rb",
     "spec/unit/document_spec.rb",
-    "spec/unit/generator_spec.rb",
     "spec/unit/named_term_proxy_spec.rb",
     "spec/unit/node_generator_spec.rb",
     "spec/unit/om_spec.rb",
-    "spec/unit/properties_spec.rb",
-    "spec/unit/property_value_operators_spec.rb",
     "spec/unit/term_builder_spec.rb",
     "spec/unit/term_spec.rb",
     "spec/unit/term_value_operators_spec.rb",
@@ -81,15 +73,11 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/integration/rights_metadata_integration_example_spec.rb",
     "spec/spec_helper.rb",
-    "spec/unit/accessors_spec.rb",
     "spec/unit/container_spec.rb",
     "spec/unit/document_spec.rb",
-    "spec/unit/generator_spec.rb",
     "spec/unit/named_term_proxy_spec.rb",
     "spec/unit/node_generator_spec.rb",
     "spec/unit/om_spec.rb",
-    "spec/unit/properties_spec.rb",
-    "spec/unit/property_value_operators_spec.rb",
     "spec/unit/term_builder_spec.rb",
     "spec/unit/term_spec.rb",
     "spec/unit/term_value_operators_spec.rb",

data/spec/fixtures/mods_articles/hydrangea_article1.xml

@@ -11,9 +11,11 @@
     </titleInfo>
 
     <name type="personal">
+        Describes a person
         <namePart type="family">FAMILY NAME</namePart>
         <namePart type="given">GIVEN NAMES</namePart>
         <namePart type="termsOfAddress">DR.</namePart>
+        <namePart>PERSON_ID</namePart>
         <displayForm>NAME AS IT APPEARS</displayForm>
         <affiliation>FACULTY, UNIVERSITY</affiliation>    
         <role> 
@@ -28,6 +30,7 @@
         <namePart type="family">Gautama</namePart>
         <namePart type="given">Siddartha</namePart>
         <namePart type="termsOfAddress">Prince</namePart>
+        <namePart>123987</namePart>
         <affiliation>Nirvana</affiliation>    
         <role> 
             <roleTerm authority="marcrelator" type="text">teacher</roleTerm>

data/spec/unit/document_spec.rb

@@ -35,6 +35,7 @@ describe "OM::XML::Document" do
           t.last_name(:path=>"namePart", :attributes=>{:type=>"family"})
           t.first_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
           t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+          t.person_id(:path=>"namePart", :attributes=>{:type=>:none})
         }
         # lookup :person, :first_name        
         t.person(:ref=>:name, :attributes=>{:type=>"personal"})
@@ -113,6 +114,9 @@ describe "OM::XML::Document" do
       @mods_article.find_by_terms( {:person=>1}, :first_name ).class.should == Nokogiri::XML::NodeSet
       @mods_article.find_by_terms( {:person=>1}, :first_name ).first.text.should == "Siddartha"
     end
+    it "should find a NodeSet where a terminology attribute has been set to :none" do
+      @mods_article.find_by_terms( {:person=>1}, :person_id).first.text.should == "123987"
+    end
     it "should support accessors whose relative_xpath is a lookup array instead of an xpath string" do
       # pending "this only impacts scenarios where we want to display & edit"
       DocumentTest.terminology.retrieve_term(:title_info, :language).path.should == {:attribute=>"lang"}
@@ -128,7 +132,7 @@ describe "OM::XML::Document" do
       pending "Can't decide if it's better to return nil or raise an error.  Choosing informative errors for now."
       @mods_article.find_by_terms( {:foo=>20}, :bar ).should == nil
     end
-
+    
     it "should support terms that point to attributes instead of nodes" do
       @mods_article.find_by_terms( {:title_info=>1}, :language ).first.text.should == "finnish"
     end

data/spec/unit/term_value_operators_spec.rb

@@ -16,6 +16,10 @@ describe "OM::XML::TermValueOperators" do
       result.length.should == expected_values.length
       expected_values.each {|v| result.should include(v)}
     end
+
+    it "should ignore whitespace elements for a term pointing to a text() node for an element that contains children" do
+      @article.term_values(:name, :name_content).should == ["Describes a person"]
+    end
   
   end
   
@@ -72,7 +76,7 @@ describe "OM::XML::TermValueOperators" do
     end
 
     it "should destringify the field key/find_by_terms_and_value pointer" do
-      OM::Samples::ModsArticle.terminology.expects(:xpath_with_indexes).with( *[{:person=>0}, :role]).times(7).returns("//oxns:name[@type=\"personal\"][1]/oxns:role")
+      OM::Samples::ModsArticle.terminology.expects(:xpath_with_indexes).with( *[{:person=>0}, :role]).times(10).returns("//oxns:name[@type=\"personal\"][1]/oxns:role")
       OM::Samples::ModsArticle.terminology.stubs(:xpath_with_indexes).with( *[{:person=>0}]).returns("//oxns:name[@type=\"personal\"][1]")
       @article.update_values( { [{":person"=>"0"}, "role"]=>"the role" } )
       @article.update_values( { [{"person"=>"0"}, "role"]=>"the role" } )
@@ -183,6 +187,13 @@ describe "OM::XML::TermValueOperators" do
       @article.update_values({[:journal, :title_info]=>{"0"=>:delete}})
       @article.term_values(:journal, :title_info).should == ['mork']
     end
+
+    it "should retain other child nodes when updating a text content term and shoud not append an additional text node but update text in place" do
+      @article.term_values(:name,:name_content).should == ["Describes a person"]
+      @article.update_values({[:name, :name_content]=>"Test text"})
+      @article.term_values(:name,:name_content).should == ["Test text"]
+      @article.find_by_terms(:name).children.length().should == 30
+    end
     
   end
   
@@ -406,4 +417,4 @@ describe "OM::XML::TermValueOperators" do
     end
   end
   
-end
+end

data/spec/unit/term_xpath_generator_spec.rb

@@ -22,6 +22,8 @@ describe "OM::XML::TermXpathGeneratorSpec" do
     @test_term_with_default_path = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
     @test_role_text = OM::XML::Term.new(:role_text, :path=>"roleTerm", :attributes=>{:type=>"text"})
     @test_lang_attribute = OM::XML::Term.new(:language, :path=>{:attribute=>"lang"})
+    @test_none_attribute_value = OM::XML::Term.new(:person_id, :path=>"namePart", :attributes=>{:type=>:none})
+    
   end
   
   it "should support terms that are pointers to attribute values" do
@@ -51,6 +53,14 @@ describe "OM::XML::TermXpathGeneratorSpec" do
       @test_term.namespace_prefix = nil
       OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term).should == 'namePart[@type="termsOfAddress"]'
     end
+    it "should not use a namespace for a path set to text() and should include normalize-space to ignore white space" do
+      text_term = OM::XML::Term.new(:title_content, :path=>"text()")
+      OM::XML::TermXpathGenerator.generate_relative_xpath(text_term).should == 'text()[normalize-space(.)]'
+    end
+    it "should set a 'not' predicate if the attribute value is :none" do
+       OM::XML::TermXpathGenerator.generate_relative_xpath(@test_none_attribute_value).should == 'oxns:namePart[not(@type)]'
+    end
+
   end
   
   describe "generate_absolute_xpath" do
@@ -108,4 +118,4 @@ describe "OM::XML::TermXpathGeneratorSpec" do
     OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term_with_default_path).should == '//oxns:detail[contains(oxns:number[@type="volume"], "#{constraint_value}")]'.gsub('"', '\"')  
   end
   
-end
+end