om 1.6.0 → 1.6.1

data/spec/integration/rights_metadata_integration_example_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require "nokogiri"
-require "om"
+require 'spec_helper'
 
 describe "OM::XML::Accessors" do
   
@@ -75,4 +73,4 @@ describe "OM::XML::Accessors" do
     end
   end
   
-end
+end

data/spec/integration/selective_querying_spec.rb

@@ -0,0 +1,89 @@
+# These tests illustrate how to select nodes based on their position
+# within an XML hierarchy and the value of particular attributes.
+
+require 'spec_helper'
+
+describe "Selecting nodes based on (a) position in hierarchy and (b) attributes" do
+
+  before(:all) do
+
+    # Some XML, with various flavors of <note> nodes:
+    #   - outer vs inner;
+    #   - with vs without an "a" attribute.
+    @xml = %Q{
+      <root xmlns="foo">
+        <note>o1</note>
+        <note>o2</note>
+        <note a="a">o3a</note>
+        <note a="a">o4a</note>
+        <inner>
+          <note>i1</note>
+          <note>i2</note>
+          <note a="a">i3a</note>
+          <note a="a">i4a</note>
+        </inner>
+      </root>
+    }
+
+    # Our document class and its OM terminology.
+    #
+    # In order to select only the outer or inner <note> nodes, we must use
+    # the :proxy approach shown below; however, that approach does not work
+    # with :attributes. Thus, the general strategy here is first to define OM
+    # terms for any attibute-based selections we might want, and then to
+    # refine those further using :proxy.
+    class FooDoc
+      include OM::XML::Document
+
+      set_terminology do |t|
+        t.root :path => 'root', :xmlns => 'foo'
+
+        # All notes.
+        t.note
+        t.all_note       :path => 'note'   # Included for symmetry.
+
+        # All notes with and without attributes.
+        t.all_note_a     :path => 'note', :attributes => { :a => "a" }
+        t.all_note_not_a :path => 'note', :attributes => { :a => :none }
+
+        # All inner notes -- again, with and without attributes.
+        t.inner do
+          t.note
+          t.note_a     :path => 'note', :attributes => { :a => "a" }
+          t.note_not_a :path => 'note', :attributes => { :a => :none }
+        end
+
+        # Using the terms defined above, we can now define any additional
+        # selections we might need.
+        t.all_outer_note   :proxy => [:root, :note]
+        t.all_inner_note   :proxy => [:root, :inner, :note]
+        t.outer_note_a     :proxy => [:root, :all_note_a]
+        t.outer_note_not_a :proxy => [:root, :all_note_not_a]
+        t.inner_note_a     :proxy => [:root, :inner, :note_a]
+        t.inner_note_not_a :proxy => [:root, :inner, :note_not_a]
+      end
+    end
+
+    # A document instance.
+    @doc = FooDoc.from_xml(@xml)
+  end
+
+
+  # Did it work?
+  it "should be able to select all types of <note> nodes" do
+    tests = [
+      # OM term.            Expected result.
+      [ 'all_note',         %w(o1 o2 o3a o4a i1 i2 i3a i4a) ],
+      [ 'all_note_a',       %w(      o3a o4a       i3a i4a) ],
+      [ 'all_note_not_a',   %w(o1 o2         i1 i2        ) ],
+      [ 'all_outer_note',   %w(o1 o2 o3a o4a              ) ],
+      [ 'all_inner_note',   %w(              i1 i2 i3a i4a) ],
+      [ 'outer_note_a',     %w(      o3a o4a              ) ],
+      [ 'outer_note_not_a', %w(o1 o2                      ) ],
+      [ 'inner_note_a',     %w(                    i3a i4a) ],
+      [ 'inner_note_not_a', %w(              i1 i2        ) ],
+    ]
+    tests.each { |meth, exp| @doc.send(meth).should == exp }
+  end
+
+end

data/spec/integration/set_reentrant_terminology_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe "calling set_terminology more than once" do
+
+  before(:all) do
+    class ReentrantTerminology
+      include OM::XML::Document
+
+      set_terminology do |t|
+        t.root :path => 'root', :xmlns => "asdf"
+        t.foo
+      end
+    end
+  end
+
+  describe "before" do
+
+    subject do
+      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+      ReentrantTerminology.from_xml(xml)
+    end
+
+    it "can get foo" do
+      subject.foo.should == ['fooval']
+    end
+
+    it "cannot get bar" do
+      expect { subject.bar }.to raise_error OM::XML::Terminology::BadPointerError
+    end
+
+  end
+
+  describe "after" do
+
+    before(:all) do
+      class ReentrantTerminology
+        set_terminology do |t|
+          t.root :path => 'root', :xmlns => "asdf"
+          t.bar
+        end
+      end
+    end
+
+    subject do
+      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+      ReentrantTerminology.from_xml(xml)
+    end
+
+    it "cannot get foo" do
+      expect { subject.foo }.to raise_error OM::XML::Terminology::BadPointerError
+    end
+
+    it "can now get bar" do
+      subject.bar.should == ['barval']
+    end
+
+  end
+
+  describe "re-entrant modification" do
+
+
+    before(:all) do
+      class ReentrantTerminology
+        set_terminology do |t|
+          t.root :path => 'root', :xmlns => "asdf"
+          t.foo
+        end
+      end
+
+      class ReentrantTerminology
+        extend_terminology do |t|
+          t.bar
+        end
+      end
+    end
+
+    subject do
+      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+      ReentrantTerminology.from_xml(xml)
+    end
+
+    it "can get foo" do
+      subject.foo.should == ['fooval']
+    end
+
+    it "can get bar" do
+      subject.bar.should == ['barval']
+    end
+
+  end
+
+  describe "subclass modification" do
+
+
+    before(:all) do
+      class ReentrantTerminology
+        set_terminology do |t|
+          t.root :path => 'root', :xmlns => "asdf"
+          t.foo
+        end
+      end
+
+      class LocalReentrantTerminology 
+        include OM::XML::Document
+        use_terminology(ReentrantTerminology)
+        extend_terminology do |t|
+          t.bar
+        end
+      end
+    end
+
+    subject do
+      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+      LocalReentrantTerminology.from_xml(xml)
+    end
+
+    it "shouldn't bleed up the inheritence stack" do
+      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+      t = ReentrantTerminology.from_xml(xml)
+
+      expect { t.bar }.to raise_error OM::XML::Terminology::BadPointerError
+    end
+
+    it "can get foo" do
+      subject.foo.should == ['fooval']
+    end
+
+    it "can get bar" do
+      subject.bar.should == ['barval']
+    end
+
+  end
+
+end

data/spec/integration/xpathy_stuff_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+describe "an example of xpath-y stuff, also using :proxy and :ref and namespaces" do
+
+  describe "a contrived example" do
+    before(:all) do
+      class XpathyStuffTerminology
+        include OM::XML::Document
+
+        set_terminology do |t|
+          t.root(:path=>"contentMetadata", :xmlns => '', :namespace_prefix => nil) 
+
+          t.resource(:namespace_prefix => nil) {
+            t.file(:ref=>[:file], :namespace_prefix => nil)
+          }
+
+          t.file(:namespace_prefix => nil) {
+            t.location(:path=>"location", :namespace_prefix => nil)
+            t.filename(:path=>{:attribute=>"id"}, :namespace_prefix => nil)
+            t.format(:path=>{:attribute=>"format"}, :namespace_prefix => nil)
+          }
+          t.content(:ref=>:file, :path=>'resource/file[location="content"]', :namespace_prefix => nil)
+          t.html(:ref=>:file, :path=>'resource/file[location="html"]', :namespace_prefix => nil)
+
+          t.content_location(:proxy=>[:content, :location])
+          t.content_filename(:proxy=>[:content, :filename])
+          t.content_format(:proxy=>[:content, :format])
+
+          t.html_location(:proxy=>[:html, :location])
+          t.html_filename(:proxy=>[:html, :filename])
+          t.html_format(:proxy=>[:html, :format])
+
+        end
+      end
+    end
+
+    subject do
+      XpathyStuffTerminology.from_xml <<-EOF
+<contentMetadata>
+   <resource type="file" id="BU3A5" objectId="val2">
+    <file id="BURCH1" format="BINARY">
+      <location>content</location>
+    </file>
+    <file id="BURCH1.html" format="HTML">
+      <location>html</location>
+    </file>
+  </resource>
+</contentMetadata>
+
+      EOF
+    end
+
+    it "should have a content term" do
+      subject.content.first.should =~ /content/
+    end
+
+    it "should have an html term" do
+      subject.html.first.should =~ /html/
+    end
+
+
+  end
+
+  describe "an example from MODS" do
+    before(:all) do
+      class ModsXpathyStuffTerminology 
+        include OM::XML::Document
+
+        set_terminology do |t|
+          t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3")
+          t.person(:path=>"name", :namespace_prefix => nil) {
+            t.given(:path=>"namePart", :attributes=>{:type=>"given"})
+            t.family(:path=>"namePart", :attributes=>{:type=>"family"})
+            t.role(:namespace_prefix => nil) {
+              t.text(:path=>"roleTerm", :attributes=>{:type=>"text"})
+              t.code(:path=>"roleTerm", :attributes=>{:type=>"code"})
+            }
+          }
+          t.author(:ref=>:person, :path=>'name[./role/roleTerm="aut"]')
+          t.advisor(:ref=>:person, :path=>'name[./role/roleTerm="ths"]')
+
+          t.author_given(:proxy=>[:author, :given])
+          t.author_family(:proxy=>[:author, :family])
+          t.advisor_given(:proxy=>[:advisor, :given])
+          t.advisor_family(:proxy=>[:advisor, :family])
+        end
+      end
+    end
+
+    subject do
+      ModsXpathyStuffTerminology.from_xml <<-EOF
+    <mods xmlns="http://www.loc.gov/mods/v3"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="3.3"
+  xsi:schemaLocation="http://www.loc.gov/mods/v3
+  http://www.loc.gov/standards/mods/v3/mods-3-3.xsd">
+     <name type="personal">
+         <namePart type="given">Mary</namePart>
+         <namePart type="family">Pickral</namePart>
+         <affiliation>University of Virginia</affiliation>
+         <namePart>mpc3c</namePart>
+         <affiliation>University of Virginia Library</affiliation>
+         <role>
+             <roleTerm authority="marcrelator" type="code">aut</roleTerm>
+             <roleTerm authority="marcrelator" type="text">author</roleTerm>
+         </role>
+     </name>
+    <name type="personal">
+      <namePart>der5y</namePart>
+      <namePart type="given">David</namePart>
+      <namePart type="family">Jones</namePart>
+      <affiliation>University of Virginia</affiliation>
+      <affiliation>Architectural History Dept.</affiliation>
+      <role>
+           <roleTerm authority="marcrelator" type="code">ths</roleTerm>
+           <roleTerm authority="marcrelator" type="text">advisor</roleTerm>
+      </role>
+    </name>
+  </mods>
+      EOF
+    end
+
+    it "should have the terms :author_given and :author_family to get the author name" do
+      pending "This doesn't seem to work?"
+      subject.author_given.should include("Mary")
+      subject.author_family.should include("Pickral")
+    end
+
+    it "should have the terms :advisor_given and :advisor_family to get the advisor name" do
+      pending "This doesn't seem to work?"
+      subject.advisor_given.should include("David")
+      subject.advisor_family.should include("Small")
+    end
+
+  end
+
+  describe "more MODS examples, with a given namespace prefix?" do
+
+    before(:all) do
+      class ModsXpathyStuffTerminology 
+        include OM::XML::Document
+
+        set_terminology do |t|
+          t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-3.xsd", :namespace_prefix => "mods")
+
+          t.name_ {
+            t.name_part(:path=>"namePart")
+            t.family_name(:path=>"namePart", :attributes=>{:type=>"family"})
+            t.given_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
+            t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+            t.role(:ref=>[:role])
+          }
+          t.role {
+            t.role_term_text(:path=>"roleTerm", :attributes=>{:type=>"text"})
+          }
+
+          t.person_full(:ref=>:name, :attributes=>{:type=>"personal"}) 
+          t.person(:proxy=>[:person_full, :name_part])
+          t.creator(:ref=>:person, :path=>'name[mods:role/mods:roleTerm="creator"]', :xmlns=>"http://www.loc.gov/mods/v3", :namespace_prefix => "mods")
+
+          t.corporate_full(:ref=>:name, :attributes=>{:type=>"corporate"})
+          t.corporate(:proxy=>[:corporate_full, :name_part])
+          t.repository(:ref=>:corporate, :path=>'name[mods:role/mods:roleTerm="repository"]', :xmlns=>"http://www.loc.gov/mods/v3", :namespace_prefix => "mods")
+        end
+      end
+    end
+
+    subject do
+      ModsXpathyStuffTerminology.from_xml <<-EOF
+<mods:mods xmlns:mods="http://www.loc.gov/mods/v3" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="3.3" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-3.xsd">
+
+  <mods:name type="personal">
+    <mods:namePart>David Small</mods:namePart>
+    <mods:role>
+      <mods:roleTerm authority="marcrelator" type="text">creator</mods:roleTerm>
+    </mods:role>
+  </mods:name>
+  <mods:name type="corporate">
+    <mods:namePart>Graphic Novel Repository</mods:namePart>
+    <mods:role>
+      <mods:roleTerm authority="local" type="text">repository</mods:roleTerm>
+    </mods:role>
+  </mods:name>
+</mods:mods>
+      EOF
+    end
+
+    it "should give a creator value" do
+      subject.creator.should include "David Small"
+    end
+
+    it "should give a repository value" do
+      subject.repository.should include "Graphic Novel Repository"
+    end
+
+    it "should have a person term 'for more generic xml'" do
+      subject.person.should include "David Small"
+    end
+
+    it "should have a corporate term 'for more generic xml'" do
+      subject.corporate.should include "Graphic Novel Repository"
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -1,3 +1,11 @@
+if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.9/
+  require 'simplecov'
+  require 'simplecov-rcov'
+
+  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+  SimpleCov.start
+end
+
 require 'om'
 require 'rspec'
 require 'equivalent-xml/rspec_matchers'