om 3.1.0 → 3.1.1

data/spec/unit/validation_spec.rb

@@ -19,28 +19,28 @@ describe "OM::XML::Validation" do
 
   describe '#schema_url' do
     it "should allow you to set the schema url" do
-      ValidationTest.schema_url.should == "http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"
+      expect(ValidationTest.schema_url).to eq "http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"
     end
   end
   
   describe "#schema" do
     it "should return an instance of Nokogiri::XML::Schema loaded from the schema url -- fails if no internet connection" do
       skip "no internet connection"
-      ValidationTest.schema.should be_kind_of Nokogiri::XML::Schema
+      expect(ValidationTest.schema).to be_kind_of Nokogiri::XML::Schema
     end
   end
 
   describe "#validate" do
     it "should validate the provided document against the schema provided in class definition  -- fails if no internet connection" do
       skip "no internet connection"
-      ValidationTest.schema.should_receive(:validate).with(@sample).and_return([])
+      expect(ValidationTest.schema).to receive(:validate).with(@sample).and_return([])
       ValidationTest.validate(@sample)
     end
   end
 
   describe ".validate" do
     it "should rely on class validate method" do
-      ValidationTest.should_receive(:validate).with(@sample)
+      expect(ValidationTest).to receive(:validate).with(@sample)
       @sample.validate
     end
   end
@@ -55,26 +55,26 @@ describe "OM::XML::Validation" do
     end
   
     it "should lazy load the schema file from the @schema_url" do
-      ValidationTest.instance_variable_get(:@schema_file).should be_nil
-      ValidationTest.should_receive(:file_from_url).with(ValidationTest.schema_url).once.and_return("fake file")
+      expect(ValidationTest.instance_variable_get(:@schema_file)).to be_nil
+      expect(ValidationTest).to receive(:file_from_url).with(ValidationTest.schema_url).once.and_return("fake file")
       ValidationTest.schema_file
-      ValidationTest.instance_variable_get(:@schema_file).should == "fake file"
-      ValidationTest.schema_file.should == "fake file"
+      expect(ValidationTest.instance_variable_get(:@schema_file)).to eq "fake file"
+      expect(ValidationTest.schema_file).to eq "fake file"
     end
   end
 
   describe "#file_from_url" do
     it "should retrieve a file from the provided url over HTTP" do
-      ValidationTest.should_receive(:open).with("http://google.com")
+      expect(ValidationTest).to receive(:open).with("http://google.com")
       ValidationTest.send(:file_from_url, "http://google.com")
     end
     it "should raise an error if the url is invalid" do
-      lambda {ValidationTest.send(:file_from_url, "")}.should raise_error(RuntimeError, /Could not retrieve file from /)
-      lambda {ValidationTest.send(:file_from_url, "foo")}.should raise_error(RuntimeError, /Could not retrieve file from foo/)
+      expect(lambda {ValidationTest.send(:file_from_url, "")}).to raise_error(RuntimeError, /Could not retrieve file from /)
+      expect(lambda {ValidationTest.send(:file_from_url, "foo")}).to raise_error(RuntimeError, /Could not retrieve file from foo/)
     end
     it "should raise an error if file retrieval fails" do
       skip "no internet connection"
-      lambda {ValidationTest.send(:file_from_url, "http://fedora-commons.org/nonexistent_file")}.should raise_error(RuntimeError, "Could not retrieve file from http://fedora-commons.org/nonexistent_file. Error: 404 Not Found")  
+      expect(lambda {ValidationTest.send(:file_from_url, "http://fedora-commons.org/nonexistent_file")}).to raise_error(RuntimeError, "Could not retrieve file from http://fedora-commons.org/nonexistent_file. Error: 404 Not Found")  
     end
   end
 end

data/spec/unit/xml_serialization_spec.rb

@@ -7,13 +7,13 @@ describe "OM::XML::Terminology.to_xml" do
   it "should put terminology details into the xml" do
     expected_xml = "<namespaces>\n  <namespace>\n    <name>oxns</name>\n    <identifier>http://www.loc.gov/mods/v3</identifier>\n  </namespace>\n  <namespace>\n    <name>xmlns:foo</name>\n    <identifier>http://my.custom.namespace</identifier>\n  </namespace>\n  <namespace>\n    <name>xmlns</name>\n    <identifier>http://www.loc.gov/mods/v3</identifier>\n  </namespace>\n</namespaces>"
     xml = @terminology.to_xml
-    xml.xpath("/terminology/schema").to_xml.should == "<schema>http://www.loc.gov/standards/mods/v3/mods-3-2.xsd</schema>"    
-    xml.xpath("/terminology/namespaces").to_xml.should be_equivalent_to expected_xml
+    expect(xml.xpath("/terminology/schema").to_xml).to eq "<schema>http://www.loc.gov/standards/mods/v3/mods-3-2.xsd</schema>"    
+    expect(xml.xpath("/terminology/namespaces").to_xml).to be_equivalent_to expected_xml
   end
   it "should call .to_xml on all of the terms" do
     options = {}
     doc = Nokogiri::XML::Document.new
-    @terminology.terms.values.each {|term| term.should_receive(:to_xml) }
+    @terminology.terms.values.each {|term| expect(term).to receive(:to_xml) }
     @terminology.to_xml(options,doc)
   end
 end
@@ -27,33 +27,33 @@ describe "OM::XML::Term.to_xml" do
   end
   it "should return an xml representation of the Term" do
     xml = @person_first_name.to_xml
-    xml.xpath("/term").first.attributes["name"].value.should == "first_name"
-    xml.xpath("/term/attributes/type").first.text.should == "given"
-    xml.xpath("/term/path").first.text.should == "namePart"
-    xml.xpath("/term/namespace_prefix").first.text.should == "oxns"
-    xml.xpath("/term/children/*").should be_empty
-    xml.xpath("/term/xpath/relative").first.text.should == "oxns:namePart[@type=\"given\"]"
-    xml.xpath("/term/xpath/absolute").first.text.should == "//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"given\"]"
-    xml.xpath("/term/xpath/constrained").first.text.should == "//oxns:name[@type=\\\"personal\\\"]/oxns:namePart[@type=\\\"given\\\" and contains(., \\\"\#{constraint_value}\\\")]"
-    xml.xpath("/term/index_as").first.text.should == ""
-    xml.xpath("/term/required").first.text.should == "false"
-    xml.xpath("/term/data_type").first.text.should == "string"
+    expect(xml.xpath("/term").first.attributes["name"].value).to eq "first_name"
+    expect(xml.xpath("/term/attributes/type").first.text).to eq "given"
+    expect(xml.xpath("/term/path").first.text).to eq "namePart"
+    expect(xml.xpath("/term/namespace_prefix").first.text).to eq "oxns"
+    expect(xml.xpath("/term/children/*")).to be_empty
+    expect(xml.xpath("/term/xpath/relative").first.text).to eq "oxns:namePart[@type=\"given\"]"
+    expect(xml.xpath("/term/xpath/absolute").first.text).to eq "//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"given\"]"
+    expect(xml.xpath("/term/xpath/constrained").first.text).to eq "//oxns:name[@type=\\\"personal\\\"]/oxns:namePart[@type=\\\"given\\\" and contains(., \\\"\#{constraint_value}\\\")]"
+    expect(xml.xpath("/term/index_as").first.text).to eq ""
+    expect(xml.xpath("/term/required").first.text).to eq "false"
+    expect(xml.xpath("/term/data_type").first.text).to eq "string"
   end
   it "should capture root term info" do
     xml = @terminology.root_terms.first.to_xml
-    xml.xpath("/term/is_root_term").text.should == "true"
-    @person_first_name.to_xml.xpath("/term/is_root_term").should be_empty
+    expect(xml.xpath("/term/is_root_term").text).to eq("true")
+    expect(@person_first_name.to_xml.xpath("/term/is_root_term")).to be_empty
   end
   it "should allow you to pass in a document to add the term to" do
     doc = Nokogiri::XML::Document.new
-    @person_first_name.to_xml({}, doc).should == doc
+    expect(@person_first_name.to_xml({}, doc)).to eq doc
   end
   it "should include children" do
     children = @person.to_xml.xpath("//term[@name=\"person\"]/children/*")
-    children.length.should == 12
-    children.each {|child| child.name.should == "term"}
+    expect(children.length).to eq(12)
+    children.each {|child| expect(child.name).to eq "term"}
   end
   it "should skip children if :children=>false" do
-    @person.to_xml(:children=>false).xpath("children").should be_empty
+    expect(@person.to_xml(:children=>false).xpath("children")).to be_empty
   end
 end

data/spec/unit/xml_spec.rb

@@ -9,13 +9,13 @@ describe "OM::XML::Container" do
   end
   
   it "should automatically include the other modules" do
-    XMLTest.included_modules.should include(OM::XML::Container)
-    XMLTest.included_modules.should include(OM::XML::Validation)
+    expect(XMLTest.included_modules).to include(OM::XML::Container)
+    expect(XMLTest.included_modules).to include(OM::XML::Validation)
   end
   
   describe "#sanitize_pointer" do
     it "should convert any nested arrays into hashes" do
-      XMLTest.sanitize_pointer( [[:person,1],:role] ).should == [{:person=>1},:role]
+      expect(XMLTest.sanitize_pointer( [[:person,1],:role] )).to eq [{:person=>1},:role]
     end
   end
   

data/spec/unit/xml_terminology_based_solrizer_spec.rb

@@ -16,13 +16,13 @@ describe OM::XML::TerminologyBasedSolrizer do
   describe ".to_solr" do
   
     it "should provide .to_solr and return a SolrDocument" do
-      @mods_article.should respond_to(:to_solr)
-      @mods_article.to_solr.should be_kind_of(Hash)
+      expect(@mods_article).to respond_to(:to_solr)
+      expect(@mods_article.to_solr).to be_kind_of(Hash)
     end
   
     it "should optionally allow you to provide the Hash to add fields to and return that document when done" do
       doc = Hash.new
-      @mods_article.to_solr(doc).should equal(doc)
+      expect(@mods_article.to_solr(doc)).to equal(doc)
     end
   
     it "should iterate through the terminology terms, calling .solrize_term on each and passing in the solr doc" do
@@ -30,24 +30,24 @@ describe OM::XML::TerminologyBasedSolrizer do
       @mods_article.field_mapper = Solrizer::FieldMapper.new
       Samples::ModsArticle.terminology.terms.each_pair do |k,v|
         next if k == :mods # we don't index the root node
-        @mods_article.should_receive(:solrize_term).with(v, solr_doc, @mods_article.field_mapper)
+        expect(@mods_article).to receive(:solrize_term).with(v, solr_doc, @mods_article.field_mapper)
       end
       @mods_article.to_solr(solr_doc)
     end
   
     it "should use Solr mappings to generate field names" do
       solr_doc =  @mods_article.to_solr
-      solr_doc["abstract"].should be_nil
+      expect(solr_doc["abstract"]).to be_nil
       # NOTE:  OM's old default expected stored and indexed;  this is a change.
-      solr_doc["abstract_tesim"].should == ["ABSTRACT"]
-      solr_doc["title_info_1_language_tesim"].should == ["finnish"]
-      solr_doc["person_1_role_0_text_tesim"].should == ["teacher"]
+      expect(solr_doc["abstract_tesim"]).to eq ["ABSTRACT"]
+      expect(solr_doc["title_info_1_language_tesim"]).to eq ["finnish"]
+      expect(solr_doc["person_1_role_0_text_tesim"]).to eq ["teacher"]
       # No index_as on the code field.
-      solr_doc["person_1_role_0_code_tesim"].should be_nil 
-      solr_doc["person_last_name_tesim"].sort.should == ["FAMILY NAME", "Gautama"]
-      solr_doc["topic_tag_tesim"].sort.should == ["CONTROLLED TERM", "TOPIC 1", "TOPIC 2"]
+      expect(solr_doc["person_1_role_0_code_tesim"]).to be_nil 
+      expect(solr_doc["person_last_name_tesim"].sort).to eq ["FAMILY NAME", "Gautama"]
+      expect(solr_doc["topic_tag_tesim"].sort).to eq ["CONTROLLED TERM", "TOPIC 1", "TOPIC 2"]
       # These are a holdover from an old verison of OM
-      solr_doc['journal_0_issue_0_publication_date_dtsim'].should == ["2007-02-01T00:00:00Z"]
+      expect(solr_doc['journal_0_issue_0_publication_date_dtsim']).to eq ["2007-02-01T00:00:00Z"]
     end
 
   end
@@ -57,7 +57,7 @@ describe OM::XML::TerminologyBasedSolrizer do
     it "should add fields to a solr document for all nodes corresponding to the given term and its children" do
       solr_doc = Hash.new
       result = @mods_article.solrize_term(Samples::ModsArticle.terminology.retrieve_term(:title_info), solr_doc)
-      result.should == solr_doc
+      expect(result).to be solr_doc
     end
 
     it "should add multiple fields based on index_as" do
@@ -70,7 +70,7 @@ describe OM::XML::TerminologyBasedSolrizer do
       expected_names = ["DR.", "FAMILY NAME", "GIVEN NAMES", "PERSON_ID"]
       %w(_teim _sim).each do |suffix|
         actual_names = fake_solr_doc["name_0_namePart#{suffix}"].sort
-        actual_names.should == expected_names
+        expect(actual_names).to eq expected_names
       end
     end
 
@@ -78,14 +78,14 @@ describe OM::XML::TerminologyBasedSolrizer do
       unless RUBY_VERSION.match("1.8.7")
         solr_doc = Hash.new
         result = @mods_article.solrize_term(Samples::ModsArticle.terminology.retrieve_term(:pub_date), solr_doc)
-        solr_doc["pub_date_dtsim"].should == ["2007-02-01T00:00:00Z"]
+        expect(solr_doc["pub_date_dtsim"]).to eq ["2007-02-01T00:00:00Z"]
       end
     end
 
     it "should add fields based on type using ref" do
       solr_doc = Hash.new
       result = @mods_article.solrize_term(Samples::ModsArticle.terminology.retrieve_term(:issue_date), solr_doc)
-      solr_doc["issue_date_dtsim"].should == ["2007-02-15T00:00:00Z"]
+      expect(solr_doc["issue_date_dtsim"]).to eq ["2007-02-15T00:00:00Z"]
     end
 
     it "shouldn't index terms where index_as is an empty array" do
@@ -94,7 +94,7 @@ describe OM::XML::TerminologyBasedSolrizer do
       term.children[:namePart].index_as = []
 
       @mods_article.solrize_term(term, fake_solr_doc)
-      fake_solr_doc["name_0_namePart_teim"].should be_nil
+      expect(fake_solr_doc["name_0_namePart_teim"]).to be_nil
     end
 
     it "should index terms where index_as is searchable" do
@@ -104,7 +104,7 @@ describe OM::XML::TerminologyBasedSolrizer do
 
       @mods_article.solrize_term(term, fake_solr_doc)
       
-      fake_solr_doc["name_0_namePart_teim"].sort.should == ["DR.", "FAMILY NAME", "GIVEN NAMES", "PERSON_ID"]
+      expect(fake_solr_doc["name_0_namePart_teim"].sort).to eq ["DR.", "FAMILY NAME", "GIVEN NAMES", "PERSON_ID"]
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: om
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Matt Zumwalt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-18 00:00:00.000000000 Z
+date: 2016-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -109,34 +109,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: RedCloth
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
@@ -179,17 +151,17 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
-- COMMON_OM_PATTERNS.textile
+- COMMON_OM_PATTERNS.md
 - CONTRIBUTING.md
-- GETTING_FANCY.textile
-- GETTING_STARTED.textile
+- GETTING_FANCY.md
+- GETTING_STARTED.md
 - Gemfile
-- History.textile
+- History.md
 - LICENSE
-- QUERYING_DOCUMENTS.textile
+- QUERYING_DOCUMENTS.md
 - README.md
 - Rakefile
-- UPDATING_DOCUMENTS.textile
+- UPDATING_DOCUMENTS.md
 - container_spec.rb
 - devel/notes.txt
 - gemfiles/gemfile.rails3
@@ -254,7 +226,8 @@ files:
 - spec/unit/xml_spec.rb
 - spec/unit/xml_terminology_based_solrizer_spec.rb
 homepage: http://github.com/projecthydra/om
-licenses: []
+licenses:
+- APACHE2
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -272,7 +245,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: 'OM (Opinionated Metadata): A library to help you tame sprawling XML schemas

data/GETTING_FANCY.textile

@@ -1,145 +0,0 @@
-h1. Getting Fancy
-
-
-
-h2. Alternative ways to Manipulate Terms, Terminologies and their Builders
-
-There is more than one way to build a terminology. 
-
-h3. OM::XML::Terminology::Builder":OM/XML/Terminology/Builder.html Block Syntax
-
-The simplest way to create an OM Terminology is to use the "OM::XML::Terminology::Builder":OM/XML/Terminology/Builder.html" block syntax. 
-
-In the following examples, we will show different ways of building this Terminology:
-
-<pre>
-  builder = OM::XML::Terminology::Builder.new do |t|
-    t.root(:path=>"grants", :xmlns=>"http://yourmediashelf.com/schemas/hydra-dataset/v0", :schema=>"http://example.org/schemas/grants-v1.xsd")
-    t.grant {
-      t.org(:path=>"organization", :attributes=>{:type=>"funder"}) {
-        t.name(:index_as=>:searchable)
-      }
-      t.number
-    }
-  end
-  another_terminology = builder.build
-</pre>
-
-
-h3. Using "OM::XML::Term":OM/XML/Term.html ::Builders
-
-First, create the Terminology Builder object:
-
-<pre>
-  terminology_builder = OM::XML::Terminology::Builder.new
-</pre>
-
-The .root method handles creating the root term and setting namespaces, schema, etc. on the Terminology:
-
-<pre>
-  terminology_builder.root(:path=>"grants", :xmlns=>"http://yourmediashelf.com/schemas/hydra-dataset/v0", :schema=>"http://example.org/schemas/grants-v1.xsd")
-</pre>
-
-This sets the namespaces for you and created the "grants" root term:
-
-<pre>
-  terminology_builder.namespaces
-   => {"oxns"=>"http://yourmediashelf.com/schemas/hydra-dataset/v0", "xmlns"=>"http://yourmediashelf.com/schemas/hydra-dataset/v0"}
-  terminology_builder.term_builders
-</pre>
-
-Create Term Builders for each of the Terms:
-
-<pre>
-  term1_builder = OM::XML::Term::Builder.new("grant", terminology_builder).path("grant")
-  subterm1_builder = OM::XML::Term::Builder.new("org", terminology_builder).attributes(:type=>"funder")
-  subsubterm_builder = OM::XML::Term::Builder.new("name", terminology_builder).index_as(:searchable)
-  subterm2_builder = OM::XML::Term::Builder.new("number", terminology_builder)
-</pre>
-
-Assemble the tree of Term builders by adding child builders to their parents; then add the top level terms to the root term in the Terminology builder:
-
-<pre>
-  subterm1_builder.add_child(subsubterm_builder)
-  term1_builder.add_child(subterm1_builder)
-  term1_builder.add_child(subterm2_builder)
-  terminology_builder.term_builders["grant"] = term1_builder
-</pre>
-
-Now build the Terminology, which will also call .build on each of the Term Builders in the tree:
-
-<pre>
-  built_terminology = terminology_builder.build
-</pre>
-
-Test it out:
-
-<pre>
-  built_terminology.retrieve_term(:grant, :org, :name)
-  built_terminology.xpath_for(:grant, :org, :name)
-  built_terminology.root_terms
-  built_terminology.terms.keys  # This will only return the Terms at the root of the terminology hierarchy
-  built_terminology.retrieve_term(:grant).children.keys
-</pre>
-
-h3. Creating Terms & Terminologies without any Builders
-
-If you want to manipulate Terms and Terminologies directly rather than using the Builder classes, you can consume their APIs at any time.
-
-People don't often do this, but the option is there if you need it.
-
-Create the Terminology, set its namespaces & (optional) schema:
-(Note that you have to set the :oxns namespaces to match :xmlns.  This is usually done for you by the Terminology::Builder.root method.)
-
-<pre>
-  handcrafted_terminology = OM::XML::Terminology.new
-  handcrafted_terminology.namespaces[:xmlns] = "http://yourmediashelf.com/schemas/hydra-dataset/v0"
-  handcrafted_terminology.namespaces[:oxns] = "http://yourmediashelf.com/schemas/hydra-dataset/v0"
-  handcrafted_terminology.schema = "http://example.org/schemas/grants-v1.xsd"
-</pre>
-
-Create the Terms:
-
-<pre>
-  # Create term1 (the root) and set it as the root term
-  root_term = OM::XML::Term.new("grants")
-  root_term.is_root_term = true
-
-  # Create term1 (grant) and its subterms
-  term1 = OM::XML::Term.new("grant")
-
-  subterm1 = OM::XML::Term.new("org")
-  subterm1.path = "organization"
-  subterm1.attributes = {:type=>"funder"}
-
-  subsubterm = OM::XML::Term.new("name")
-  subsubterm.index_as = :searchable
-
-  subterm2 = OM::XML::Term.new("number")
-</pre>
-
-Assemble the tree of terms by adding child terms to their parents, then add those to the Terminology.
-
-<pre>
-  subterm1.add_child(subsubterm)
-  term1.add_child(subterm1)
-  term1.add_child(subterm2)
-  handcrafted_terminology.add_term(root_term)
-  handcrafted_terminology.add_term(term1)
-</pre>
-
-Generate the xpath queries for each term.  This is usually done for you by the Term Builder.build method:
-
-<pre>
-  [root_term, term1, subterm1, subsubterm, subterm2].each {|t| t.generate_xpath_queries!}
-</pre>
-
-Test it out:
-
-<pre>
-  handcrafted_terminology.retrieve_term(:grant, :org, :name)
-  handcrafted_terminology.xpath_for(:grant, :org, :name)
-  handcrafted_terminology.root_terms
-  handcrafted_terminology.terms.keys  # This will only return the Terms at the root of the terminology hierarchy
-  handcrafted_terminology.retrieve_term(:grant).children.keys
-</pre>