solr_ead 0.7.1 → 0.7.2

data/Rakefile

@@ -1,9 +1,9 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
 require "rspec/core/rake_task"
-require "jettywrapper"
 Bundler::GemHelper.install_tasks
+
 # load rake tasks in lib/tasks
 Dir.glob('lib/tasks/*.rake').each { |r| import r }
+
 RSpec::Core::RakeTask.new(:spec)
-task :default => :ci
+task :default => :ci

data/lib/solr_ead/indexer.rb

@@ -123,13 +123,13 @@ class Indexer
   # Determines the url to our solr service by consulting yaml files
   def solr_url
     if defined?(Rails.root)
-      YAML.load(ERB.new(File.read(File.join(Rails.root,"config","solr.yml"))).result)[Rails.env]['url']
+      ::YAML.load(ERB.new(File.read(File.join(Rails.root,"config","solr.yml"))).result)[Rails.env]['url']
     elsif ENV['RAILS_ENV']
-      YAML.load(ERB.new(File.read("config/solr.yml")).result)[ENV['RAILS_ENV']]['url']
+      ::YAML.load(ERB.new(File.read("config/solr.yml")).result)[ENV['RAILS_ENV']]['url']
     else
-      YAML.load(ERB.new(File.read("config/solr.yml")).result)['development']['url']
+      ::YAML.load(ERB.new(File.read("config/solr.yml")).result)['development']['url']
     end
   end
 
 end
-end
+end

data/lib/solr_ead/version.rb

@@ -1,3 +1,3 @@
 module SolrEad
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

data/lib/solr_ead.rb

@@ -3,6 +3,10 @@ require 'solrizer'
 require 'om'
 require 'rsolr'
 require 'active_support'
+require 'yaml'
+
+# Load these rake tasks when the gem is included in a Rails application
+Dir[File.expand_path(File.join(File.dirname(__FILE__),"../tasks/*.rake"))].each { |ext| load ext } if defined?(Rake)
 
 module SolrEad
   extend ActiveSupport::Autoload
@@ -13,9 +17,8 @@ module SolrEad
   autoload :Indexer
   autoload :Document
   autoload :Component
-  autoload :Railtie if defined?(Rails)
 
   def self.version
     SolrEad::VERSION
   end
-end
+end

data/lib/tasks/dev.rake

@@ -0,0 +1,9 @@
+require 'jettywrapper'
+Jettywrapper.url = "https://github.com/awead/solr-jetty/archive/v1.zip"
+
+desc "Travis continuous integration task"
+task :ci do
+  Rake::Task["jetty:clean"].invoke
+  Rake::Task["jetty:start"].invoke
+  Rake::Task["spec"].invoke
+end

data/solr_ead.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |gem|
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
   gem.name          = "solr_ead"
   gem.require_paths = ["lib"]
   gem.version       = SolrEad::VERSION
@@ -26,7 +26,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'redcarpet'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'debugger'
+  gem.add_development_dependency 'byebug'
   gem.add_development_dependency 'rdoc'
   gem.add_development_dependency 'jettywrapper'
 end

data/spec/behaviors_spec.rb

@@ -2,51 +2,42 @@ require "spec_helper"
 
 describe SolrEad::Behaviors do
 
-  before :all do
-    @not_numbered = fixture "ARC-0005.xml"
-    @numbered     = fixture "pp002010.xml"
-    @messy        = fixture "ead_messy_format.xml"
-    class TestClass
-      include SolrEad::Behaviors
-    end
-    @test = TestClass.new
+  class TestClass
+    include SolrEad::Behaviors
   end
 
   describe "#components" do
 
-    before :all do
-      @non_numbered_nodeset = @test.components(@not_numbered)
-      @numbered_nodeset     = @test.components(@numbered)
-      @messy_nodeset        = @test.components(@messy)
-    end
+    let(:non_numbered_nodeset)  { TestClass.new.components(fixture("ARC-0005.xml")) }
+    let(:numbered_nodeset)      { TestClass.new.components(fixture("pp002010.xml")) }
+    let(:messy_nodeset)         { TestClass.new.components(fixture("ead_messy_format.xml")) }
 
     it "should return a nodeset" do
-      @non_numbered_nodeset.should be_a_kind_of(Nokogiri::XML::NodeSet)
-      @non_numbered_nodeset.first.should be_a_kind_of(Nokogiri::XML::Element)
+      expect(non_numbered_nodeset).to be_a_kind_of(Nokogiri::XML::NodeSet)
+      expect(non_numbered_nodeset.first).to be_a_kind_of(Nokogiri::XML::Element)
     end
 
     it "should be able to handle both numbered and non-numbered <c> nodes" do
-      @non_numbered_nodeset.count.should == 135
-      @numbered_nodeset.count.should == 83
+      expect(non_numbered_nodeset.count).to eq(135)
+      expect(numbered_nodeset.count).to eq(83)
     end
     
     it "should find some components even if ead is messily formatted" do
-      @messy_nodeset.count.should > 0
+      expect(messy_nodeset.count).to be > 0
     end
     
   end
 
   describe "#prep" do
+    let(:subject) { TestClass.new.prep(fixture("pp002010.xml")) }
     it "should return a single component document" do
-      part = @test.prep(@numbered_nodeset)
-      part.should be_a_kind_of(Nokogiri::XML::Document)
+      expect(subject).to be_a_kind_of(Nokogiri::XML::Document)
     end
   end
 
   describe "#component_children?" do
-
-    before :all do
-      @true = '
+    let(:true_node) do
+      Nokogiri::XML('
         <c id="ref167" level="file">
           <did>
             <unittitle>Zines</unittitle>
@@ -68,27 +59,27 @@ describe SolrEad::Behaviors do
             </did>
           </c>
         </c>
-      '
-      @false = '
+      ')
+    end
+
+    let(:false_node) do
+      Nokogiri::XML('
         <c id="ref167" level="file">
           <did>
             <unittitle>Zines</unittitle>
           </did>
         </c>
-      '
+      ')
     end
 
-
     it "should return true for components that have c nodes below them" do
-      node = Nokogiri::XML(@true)
-      @test.component_children?(node.elements.first).should be_true
+      expect(TestClass.new.component_children?(true_node.elements.first)).to be true
     end
 
     it "should return false for components that do not have c nodes below them" do
-      node = Nokogiri::XML(@false)
-      @test.component_children?(node.elements.first).should be_false
+      expect(TestClass.new.component_children?(false_node.elements.first)).to be false
     end
 
   end
 
-end
+end

data/spec/component_spec.rb

@@ -2,40 +2,35 @@ require "spec_helper"
 
 describe SolrEad::Component do
 
-  describe "the solr document" do
+  context "with parent components" do
 
-    before :all do
-      file = "component_template.xml"
-      @doc = SolrEad::Component.from_xml(fixture file)
+    let(:subject) do
+      additional_fields = {
+        "id"                                                        => "TEST-0001ref010",
+        Solrizer.solr_name("ead", :stored_sortable)                 => "TEST-0001",
+        Solrizer.solr_name("parent", :stored_sortable)              => "ref001",
+        Solrizer.solr_name("parent", :displayable)                  => ["ref001", "ref002", "ref003"],
+        Solrizer.solr_name("parent_unittitles", :displayable)       => ["Series I", "Subseries A", "Subseries 1"],
+        Solrizer.solr_name("component_children", :type => :boolean) => FALSE
+      }
+      SolrEad::Component.from_xml(fixture "component_template.xml").to_solr(additional_fields)
     end
 
-    describe "for item-level components" do
+    it "should accept additional fields from a hash" do
+      expect(subject["id"]).to eq("TEST-0001ref010")
+      expect(subject[Solrizer.solr_name("level", :facetable)]).to include "item"
+      expect(subject[Solrizer.solr_name("accessrestrict", :displayable)].first).to match /^This item .* is available.$/
+    end
 
-      before :each do
-        additional_fields = {
-          "id" => "TEST-0001ref010",
-          Solrizer.solr_name("ead", :stored_sortable)                 => "TEST-0001",
-          Solrizer.solr_name("parent", :stored_sortable)              => "ref001",
-          Solrizer.solr_name("parent", :displayable)                  => ["ref001", "ref002", "ref003"],
-          Solrizer.solr_name("parent_unittitles", :displayable)       => ["Series I", "Subseries A", "Subseries 1"],
-          Solrizer.solr_name("component_children", :type => :boolean) => FALSE
-        }
-        @solr_doc = @doc.to_solr(additional_fields)
-      end
+    it "should create fields using type" do
+      expect(subject[Solrizer.solr_name("ref", :stored_sortable)]).to eq("ref215")
+    end
 
-      it "should accept additional fields from a hash" do
-        @solr_doc["id"].should == "TEST-0001ref010"
-        @solr_doc[Solrizer.solr_name("level", :facetable)].should include "item"
-        @solr_doc[Solrizer.solr_name("accessrestrict", :displayable)].first.should match /^This item .* is available.$/
-      end
+  end
 
-      it "should create fields using type" do
-        @solr_doc[Solrizer.solr_name("ref", :stored_sortable)].should == "ref215"
-      end
+  context "without parent components" do
 
-    end
-
-    it "should format heading_display with only one element" do
+    let(:subject) do
       additional_fields = {
         "id"                                                        => "TEST-0001ref010",
         Solrizer.solr_name("ead", :stored_sortable)                 => "TEST-0001",
@@ -44,25 +39,21 @@ describe SolrEad::Component do
         Solrizer.solr_name("parent_unittitles", :displayable)       => [],
         Solrizer.solr_name("component_children", :type => :boolean) => FALSE
       }
-      solr_doc = @doc.to_solr(additional_fields)
-      solr_doc["id"].should == "TEST-0001ref010"
-      solr_doc[Solrizer.solr_name("level", :facetable)].should include "item"
-      solr_doc[Solrizer.solr_name("accessrestrict", :displayable)].first.should match /^This item .* is available.$/
-    end       
+      SolrEad::Component.from_xml(fixture "component_template.xml").to_solr(additional_fields)
+    end
+    it "should format heading_display with only one element" do
+      expect(subject["id"]).to eq("TEST-0001ref010")
+      expect(subject[Solrizer.solr_name("level", :facetable)]).to include "item"
+      expect(subject[Solrizer.solr_name("accessrestrict", :displayable)].first).to match /^This item .* is available.$/
+    end
 
-  end
+  end    
 
   describe "formatting fields as html" do
-
-    before :all do
-      file = "html_component.xml"
-      @sample = SolrEad::Component.from_xml(fixture file)
-    end
-
+    let(:subject) { SolrEad::Component.from_xml(fixture "html_component.xml") }
     it "should format as term as html" do
-      @sample.term_to_html("scopecontent").should include "<em>OPAL</em> "
+      expect(subject.term_to_html("scopecontent")).to include "<em>OPAL</em> "
     end
-
   end
 
-end
+end

data/spec/document_spec.rb

@@ -2,77 +2,76 @@ require "spec_helper"
 
 describe SolrEad::Document do
 
-  before(:all) do
-    @ex1 = SolrEad::Document.from_xml(fixture "ARC-0005.xml")
-    @ex2 = SolrEad::Document.from_xml(fixture "pp002010.xml")
-    @ex3 = SolrEad::Document.from_xml(fixture "ARC-0161.xml")
-    @solr_ex1 = @ex1.to_solr
-    @solr_ex2 = @ex2.to_solr
-    @solr_ex3 = @ex3.to_solr
-  end
-
   describe "#terminology" do
 
+    let(:ex1) { SolrEad::Document.from_xml(fixture "ARC-0005.xml") }
+    let(:ex2) { SolrEad::Document.from_xml(fixture "pp002010.xml") }
+    let(:ex3) { SolrEad::Document.from_xml(fixture "ARC-0161.xml") }
+
     it "should have an id field" do
-      @ex1.eadid.first.should == "ARC-0005"
+      expect(ex1.eadid.first).to eq("ARC-0005")
     end
 
     it "should have a simple title" do
-      @ex1.title.first.should match "Eddie Cochran Historical Organization Collection"
+      expect(ex1.title.first).to match "Eddie Cochran Historical Organization Collection"
     end
 
     it "should have some subject headings" do
-      @ex1.persname.should  include "Cochran, Eddie, 1938-1960"
-      @ex1.genreform.should include "Newspapers"
-      @ex1.subject.should   include "Rockabilly music"
-      @ex2.corpname.should  include "Tuskegee Normal and Industrial Institute--1880-1940."
-      @ex2.genreform.should include "Group portraits--1880-1940."
-      @ex2.geogname.should  include "Washington, D.C."
-      @ex2.name.should      include "Bell, J.S., Portland, OR"
-      @ex2.persname.should  include "Johnston, Frances Benjamin, 1864-1952, photographer."
-      @ex2.subject.should   include "Buildings--1880-1940."
+      expect(ex1.persname).to  include "Cochran, Eddie, 1938-1960"
+      expect(ex1.genreform).to include "Newspapers"
+      expect(ex1.subject).to   include "Rockabilly music"
+      expect(ex2.corpname).to  include "Tuskegee Normal and Industrial Institute--1880-1940."
+      expect(ex2.genreform).to include "Group portraits--1880-1940."
+      expect(ex2.geogname).to  include "Washington, D.C."
+      expect(ex2.name).to      include "Bell, J.S., Portland, OR"
+      expect(ex2.persname).to  include "Johnston, Frances Benjamin, 1864-1952, photographer."
+      expect(ex2.subject).to   include "Buildings--1880-1940."
     end
 
     it "should have scope and contents" do
-      @ex2.scopecontent.first.should match /^Photographs/
+      expect(ex2.scopecontent.first).to match /^Photographs/
     end
 
     it "should have one separatedmaterial material note from the archdesc section" do
-      @ex1.separatedmaterial.first.should match /^Commercially-released publications.*materials are available.$/
+      expect(ex1.separatedmaterial.first).to match /^Commercially-released publications.*materials are available.$/
     end
 
     it "should have its xml" do
-      @ex1.to_xml.should match "<c\s"
-      @ex2.to_xml.should match "<c01\s"\
+      expect(ex1.to_xml).to match "<c\s"
+      expect(ex2.to_xml).to match "<c01\s"\
     end
 
     it "should have a bibliography" do
-      @ex3.bibliography.first.should == "All Music Guide. Accessed February 4, 2013. http://www.allmusic.com/."
+      expect(ex3.bibliography.first).to eq("All Music Guide. Accessed February 4, 2013. http://www.allmusic.com/.")
     end
 
   end
 
   describe ".to_solr" do
 
+    let(:ex1) { SolrEad::Document.from_xml(fixture "ARC-0005.xml").to_solr }
+    let(:ex2) { SolrEad::Document.from_xml(fixture "pp002010.xml").to_solr }
+    let(:ex3) { SolrEad::Document.from_xml(fixture "ARC-0161.xml").to_solr }
+
     it "should have the appropriate id fields" do
-      @solr_ex2["id"].should      == "http://hdl.loc.gov/loc.pnp/eadpnp.pp002010"
-      @solr_ex1["id"].should      == "ARC-0005"
-      @solr_ex2[Solrizer.solr_name("ead", :stored_sortable)].should  == "http://hdl.loc.gov/loc.pnp/eadpnp.pp002010"
-      @solr_ex1[Solrizer.solr_name("ead", :stored_sortable)].should  == "ARC-0005"
+      expect(ex2["id"]).to      eq("http://hdl.loc.gov/loc.pnp/eadpnp.pp002010")
+      expect(ex1["id"]).to      eq("ARC-0005")
+      expect(ex2[Solrizer.solr_name("ead", :stored_sortable)]).to  eq("http://hdl.loc.gov/loc.pnp/eadpnp.pp002010")
+      expect(ex1[Solrizer.solr_name("ead", :stored_sortable)]).to  eq("ARC-0005")
     end
 
     it "should have faceted terms created from subject headings" do
-      @solr_ex1[Solrizer.solr_name("persname", :facetable)].should include "Cochran, Eddie, 1938-1960"
-      @solr_ex1[Solrizer.solr_name("genreform", :facetable)].should include "Newspapers"
-      @solr_ex1[Solrizer.solr_name("subject", :facetable)].should include "Rockabilly music"
-      @solr_ex2[Solrizer.solr_name("corpname", :facetable)].should include "Tuskegee Normal and Industrial Institute--1880-1940."
-      @solr_ex2[Solrizer.solr_name("genreform", :facetable)].should include "Group portraits--1880-1940."
-      @solr_ex2[Solrizer.solr_name("geogname", :facetable)].should include "Washington, D.C."
-      @solr_ex2[Solrizer.solr_name("name", :facetable)].should include "Bell, J.S., Portland, OR"
-      @solr_ex2[Solrizer.solr_name("persname", :facetable)].should include "Johnston, Frances Benjamin, 1864-1952, photographer."
-      @solr_ex2[Solrizer.solr_name("subject", :facetable)].should include "Buildings--1880-1940."
+      expect(ex1[Solrizer.solr_name("persname", :facetable)]).to include "Cochran, Eddie, 1938-1960"
+      expect(ex1[Solrizer.solr_name("genreform", :facetable)]).to include "Newspapers"
+      expect(ex1[Solrizer.solr_name("subject", :facetable)]).to include "Rockabilly music"
+      expect(ex2[Solrizer.solr_name("corpname", :facetable)]).to include "Tuskegee Normal and Industrial Institute--1880-1940."
+      expect(ex2[Solrizer.solr_name("genreform", :facetable)]).to include "Group portraits--1880-1940."
+      expect(ex2[Solrizer.solr_name("geogname", :facetable)]).to include "Washington, D.C."
+      expect(ex2[Solrizer.solr_name("name", :facetable)]).to include "Bell, J.S., Portland, OR"
+      expect(ex2[Solrizer.solr_name("persname", :facetable)]).to include "Johnston, Frances Benjamin, 1864-1952, photographer."
+      expect(ex2[Solrizer.solr_name("subject", :facetable)]).to include "Buildings--1880-1940."
     end
 
   end
 
-end
+end

data/spec/formatting_spec.rb

@@ -2,25 +2,24 @@ require 'spec_helper'
 
 describe SolrEad::Formatting do
 
-  before :all do
+  let(:subject) do
     class SampleClass
       include SolrEad::Formatting
     end
-    @sample = SampleClass.new
+    return SampleClass.new
   end
 
   describe "#ead_to_html" do
     
     it "should convert ead markup to html" do
       xml = 'This is some text with <title render="italics">italics</title> included in it.'
-      @sample.ead_to_html(xml).should == 'This is some text with <em>italics</em> included in it.'
+      expect(subject.ead_to_html(xml)).to eq('This is some text with <em>italics</em> included in it.')
     end
 
     it "should remove other tags" do
       xml = 'Blah blah <title render="italics">italics</title> blah <span>blah</span> <title render="bold">italics</title>'
-      @sample.ead_to_html(xml).should == 'Blah blah <em>italics</em> blah blah <strong>italics</strong>'      
+      expect(subject.ead_to_html(xml)).to eq('Blah blah <em>italics</em> blah blah <strong>italics</strong>')      
     end
   end
 
-
-end
+end

data/spec/indexer_spec.rb

@@ -2,112 +2,103 @@ require "spec_helper"
 
 describe SolrEad::Indexer do
 
-  before :all do
-    @file = fixture "ARC-0005.xml"
-  end
+  let(:file) { fixture "ARC-0005.xml" }
 
   describe "indexing an ead document into multiple solr documents" do
 
-    before :each do
-      @indexer = SolrEad::Indexer.new
-    end
+    let(:indexer) { SolrEad::Indexer.new }
 
     it "should index a new ead from a file" do
-      @indexer.create(@file)
-      q = @indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
-      q["response"]["numFound"].should == 136
+      indexer.create(file)
+      q = indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
+      expect(q["response"]["numFound"]).to eq(136)
     end
 
-
     it "should update an ead from a file" do
-      @indexer.update(@file)
-      q = @indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
-      q["response"]["numFound"].should == 136
+      indexer.update(file)
+      q = indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
+      expect(q["response"]["numFound"]).to eq(136)
     end
 
     it "should delete and ead give an id" do
-      @indexer.delete("ARC-0005")
-      q = @indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
-      q["response"]["numFound"].should == 0
+      indexer.delete("ARC-0005")
+      q = indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
+      expect(q["response"]["numFound"]).to eq(0)
     end
 
   end
 
   describe "indexing ead document into one solr document" do
 
-    before :each do
-      @simple_indexer = SolrEad::Indexer.new(:simple => true)
-    end
+    let(:indexer) { SolrEad::Indexer.new(:simple => true) }
 
     it "should be set to use the simple option" do
-      @simple_indexer.options[:simple].should be_true
+      expect(indexer.options[:simple]).to be true
     end
 
     it "should index a new ead from a file as a single solr document" do
-      @simple_indexer.create(@file)
-      q = @simple_indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
-      q["response"]["numFound"].should == 1
+      indexer.create(file)
+      q = indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
+      expect(q["response"]["numFound"]).to eq(1)
     end
 
     it "should delete a single ead" do
-      @simple_indexer.delete("ARC-0005")
-      q = @simple_indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
-      q["response"]["numFound"].should == 0
+      indexer.delete("ARC-0005")
+      q = indexer.solr.get 'select', :params => {:q=>Solrizer.solr_name("ead", :stored_sortable)+':"ARC-0005"', :qt=>'document'}
+      expect(q["response"]["numFound"]).to eq(0)
     end
 
   end
 
   describe "specifying custom om definitions" do
 
-    before :all do
-      class CustomDocument < SolrEad::Document
-        include OM::XML::Document
-        include OM::XML::TerminologyBasedSolrizer
-        include SolrEad::OmBehaviors
-        set_terminology do |t|
-          t.root(:path=>"ead", :index_as => [:not_searchable])
-          t.title
-          t.eadid
-          t.title_num
-        end
+    class CustomDocument < SolrEad::Document
+      include OM::XML::Document
+      include OM::XML::TerminologyBasedSolrizer
+      include SolrEad::OmBehaviors
+      set_terminology do |t|
+        t.root(:path=>"ead", :index_as => [:not_searchable])
+        t.title
+        t.eadid
+        t.title_num
       end
+    end
 
-      class CustomComponent < SolrEad::Component
-        include OM::XML::Document
-        include OM::XML::TerminologyBasedSolrizer
-        set_terminology do |t|
-          t.root(:path=>"c", :index_as => [:not_searchable, :not_displayable])
-          t.ref(:path=>"/c/@id")
-          t.level(:path=>"/c/@level", :index_as => [:facetable])
-          t.title(:path=>"unittitle", :attributes=>{ :type => :none }, :index_as=>[:searchable, :displayable])
-        end
+    class CustomComponent < SolrEad::Component
+      include OM::XML::Document
+      include OM::XML::TerminologyBasedSolrizer
+      set_terminology do |t|
+        t.root(:path=>"c", :index_as => [:not_searchable, :not_displayable])
+        t.ref(:path=>"/c/@id")
+        t.level(:path=>"/c/@level", :index_as => [:facetable])
+        t.title(:path=>"unittitle", :attributes=>{ :type => :none }, :index_as=>[:searchable, :displayable])
       end
     end
 
     it "should raise an error if you use an undefined class" do
-      lambda {SolrEad::Indexer.new(:document => BogusClass)}.should raise_error NameError
+      expect {SolrEad::Indexer.new(:document => BogusClass)}.to raise_error NameError
     end
 
     it "should accept a document definition" do
       indexer = SolrEad::Indexer.new(:document => CustomDocument)
-      indexer.create(@file)
+      indexer.create(file)
     end
 
     it "should accept a component definition" do
       indexer = SolrEad::Indexer.new(:component => CustomComponent)
-      indexer.create(@file)
+      indexer.create(file)
     end
 
     it "should accept a simple custom document definition" do
       indexer = SolrEad::Indexer.new(:document => CustomDocument, :stored_sortable=>true)
-      indexer.create(@file)
+      indexer.create(file)
     end
 
     it "should accept both custom definitions and components" do
       indexer = SolrEad::Indexer.new(:document => CustomDocument, :component => CustomComponent)
-      indexer.create(@file)
+      indexer.create(file)
     end
 
   end
 
-end
+end

data/spec/spec_helper.rb

@@ -1,18 +1,9 @@
 # :nodoc
 require "solr_ead"
-require "debugger"
+require "byebug" unless ENV['TRAVIS']
 
 RSpec.configure do |config|
-
-  # == Mock Framework
-  # Note: we're not mocking... yet.
-  # config.mock_with :mocha
-  # config.mock_with :flexmock
-  # config.mock_with :rr
-  #config.mock_with :rspec
-
   config.color = true
-
 end
 
 def fixture(file) #:nodoc
@@ -27,4 +18,4 @@ def debug_solr_doc(doc) #:nodoc
       puts doc[key]
     end
   end
-end
+end

data/{lib/tasks → tasks}/solr_ead.rake

@@ -45,4 +45,4 @@ def load_indexer
   options[:simple] = (ENV['SIMPLE'] or ENV['SIMPLE']=="true") ? true : false
   indexer = SolrEad::Indexer.new(options)
   return indexer
-end
+end