active-fedora 4.0.0.rc12 → 4.0.0.rc13

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active-fedora (4.0.0.rc12)
+    active-fedora (4.0.0.rc13)
       activeresource (>= 3.0.0)
       activesupport (>= 3.0.0)
       equivalent-xml

data/History.txt

@@ -1,4 +1,4 @@
-4.0.0.rc12
+4.0.0.rc13
 Removed deprecations
   * allowing :fedora level in fedora.yml
   * automatic includes of Relationships and FileMethods is removed
@@ -20,6 +20,7 @@ HYDRA-758 Added ActiveFedora::Base.exists?
 Fixes for Ruby 1.9 compatibility
 HYDRA-741 Use fixture loader in repo:* rake tasks. Parameters changed to foxml and dir.
 rubydora to 0.5.7
+Lazily load solr config
 
 3.3.2
 HYDRA-745 No need to require :url be present on external datastreams

data/lib/active_fedora/file_configurator.rb

@@ -44,7 +44,7 @@ module ActiveFedora
     #     url: http://127.0.0.1:8983/fedora2
     #
 
-    attr_accessor :solr_config, :config_env
+    attr_accessor :config_env
     attr_reader :config_options, :fedora_config_path, :solr_config_path
 
     # The configuration hash that gets used by RSolr.connect
@@ -66,6 +66,10 @@ module ActiveFedora
       load_configs
       @fedora_config
     end
+    def solr_config
+      load_configs
+      @solr_config
+    end
 
     def config_reload!
       ActiveSupport::Deprecation.warn("config_reload! is not supported")
@@ -80,6 +84,7 @@ module ActiveFedora
     def reset!
       @config_loaded = false  #Force reload of configs
       @fedora_config = {}
+      @solr_config = {}
       @config_options = {}
       @predicate_config_path = nil
     end
@@ -92,48 +97,25 @@ module ActiveFedora
       return if config_loaded?
       @config_env = ActiveFedora.environment
       
+      load_fedora_config
+      load_solr_config
+      @config_loaded = true
+    end
+
+    def load_fedora_config
+      return @fedora_config unless @fedora_config.empty?
       config_path = get_config_path(:fedora)
       @fedora_config = YAML.load(File.open(config_path))[@config_env] || {}
-      load_config(:solr)
-      @config_loaded = true
     end
 
-    def load_config(config_type)
-      config_path = get_config_path(config_type)
-      config_type = config_type.to_s
-      self.instance_variable_set "@#{config_type}_config_path".to_sym, config_path
-      config_path = self.send("#{config_type}_config_path".to_sym)
+    def load_solr_config
+      return @solr_config unless @solr_config.empty?
+      @solr_config_path = get_config_path(:solr)
 
-      logger.info("#{config_type.upcase}: loading ActiveFedora.#{config_type}_config from #{File.expand_path(config_path)}")
-      config = YAML.load(File.open(config_path)).symbolize_keys
-      raise "The #{@config_env.to_sym} environment settings were not found in the #{config_type}.yml config.  If you already have a #{config_type}.yml file defined, make sure it defines settings for the #{@config_env} environment" unless config[@config_env.to_sym]
-    
-      config[:url] = determine_url(config_type,config)
-
-      self.instance_variable_set("@#{config_type}_config", config)
-      config
-    end
-
-    # Determines and sets the fedora_config[:url] or solr_config[:url]
-    # @param [String] config_type Either 'fedora' or 'solr'
-    # @param [Hash] config The config hash 
-    # @return [String] the solr or fedora url
-    def determine_url(config_type,config)  
-      c = config[ActiveFedora.environment.to_sym]
-      c.symbolize_keys!
-      if config_type == "fedora"
-        url =  c[:url]
-        if url && !c[:user]
-          u = URI.parse url
-          c[:user] = u.user
-          c[:password] = u.password
-          c[:url] = "#{u.scheme}://#{u.host}:#{u.port}#{u.path}"
-          url = c[:url]
-        end
-        return url
-      else
-        return get_solr_url(c) if config_type == "solr"
-      end
+      logger.info("ActiveFedora: loading solr config from #{File.expand_path(@solr_config_path)}")
+      config = YAML.load(File.open(@solr_config_path)).symbolize_keys
+      raise "The #{@config_env.to_sym} environment settings were not found in the solr.yml config.  If you already have a solr.yml file defined, make sure it defines settings for the #{@config_env} environment" unless config[@config_env.to_sym]
+      @solr_config = {:url=> get_solr_url(config[ActiveFedora.environment.to_sym].symbolize_keys)}
     end
 
     # Given the solr_config that's been loaded for this environment, 

data/lib/active_fedora/rdf_datastream.rb

@@ -27,6 +27,11 @@ module ActiveFedora
         def config
           ActiveFedora::Predicates.predicate_config
         end
+        def prefix(name)
+          name = name.to_s unless name.is_a? String
+          pre = self.to_s.sub(/RDFDatastream$/, '').underscore
+          return "#{pre}__#{name}".to_sym
+        end
         def register_vocabularies(*vocabs)
           @vocabularies = {}
           vocabs.each do |v|
@@ -60,6 +65,7 @@ module ActiveFedora
           # needed for AF::Predicates integration & drives all other
           # functionality below
           vocab = vocab.to_s
+          name = self.prefix(name)
           if config
             if config[:predicate_mapping].has_key? vocab
               config[:predicate_mapping][vocab][name] = predicate
@@ -122,12 +128,6 @@ module ActiveFedora
         end
   
       end
-      # def empty?
-      #   @values.empty?
-      # end
-      # def to_s
-      #   @values.to_s
-      # end
     end
     
     include ModelMethods
@@ -156,7 +156,7 @@ module ActiveFedora
         vocabs_list = self.class.vocabularies.select { |ns, v| v.__prefix__ == vocab_sym }
         vocab = vocabs_list.first.first.to_s
         vocab_hash = self.class.config[:predicate_mapping][vocab]
-        mapped_names = vocab_hash.select {|k, v| v.to_s == name.to_s}
+        mapped_names = vocab_hash.select { |k, v| name.to_s == v.to_s && k.to_s.split("__")[0] == self.class.prefix(name).to_s.split("__")[0]}
         name = mapped_names.first.first.to_s
         next unless vocab_hash.has_key?("#{name}type".to_sym) and vocab_hash.has_key?("#{name}behaviors".to_sym)
         type = vocab_hash["#{name}type".to_sym]
@@ -184,7 +184,7 @@ module ActiveFedora
 
     # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
     def find_predicate(predicate)
-      predicate = predicate.to_sym unless predicate.kind_of? RDF::URI
+      predicate = self.class.prefix(predicate) unless predicate.kind_of? RDF::URI
       result = ActiveFedora::Predicates.find_predicate(predicate)
       RDF::URI(result.reverse.join)
     end
@@ -212,7 +212,6 @@ module ActiveFedora
       ensure_loaded
       predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
       graph.delete(predicate)
-
       args = [args] unless args.respond_to? :each
       args.each do |arg|
         graph.add(predicate, arg, true) unless arg.empty?

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-    VERSION = "4.0.0.rc12"
+    VERSION = "4.0.0.rc13"
 end

data/spec/unit/file_configurator_spec.rb

@@ -35,12 +35,23 @@ describe ActiveFedora::FileConfigurator do
       subject.fedora_config.should == {"url"=>"http://127.0.0.1:8983/fedora-test", "password"=>"fedoraAdmin", "user"=>"fedoraAdmin"}
     end 
   end
+  describe "#solr_config" do
+    before do
+      subject.reset!
+    end
+    it "should trigger configuration to load" do
+      subject.solr_config.should == {:url=>"http://localhost:8983/solr/test"}
+    end 
+  end
 
   describe "#reset!" do
     before { subject.reset! }
     it "should clear @fedora_config" do
       subject.instance_variable_get(:@fedora_config).should == {} 
     end
+    it "should clear @solr_config" do
+      subject.instance_variable_get(:@solr_config).should == {} 
+    end
     it "should clear @config_options" do
       subject.instance_variable_get(:@config_options).should == {}
     end
@@ -127,25 +138,13 @@ describe ActiveFedora::FileConfigurator do
 
     end
 
-    describe "#determine url" do
-      it "should support config['environment']['url'] if config_type is fedora" do
-        config = {:test=> {:url=>"http://fedoraAdmin:fedorAdmin@localhost:8983/fedora"}}
-        subject.determine_url("fedora",config).should eql("http://localhost:8983/fedora")
-      end
-
-      it "should call #get_solr_url to determine the solr url if config_type is solr" do
-        config = {:test=>{:default => "http://default.solr:8983"}}
-        subject.expects(:get_solr_url).with(config[:test]).returns("http://default.solr:8983")
-        subject.determine_url("solr",config).should eql("http://default.solr:8983")
-      end
-    end
-
-    describe "load_config" do
+    describe "load_solr_config" do
       it "should load the file specified in solr_config_path" do
-        subject.expects(:solr_config_path).returns("/path/to/solr.yml")
+        subject.expects(:get_config_path).with(:solr).returns("/path/to/solr.yml")
+        subject.expects(:load_fedora_config)
         File.expects(:open).with("/path/to/solr.yml").returns("development:\n  default:\n    url: http://devsolr:8983\ntest:\n  default:\n    url: http://mysolr:8080")
-        subject.load_config(:solr).should eql({:url=>"http://mysolr:8080",:development=>{"default"=>{"url"=>"http://devsolr:8983"}}, :test=>{:default=>{"url"=>"http://mysolr:8080"}}})
-        subject.solr_config.should eql({:url=>"http://mysolr:8080",:development=>{"default"=>{"url"=>"http://devsolr:8983"}}, :test=>{:default=>{"url"=>"http://mysolr:8080"}}})
+        subject.load_solr_config.should == {:url=>"http://mysolr:8080"}
+        subject.solr_config.should == {:url=>"http://mysolr:8080"}
       end
     end
 
@@ -155,8 +154,6 @@ describe ActiveFedora::FileConfigurator do
           subject.instance_variable_set :@config_loaded, nil
         end
         it "should load the fedora and solr configs" do
-          #ActiveFedora.expects(:load_config).with(:fedora)
-          subject.expects(:load_config).with(:solr)
           subject.config_loaded?.should be_false
           subject.load_configs
           subject.config_loaded?.should be_true

data/spec/unit/ntriples_datastream_spec.rb

@@ -112,12 +112,12 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.content = File.new('spec/fixtures/solr_rdf_descMetadata.nt').read
       @subject.stubs(:pid => 'test:1')
       @subject.stubs(:new? => false)
-      @sample_fields = {:publisher => {:values => ["publisher1"], :type => :string, :behaviors => [:facetable, :sortable, :searchable, :displayable]}, 
-        :based_near => {:values => ["coverage1", "coverage2"], :type => :text, :behaviors => [:displayable, :facetable, :searchable]}, 
-        :created => {:values => "fake-date", :type => :date, :behaviors => [:sortable, :displayable]},
-        :title => {:values => "fake-title", :type => :text, :behaviors => [:searchable, :displayable, :sortable]},
-        :related_url => {:values => "http://example.org/", :type =>:string, :behaviors => [:searchable]},
-        :empty_field => {:values => [], :type => :string, :behaviors => [:searchable]}
+      @sample_fields = {:my_datastream__publisher => {:values => ["publisher1"], :type => :string, :behaviors => [:facetable, :sortable, :searchable, :displayable]}, 
+        :my_datastream__based_near => {:values => ["coverage1", "coverage2"], :type => :text, :behaviors => [:displayable, :facetable, :searchable]}, 
+        :my_datastream__created => {:values => "fake-date", :type => :date, :behaviors => [:sortable, :displayable]},
+        :my_datastream__title => {:values => "fake-title", :type => :text, :behaviors => [:searchable, :displayable, :sortable]},
+        :my_datastream__related_url => {:values => "http://example.org/", :type =>:string, :behaviors => [:searchable]},
+        :my_datastream__empty_field => {:values => [], :type => :string, :behaviors => [:searchable]}
       } 
     end
     after(:all) do
@@ -139,35 +139,34 @@ describe ActiveFedora::NtriplesRDFDatastream do
     it "should iterate through @fields hash" do
       @subject.expects(:fields).returns(@sample_fields)
       solr_doc = @subject.to_solr
-      solr_doc["publisher_t"].should == ["publisher1"]
-      solr_doc["publisher_sort"].should == ["publisher1"]
-      solr_doc["publisher_display"].should == ["publisher1"]
-      solr_doc["publisher_facet"].should == ["publisher1"]
-      solr_doc["based_near_t"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["based_near_display"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["based_near_facet"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["created_sort"].should == ["fake-date"]
-      solr_doc["created_display"].should == ["fake-date"]
-      solr_doc["title_t"].should == ["fake-title"]
-      solr_doc["title_sort"].should == ["fake-title"]
-      solr_doc["title_display"].should == ["fake-title"]
-      solr_doc["related_url_t"].should == ["http://example.org/"]
-      solr_doc["empty_field_t"].should be_nil
-    end
-    it "should allow multiple values for a single field"
+      solr_doc["my_datastream__publisher_t"].should == ["publisher1"]
+      solr_doc["my_datastream__publisher_sort"].should == ["publisher1"]
+      solr_doc["my_datastream__publisher_display"].should == ["publisher1"]
+      solr_doc["my_datastream__publisher_facet"].should == ["publisher1"]
+      solr_doc["my_datastream__based_near_t"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["my_datastream__based_near_display"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["my_datastream__based_near_facet"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["my_datastream__created_sort"].should == ["fake-date"]
+      solr_doc["my_datastream__created_display"].should == ["fake-date"]
+      solr_doc["my_datastream__title_t"].should == ["fake-title"]
+      solr_doc["my_datastream__title_sort"].should == ["fake-title"]
+      solr_doc["my_datastream__title_display"].should == ["fake-title"]
+      solr_doc["my_datastream__related_url_t"].should == ["http://example.org/"]
+      solr_doc["my_datastream__empty_field_t"].should be_nil
+    end
     it 'should append create keys in format field_name + _ + field_type' do
       @subject.stubs(:fields).returns(@sample_fields)
       
       #should have these            
-      @subject.to_solr["publisher_t"].should_not be_nil
-      @subject.to_solr["based_near_t"].should_not be_nil
-      @subject.to_solr["title_t"].should_not be_nil
-      @subject.to_solr["related_url_t"].should_not be_nil
+      @subject.to_solr["my_datastream__publisher_t"].should_not be_nil
+      @subject.to_solr["my_datastream__based_near_t"].should_not be_nil
+      @subject.to_solr["my_datastream__title_t"].should_not be_nil
+      @subject.to_solr["my_datastream__related_url_t"].should_not be_nil
 
       #should NOT have these
-      @subject.to_solr["narrator"].should be_nil
-      @subject.to_solr["empty_field"].should be_nil
-      @subject.to_solr["creator"].should be_nil
+      @subject.to_solr["my_datastream__narrator"].should be_nil
+      @subject.to_solr["my_datastream__empty_field"].should be_nil
+      @subject.to_solr["my_datastream__creator"].should be_nil
     end
     it "should use Solr mappings to generate field names" do
       ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
@@ -175,15 +174,15 @@ describe ActiveFedora::NtriplesRDFDatastream do
       solr_doc =  @subject.to_solr
 
       #should have these            
-      solr_doc["publisher_field"].should == ["publisher1"]
-      solr_doc["based_near_field"].sort.should == ["coverage1", "coverage2"]
-      solr_doc["created_display"].should == ["fake-date"]
-      solr_doc["title_field"].should == ["fake-title"]
+      solr_doc["my_datastream__publisher_field"].should == ["publisher1"]
+      solr_doc["my_datastream__based_near_field"].sort.should == ["coverage1", "coverage2"]
+      solr_doc["my_datastream__created_display"].should == ["fake-date"]
+      solr_doc["my_datastream__title_field"].should == ["fake-title"]
         
-      solr_doc["title_t"].should be_nil
-      solr_doc["publisher_t"].should be_nil
-      solr_doc["based_near_t"].should be_nil
-      solr_doc["created_dt"].should be_nil
+      solr_doc["my_datastream__title_t"].should be_nil
+      solr_doc["my_datastream__publisher_t"].should be_nil
+      solr_doc["my_datastream__based_near_t"].should be_nil
+      solr_doc["my_datastream__created_dt"].should be_nil
       
       # Reload default mappings
       ActiveFedora::SolrService.load_mappings
@@ -204,22 +203,22 @@ describe ActiveFedora::NtriplesRDFDatastream do
           @obj.fields.keys.count.should == 5
         end
         it "should return the right fields" do
-          @obj.fields.keys.should include(:related_url)
-          @obj.fields.keys.should include(:publisher)
-          @obj.fields.keys.should include(:created)
-          @obj.fields.keys.should include(:title)
-          @obj.fields.keys.should include(:based_near)
+          @obj.fields.keys.should include(:my_datastream__related_url)
+          @obj.fields.keys.should include(:my_datastream__publisher)
+          @obj.fields.keys.should include(:my_datastream__created)
+          @obj.fields.keys.should include(:my_datastream__title)
+          @obj.fields.keys.should include(:my_datastream__based_near)
         end
         it "should return the right values" do
-          @obj.fields[:related_url][:values].should == ["http://example.org/blogtastic/"]
+          @obj.fields[:my_datastream__related_url][:values].should == ["http://example.org/blogtastic/"]
         end
         it "should return the right type information" do
-          @obj.fields[:created][:type].should == :date
+          @obj.fields[:my_datastream__created][:type].should == :date
         end
         it "should return multi-value fields as expected" do
-          @obj.fields[:based_near][:values].count.should == 2
-          @obj.fields[:based_near][:values].should include("Tacoma, WA")
-          @obj.fields[:based_near][:values].should include("Renton, WA")
+          @obj.fields[:my_datastream__based_near][:values].count.should == 2
+          @obj.fields[:my_datastream__based_near][:values].should include("Tacoma, WA")
+          @obj.fields[:my_datastream__based_near][:values].should include("Renton, WA")
         end
       end
       describe ".to_solr()" do
@@ -227,27 +226,27 @@ describe ActiveFedora::NtriplesRDFDatastream do
           @obj.to_solr.keys.count.should == 13
         end
         it "should return the right fields" do
-          @obj.to_solr.keys.should include("related_url_t")
-          @obj.to_solr.keys.should include("publisher_t")
-          @obj.to_solr.keys.should include("publisher_sort")
-          @obj.to_solr.keys.should include("publisher_display")
-          @obj.to_solr.keys.should include("publisher_facet")
-          @obj.to_solr.keys.should include("created_sort")
-          @obj.to_solr.keys.should include("created_display")
-          @obj.to_solr.keys.should include("title_t")
-          @obj.to_solr.keys.should include("title_sort")
-          @obj.to_solr.keys.should include("title_display")
-          @obj.to_solr.keys.should include("based_near_t")
-          @obj.to_solr.keys.should include("based_near_facet")
-          @obj.to_solr.keys.should include("based_near_display")
+          @obj.to_solr.keys.should include("my_datastream__related_url_t")
+          @obj.to_solr.keys.should include("my_datastream__publisher_t")
+          @obj.to_solr.keys.should include("my_datastream__publisher_sort")
+          @obj.to_solr.keys.should include("my_datastream__publisher_display")
+          @obj.to_solr.keys.should include("my_datastream__publisher_facet")
+          @obj.to_solr.keys.should include("my_datastream__created_sort")
+          @obj.to_solr.keys.should include("my_datastream__created_display")
+          @obj.to_solr.keys.should include("my_datastream__title_t")
+          @obj.to_solr.keys.should include("my_datastream__title_sort")
+          @obj.to_solr.keys.should include("my_datastream__title_display")
+          @obj.to_solr.keys.should include("my_datastream__based_near_t")
+          @obj.to_solr.keys.should include("my_datastream__based_near_facet")
+          @obj.to_solr.keys.should include("my_datastream__based_near_display")
         end
         it "should return the right values" do
-          @obj.to_solr["related_url_t"].should == ["http://example.org/blogtastic/"]
+          @obj.to_solr["my_datastream__related_url_t"].should == ["http://example.org/blogtastic/"]
         end
         it "should return multi-value fields as expected" do
-          @obj.to_solr["based_near_t"].count.should == 2
-          @obj.to_solr["based_near_t"].should include("Tacoma, WA")
-          @obj.to_solr["based_near_t"].should include("Renton, WA")
+          @obj.to_solr["my_datastream__based_near_t"].count.should == 2
+          @obj.to_solr["my_datastream__based_near_t"].should include("Tacoma, WA")
+          @obj.to_solr["my_datastream__based_near_t"].should include("Renton, WA")
         end
       end
     end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: active-fedora
 version: !ruby/object:Gem::Version 
-  hash: 15424141
+  hash: 15424143
   prerelease: 6
   segments: 
   - 4
   - 0
   - 0
   - rc
-  - 12
-  version: 4.0.0.rc12
+  - 13
+  version: 4.0.0.rc13
 platform: ruby
 authors: 
 - Matt Zumwalt