om 3.0.3 → 3.0.5

data/lib/om/xml/term_builder.rb

@@ -93,7 +93,7 @@ module OM::XML::TermBuilder
     # @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)
+      if 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)
@@ -118,14 +118,45 @@ module OM::XML::TermBuilder
       return self
     end
 
+    def root_term= val
+      @settings[:is_root_term] = val
+    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
+    def index_as= val
+      @settings[:index_as] = val
+    end
+
+    def required= val
+      @settings[:required] = val
+    end
+
+    def ref= val
+      @settings[:ref] = val
+    end
+
+    def attributes= val
+      @settings[:attributes] = val
+    end
+
+    def proxy= val
+      @settings[:proxy] = val
+    end
+
+    def type= val
+      @settings[:type] = val
+    end
+
+    def path= val
+      @settings[:path] = val
     end
+
+    def variant_of= val
+      @settings[:variant_of] = val
+    end
+
+    def default_content_path= val
+      @settings[:default_content_path] = val
+    end
+
   end
 end

data/lib/om/xml/terminology.rb

@@ -51,7 +51,10 @@ class OM::XML::Terminology
           @namespaces["oxns"] = ns_pair.last
         end
       end
-      root_term_builder = OM::XML::Term::Builder.new(opts.fetch(:path,:root).to_s.sub(/[_!]$/, '')).is_root_term(true)
+      path = opts.fetch(:path,:root).to_s.sub(/[_!]$/, '')
+      root_term_builder = OM::XML::Term::Builder.new(path).tap do |t|
+        t.root_term= true
+      end
       term_opts = opts.dup
       term_opts.delete(:schema)
       root_term_builder.settings.merge!(term_opts)

data/lib/om/xml/terminology_based_solrizer.rb

@@ -15,7 +15,7 @@ module OM::XML::TerminologyBasedSolrizer
     def solrize(doc, solr_doc=Hash.new, field_mapper = nil)
       unless doc.class.terminology.nil?
         doc.class.terminology.terms.each_pair do |term_name,term|
-          doc.solrize_term(term, solr_doc, field_mapper)
+          doc.solrize_term(term, solr_doc, field_mapper) unless term.is_root_term?
         end
       end
 

data/om.gemspec

@@ -32,8 +32,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.extra_rdoc_files = [
-    "LICENSE",
-    "README.textile"
+    "LICENSE"
   ]
   s.require_paths = ["lib"]
 end

data/spec/integration/serialization_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'active_support/core_ext/string/conversions' # for String#to_time conversion
 
 describe "element values" do
   before(:all) do
@@ -20,7 +21,7 @@ describe "element values" do
 
 
   describe "when the xml template has existing values" do
-    subject do
+    let(:datastream) do
       ElementValueTerminology.from_xml <<-EOF
 <outer outerId="hypatia:outer" type="outer type">
   <my_date>2012-10-30</my_date>
@@ -30,6 +31,7 @@ describe "element values" do
 </outer>
 EOF
     end
+    subject { datastream } 
     describe "reading  values" do
       it "should deserialize date" do
         subject.my_date.should == [Date.parse('2012-10-30')]
@@ -45,26 +47,42 @@ 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>'
+      context "serializing time" do
+        context "with a valid time" do
+          subject { datastream.to_xml }
+          before { datastream.my_time = [DateTime.parse('2011-01-30T03:45:15Z')] }
+          it { 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
+
+        context "setting an invalid time" do
+          it "raises a type mismatch error" do
+            expect { datastream.my_time = '' }.to raise_error OM::TypeMismatch
+          end
+        end
       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>'
+
+      context "serializing dates" do
+
+        subject { datastream.to_xml }
+        context "with a valid date" do
+
+          before { datastream.my_date = [Date.parse('2012-09-22')] }
+          it { 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>' }
+        end
       end
+
       it "should serialize ints" do
         subject.my_int = [9]
         subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>

data/spec/integration/subclass_terminology_spec.rb

@@ -12,6 +12,9 @@ describe "Inherited terminology" do
       end
 
       class ConcreteTerminology < AbstractTerminology
+        extend_terminology do |t|
+          t.bar
+        end
       end
     end
 
@@ -20,7 +23,7 @@ describe "Inherited terminology" do
       Object.send(:remove_const, :AbstractTerminology)
     end
 
-    describe "on the subclass" do
+    describe "the subclass" do
       subject do
         xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
         ConcreteTerminology.from_xml(xml)
@@ -30,9 +33,14 @@ describe "Inherited terminology" do
         subject.foo = "Test value"
         subject.foo.should == ["Test value"]
       end
+
+      it "should have extended terminology" do
+        subject.bar = "Test value"
+        subject.bar.should == ["Test value"]
+      end
     end
 
-    describe "on the superclass" do
+    describe "the superclass" do
       subject do
         xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
         AbstractTerminology.from_xml(xml)
@@ -42,6 +50,10 @@ describe "Inherited terminology" do
         subject.foo = "Test value"
         subject.foo.should == ["Test value"]
       end
+
+      it "should not have extended terminology" do
+        expect { subject.bar }.to raise_error NoMethodError
+      end
     end
   end
 

data/spec/unit/container_spec.rb

@@ -54,7 +54,7 @@ describe "OM::XML::Container" do
     
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
       doc = Nokogiri::XML::Document.parse("<test_xml/>")
-      mock_new_node = mock("new node")
+      mock_new_node = double("new node")
       doc.root.should_receive(:add_child).with(subject.ng_xml.root).and_return(mock_new_node)
       result = subject.to_xml(doc)
     end
@@ -65,7 +65,7 @@ describe "OM::XML::Container" do
     end
     
     it 'should add to root of Nokogiri::XML::Documents, but add directly to the elements if a Nokogiri::XML::Node is passed in' do
-      mock_new_node = mock("new node")
+      mock_new_node = double("new node")
       mock_new_node.stub(:to_xml).and_return("foo")
       
       doc = Nokogiri::XML::Document.parse("<test_document/>")

data/spec/unit/dynamic_node_spec.rb

@@ -47,6 +47,11 @@ describe "OM::XML::DynamicNode" do
       @sample.date_created = ['A long time ago']
       @sample.date_created.should == ['A long time ago']
     end
+
+    it "checks inequality" do
+      @sample.foo = ['in a galaxy far far away']
+      expect(@sample.foo != ['nearby']).to be true
+    end
   end
         
   
@@ -80,6 +85,10 @@ describe "OM::XML::DynamicNode" do
         @article.person.last_name.first.should == "FAMILY NAME"
       end
 
+      it "should respond_to? things an array can do" do
+        expect(@article.person.last_name).to respond_to(:map)
+      end
+
       it "should delegate with blocks to the found array" do
         arr = []
         @article.person.last_name.each{|x| arr << x}
@@ -161,6 +170,20 @@ describe "OM::XML::DynamicNode" do
         @article.journal.title_info = %W(six seven)
         @article.journal.title_info.should == ["six", "seven"]
       end
+
+      describe '==' do
+        it "returns true when values of dynamic nodes are equal." do
+          @article.name(0).last_name = "Steven"
+          @article.name(0).first_name = "Steven"
+          (@article.name(0).last_name == @article.name(0).first_name).should == true
+        end
+
+        it 'returns false when values of dynamic nodes are not equal.' do
+          @article.name(0).first_name = "Horatio"
+          @article.name(0).last_name = "Hogginobble"
+          (@article.name(0).last_name == @article.name(0).first_name).should == false
+        end
+      end 
     end
   end
 end

data/spec/unit/term_builder_spec.rb

@@ -33,7 +33,7 @@ describe "OM::XML::Term::Builder" do
   
   describe '#new' do
    it "should set terminology_builder attribute if provided" do
-     mock_terminology_builder = mock("TerminologyBuilder")
+     mock_terminology_builder = double("TerminologyBuilder")
      OM::XML::Term::Builder.new("term1", mock_terminology_builder).terminology_builder.should == mock_terminology_builder
    end
   end
@@ -41,17 +41,19 @@ describe "OM::XML::Term::Builder" do
   describe "configuration methods" do
     it "should set the corresponding .settings value return the mapping object" do
       [:path, :index_as, :required, :type, :variant_of, :path, :attributes, :default_content_path].each do |method_name|
-        @test_builder.send(method_name, "#{method_name.to_s}foo").should == @test_builder
+        @test_builder.send("#{method_name}=".to_sym, "#{method_name.to_s}foo")
         @test_builder.settings[method_name].should == "#{method_name.to_s}foo"
       end
     end
-    it "should be chainable" do
-      test_builder = OM::XML::Term::Builder.new("chainableTerm").index_as(:facetable, :searchable, :sortable, :displayable).required(true).type(:text)  
-      resulting_settings = test_builder.settings
-      resulting_settings[:index_as].should == [:facetable, :searchable, :sortable, :displayable]
-      resulting_settings[:required].should == true 
-      resulting_settings[:type].should == :text
-    end
+    # it "should be chainable" do
+    #   test_builder = OM::XML::Term::Builder.new("chainableTerm").tap do |t|
+    #     t.index_as = [:facetable, :searchable, :sortable, :displayable).required(true).type(:text)  
+    #   end
+    #   resulting_settings = test_builder.settings
+    #   resulting_settings[:index_as].should == [:facetable, :searchable, :sortable, :displayable]
+    #   resulting_settings[:required].should == true 
+    #   resulting_settings[:type].should == :text
+    # end
   end
 
   describe "settings" do
@@ -70,7 +72,6 @@ describe "OM::XML::Term::Builder" do
     it "should insert the given Term Builder into the current Term Builder's children" do
       @test_builder.add_child(@test_builder_2)
       @test_builder.children[@test_builder_2.name].should == @test_builder_2
-      @test_builder.ancestors.should include(@test_builder_2)
     end
   end
   describe ".retrieve_child" do
@@ -88,7 +89,11 @@ describe "OM::XML::Term::Builder" do
   
   describe ".build" do
     it "should build a Term with the given settings and generate its xpath values" do
-      test_builder = OM::XML::Term::Builder.new("requiredTextFacet").index_as([:facetable, :searchable, :sortable, :displayable]).required(true).type(:text)  
+      test_builder = OM::XML::Term::Builder.new("requiredTextFacet").tap do |t|
+        t.index_as = [:facetable, :searchable, :sortable, :displayable]
+        t.required = true
+        t.type = :text
+      end
       result = test_builder.build
       result.should be_instance_of OM::XML::Term
       result.index_as.should == [:facetable, :searchable, :sortable, :displayable]
@@ -100,7 +105,9 @@ describe "OM::XML::Term::Builder" do
       result.xpath_relative.should == OM::XML::TermXpathGenerator.generate_relative_xpath(result)
     end
     it "should create proxy terms if :proxy is set" do
-      test_builder = OM::XML::Term::Builder.new("my_proxy").proxy([:foo, :bar])
+      test_builder = OM::XML::Term::Builder.new("my_proxy").tap do |t|
+        t.proxy = [:foo, :bar]
+      end
       result = test_builder.build
       result.should be_kind_of OM::XML::NamedTermProxy
     end
@@ -113,8 +120,8 @@ describe "OM::XML::Term::Builder" do
       built_child1 = OM::XML::Term.new("child1")
       built_child2 = OM::XML::Term.new("child2")
 
-      mock1 = mock("Builder1", :build => built_child1 )
-      mock2 = mock("Builder2", :build => built_child2 )
+      mock1 = double("Builder1", :build => built_child1 )
+      mock2 = double("Builder2", :build => built_child2 )
       mock1.stub(:name).and_return("child1")
       mock2.stub(:name).and_return("child2")
 
@@ -137,10 +144,17 @@ describe "OM::XML::Term::Builder" do
 	    @almond.lookup_refs.should == [@peach, @stone_fruit]
 	  end
   	it "should raise an error if the TermBuilder does not have a reference to a terminology builder" do
-  	  lambda { OM::XML::Term::Builder.new("referrer").ref("bongos").lookup_refs }.should raise_error(StandardError,"Cannot perform lookup_ref for the referrer builder.  It doesn't have a reference to any terminology builder")
+  	  lambda { 
+        OM::XML::Term::Builder.new("referrer").tap do |t|
+          t.ref="bongos"
+          t.lookup_refs 
+        end
+      }.should raise_error(StandardError,"Cannot perform lookup_ref for the referrer builder.  It doesn't have a reference to any terminology builder")
 	  end
     it "should raise an error if the referece points to a nonexistent term builder" do
-      tb = OM::XML::Term::Builder.new("mork",@test_terminology_builder).ref(:characters, :aliens)
+      tb = OM::XML::Term::Builder.new("mork",@test_terminology_builder).tap do |t|
+        t.ref = [:characters, :aliens]
+      end
       lambda { tb.lookup_refs }.should raise_error(OM::XML::Terminology::BadPointerError,"This TerminologyBuilder does not have a root TermBuilder defined that corresponds to \":characters\"")
     end
     it "should raise an error with informative error when given circular references" do
@@ -158,7 +172,9 @@ describe "OM::XML::Term::Builder" do
       @test_builder.children.should == children_pre
     end
     it "should should look up the referenced TermBuilder, use its settings and duplicate its children without changing the name" do
-      term_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus)
+      term_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).tap do |b|
+        b.ref = [:fruit_trees, :citrus]
+      end
       term_builder.resolve_refs!
       # Make sure children and settings were copied
       term_builder.settings.should == @citrus.settings.merge(:path=>"citrus")
@@ -174,7 +190,9 @@ describe "OM::XML::Term::Builder" do
       @almond.settings[:path].should == "prunus"
     end
     it "should set path based on the first ref's name if no path is set" do
-      orange_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus)
+      orange_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).tap do |b|
+        b.ref= [:fruit_trees, :citrus]
+      end
       orange_builder.resolve_refs!
       orange_builder.settings[:path].should == "citrus"
     end
@@ -182,7 +200,11 @@ describe "OM::XML::Term::Builder" do
     it "should result in clean trees of Terms after building" 
     
   	it "should preserve any extra settings specific to this builder (for variant terms)" do
-  	  tb = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus).attributes(:color=>"orange").required(true)
+  	  tb = OM::XML::Term::Builder.new("orange",@test_terminology_builder).tap do |b|
+        b.ref= [:fruit_trees, :citrus]
+        b.attributes = {color: "orange"}
+        b.required =true
+      end
   	  tb.resolve_refs!
   	  tb.settings.should == {:path=>"citrus", :attributes=>{"citric_acid"=>"true", :color=>"orange"}, :required=>true, :type=>:string, :index_as=>[:facetable]}
 	  end

data/spec/unit/term_spec.rb

@@ -75,8 +75,8 @@ describe OM::XML::Term do
 
     describe ".retrieve_term" do
       it "should crawl down into mapper children to find the desired term" do
-        mock_role = mock("mapper", :children =>{:text=>"the target"})
-        mock_conference = mock("mapper", :children =>{:role=>mock_role})
+        mock_role = double("mapper", :children =>{:text=>"the target"})
+        mock_conference = double("mapper", :children =>{:role=>mock_role})
         @test_name_part.should_receive(:children).and_return({:conference=>mock_conference})
         @test_name_part.retrieve_term(:conference, :role, :text).should == "the target"
       end
@@ -185,7 +185,7 @@ describe OM::XML::Term do
         @test_volume.xpath_constrained.should == '//detail[@type="volume" and contains(number, "#{constraint_value}")]'.gsub('"', '\"')
       end
       it "should trigger update on any child objects" do
-        mock_child = mock("child term")
+        mock_child = double("child term")
         mock_child.should_receive(:generate_xpath_queries!).exactly(3).times
         @test_name_part.should_receive(:children).and_return({1=>mock_child, 2=>mock_child, 3=>mock_child})
         @test_name_part.generate_xpath_queries!

data/spec/unit/term_xpath_generator_spec.rb

@@ -68,7 +68,7 @@ describe "OM::XML::TermXpathGeneratorSpec" do
       OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term).should == '//namePart[@type="termsOfAddress"]'
     end
     it "should prepend the xpath for any parent nodes" do
-      mock_parent_mapper = mock("Term", :xpath_absolute=>'//name[@type="conference"]/role')
+      mock_parent_mapper = double("Term", :xpath_absolute=>'//name[@type="conference"]/role')
       @test_role_text.stub(:parent => mock_parent_mapper)
       OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_role_text).should == '//name[@type="conference"]/role/roleTerm[@type="text"]'
     end

data/spec/unit/xml_terminology_based_solrizer_spec.rb

@@ -29,6 +29,7 @@ describe OM::XML::TerminologyBasedSolrizer do
       solr_doc = Hash.new
       @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)
       end
       @mods_article.to_solr(solr_doc)