active-fedora 5.4.0 → 5.5.0.rc1

data/Gemfile

@@ -10,4 +10,3 @@ group :development, :test do
 end
 
 gem 'jruby-openssl', :platform=> :jruby
-gem 'nom-xml', '>=0.5.1'

data/active-fedora.gemspec

@@ -17,7 +17,8 @@ Gem::Specification.new do |s|
 
   s.add_dependency('rsolr')
   s.add_dependency('om', '~> 1.8.0')
-  s.add_dependency('solrizer', '~>2.0.0')
+  s.add_dependency('nom-xml', '>=0.5.1')
+  s.add_dependency('solrizer', '~>2.1.0.rc1')
   s.add_dependency("activeresource", '>= 3.0.0')
   s.add_dependency("activesupport", '>= 3.0.0')
   s.add_dependency("builder", '~> 3.0.0')

data/config/solr_mappings_af_0.1.yml

@@ -6,4 +6,4 @@ searchable:
 displayable: _display
 facetable: _facet
 sortable: _sort
-unstemmed_searchable: _unstem_search
+unstemmed_searchable: _unstem_search

data/config/solr_mappings_bl_2.4.yml

@@ -14,4 +14,4 @@ searchable:
 displayable: _display
 facetable: _facet
 sortable: _sort
-unstemmed_searchable: _unstem_search
+unstemmed_searchable: _unstem_search

data/lib/active_fedora.rb

@@ -1,13 +1,14 @@
 require "loggable"
 require 'active_support'
-require 'active_fedora/solr_service'
+require "solrizer"
+require 'active_fedora/file_configurator'
 require 'active_fedora/rubydora_connection'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/object'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'rdf'
 
-SOLR_DOCUMENT_ID = ActiveFedora::SolrService.id_field unless defined?(SOLR_DOCUMENT_ID)
+SOLR_DOCUMENT_ID = ActiveFedora::FileConfigurator.id_field unless defined?(SOLR_DOCUMENT_ID)
 ENABLE_SOLR_UPDATES = true unless defined?(ENABLE_SOLR_UPDATES)
 
 module ActiveFedora #:nodoc:
@@ -52,12 +53,15 @@ module ActiveFedora #:nodoc:
     autoload :QualifiedDublinCoreDatastream
     autoload :Querying
     autoload :RDFDatastream
+    autoload :RdfNode
+    autoload :RdfObject
     autoload :RdfxmlRDFDatastream
     autoload :Relation
     autoload :RelsExtDatastream
     autoload :ServiceDefinitions
     autoload :SemanticNode
     autoload :SimpleDatastream
+    autoload :SolrService
     autoload :NestedAttributes
     autoload :FixtureLoader
     autoload :FixtureExporter

data/lib/active_fedora/datastream.rb

@@ -4,11 +4,10 @@ module ActiveFedora
   class Datastream < Rubydora::Datastream
     extend Deprecation
     attr_writer :digital_object
-    attr_accessor :last_modified, :fields
+    attr_accessor :last_modified
 
     def initialize(digital_object=nil, dsid=nil, options={})
       ## When you use the versions feature of rubydora (0.5.x), you need to have a 3 argument constructor
-      self.fields={}
       super
     end
 

data/lib/active_fedora/file_configurator.rb

@@ -46,6 +46,7 @@ module ActiveFedora
     #     url: http://127.0.0.1:8983/fedora2
     #
 
+    include Solrizer::FieldNameMapper
     attr_accessor :config_env
     attr_reader :config_options, :fedora_config_path, :solr_config_path
 
@@ -100,6 +101,7 @@ module ActiveFedora
       
       load_fedora_config
       load_solr_config
+      load_solrizer_config
       @config_loaded = true
     end
 
@@ -148,6 +150,20 @@ module ActiveFedora
       @solr_config = {:url=> get_solr_url(config[ActiveFedora.environment.to_sym].symbolize_keys)}
     end
 
+    def load_solrizer_config
+      if solrizer_config_path
+        logger.warn "loading_solrizer_config at #{solrizer_config_path}, this overwrites the default field mapper class."
+        ActiveFedora::SolrService.load_mappings 
+      end
+    end
+
+    def solrizer_config_path
+      begin
+        get_config_path('solr_mappings')
+      rescue ActiveFedora::ConfigurationError
+      end
+    end
+
     # Given the solr_config that's been loaded for this environment, 
     # determine which solr url to use
     def get_solr_url(solr_config)
@@ -194,9 +210,12 @@ module ActiveFedora
     
       # Last choice, check for the default config file
       config_path = File.join(ActiveFedora.root, "config", "#{config_type}.yml")
-      logger.warn "Using the default #{config_type}.yml that comes with active-fedora.  If you want to override this, pass the path to #{config_type}.yml to ActiveFedora - ie. ActiveFedora.init(:#{config_type}_config_path => '/path/to/#{config_type}.yml') - or set Rails.root and put #{config_type}.yml into \#{Rails.root}/config."
-      return config_path if File.file? config_path
-      raise ConfigurationError "Couldn't load #{config_type} config file!"
+      if File.file? config_path
+        logger.warn "Using the default #{config_type}.yml that comes with active-fedora.  If you want to override this, pass the path to #{config_type}.yml to ActiveFedora - ie. ActiveFedora.init(:#{config_type}_config_path => '/path/to/#{config_type}.yml') - or set Rails.root and put #{config_type}.yml into \#{Rails.root}/config."
+        return config_path
+      else
+        raise ConfigurationError, "Couldn't load #{config_type} config file!"
+      end
     end
   
     # Checks the existing fedora_config.path to see if there is a solr.yml there

data/lib/active_fedora/nokogiri_datastream.rb

@@ -285,7 +285,7 @@ module ActiveFedora
     end
 
     def generate_solr_symbol(base, data_type)
-      Solrizer::XML::TerminologyBasedSolrizer.default_field_mapper.solr_name(base.to_sym, data_type)
+      Solrizer.default_field_mapper.solr_name(base.to_sym, data_type)
     end
 
     # ** Experimental **

data/lib/active_fedora/nom_datastream.rb

@@ -2,10 +2,15 @@ require  "nom"
 
 module ActiveFedora
   class NomDatastream < Datastream
-      def self.set_terminology &block
+      def self.set_terminology(options = {}, &block)
+        @terminology_options = options || {}
         @terminology = block
       end
 
+      def self.terminology_options
+        @terminology_options
+      end
+
       def self.terminology
         @terminology
       end
@@ -27,7 +32,7 @@ module ActiveFedora
     def ng_xml
       @ng_xml ||= begin
          xml = Nokogiri::XML content
-         xml.set_terminology &self.class.terminology
+         xml.set_terminology self.class.terminology_options, &self.class.terminology
          xml.nom!
          xml
       end
@@ -35,7 +40,7 @@ module ActiveFedora
     
     def ng_xml= ng_xml
       @ng_xml = ng_xml
-      @ng_xml.set_terminology &self.class.terminology
+      @ng_xml.set_terminology self.class.terminology_options, &self.class.terminology
       content_will_change!
       @ng_xml
     end

data/lib/active_fedora/qualified_dublin_core_datastream.rb

@@ -7,6 +7,7 @@ module ActiveFedora
   #Fields can still be overridden if more specificity is desired (see ActiveFedora::Datastream#fields method).
   class QualifiedDublinCoreDatastream < OmDatastream
 
+    attr_accessor :fields
     class_attribute :class_fields
     self.class_fields = []
     
@@ -31,6 +32,7 @@ module ActiveFedora
     #when this method returns. Each term is marked as a multivalue string.
     def initialize(digital_object=nil, dsid=nil, options={})
       super
+      self.fields={}
       DCTERMS.each do |el|
         field el, :string, :multiple=>true
       end

data/lib/active_fedora/rdf_datastream.rb

@@ -1,46 +1,22 @@
 module ActiveFedora
   class RDFDatastream < Datastream
 
+    include Solrizer::Common
+
     before_save do
       if content.blank?
         logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
         false
       end
     end
+    include RdfNode
     
-    # this enables a cleaner API for solr integration
-    class IndexObject
-      attr_accessor :data_type, :behaviors
-      def initialize
-        @behaviors = [:searchable]
-        @data_type = :string
-      end
-      def as(*args)
-        @behaviors = args
-      end
-      def type(sym)
-        @data_type = sym
-      end
-      def defaults
-        :noop
-      end
-    end
-
     class << self 
-      attr_accessor :vocabularies
-      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$/i, '').underscore
-        return "#{pre}__#{name}".to_sym
-      end
-
       ##
       # Register a ruby block that evaluates to the subject of the graph
       # By default, the block returns the current object's pid
       # @yield [ds] 'ds' is the datastream instance
+      # This should override the method in rdf_object, which just creates a b-node by default
       def rdf_subject &block
         if block_given?
            return @subject_block = block
@@ -50,117 +26,20 @@ module ActiveFedora
       end
 
       def register_vocabularies(*vocabs)
-        @vocabularies ||= {}
-        vocabs.each do |v|
-          if v.is_a?(RDF::Vocabulary) or (v.respond_to? :property and v.respond_to? :to_uri)
-            @vocabularies[v.to_uri] = v 
-          else
-            raise "not an RDF vocabulary: #{v}"
-          end
-        end
-        ActiveFedora::Predicates.vocabularies(@vocabularies)
-        @vocabularies
+        Deprecation.warn(RDFDatastream, "register_vocabularies no longer has any effect and will be removed in active-fedora 6.0", caller)
       end
 
-      def map_predicates(&block)
-        yield self
-      end
-      def method_missing(name, *args, &block)
-        args = args.first if args.respond_to? :first
-        raise "mapping must specify RDF vocabulary as :in argument" unless args.has_key? :in
-        vocab = args[:in]
-        predicate = args.fetch(:to, name)
-        raise "Vocabulary '#{vocab.inspect}' does not define property '#{predicate.inspect}'" unless vocab.respond_to? predicate
-        indexing = false
-        if block_given?
-          # needed for solrizer integration
-          indexing = true
-          iobj = IndexObject.new
-          yield iobj
-          data_type = iobj.data_type
-          behaviors = iobj.behaviors
-        end
-        # 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
-          else
-            config[:predicate_mapping][vocab] = { name => predicate } 
-          end
-          # stuff data_type and behaviors in there for to_solr support
-          config[:predicate_mapping][vocab]["#{name}__type".to_sym] = data_type if indexing
-          config[:predicate_mapping][vocab]["#{name}__behaviors".to_sym] = behaviors if indexing
-        else
-          config = {
-            :default_namespace => vocab,
-            :predicate_mapping => {
-              vocab => { name => predicate }
-            }
-          }
-          # stuff data_type and behaviors in there for to_solr support
-          config[:predicate_mapping][vocab]["#{name}__type".to_sym] = data_type if indexing
-          config[:predicate_mapping][vocab]["#{name}__behaviors".to_sym] = behaviors if indexing
-        end
+      def prefix(name)
+        name = name.to_s unless name.is_a? String
+        pre = self.to_s.sub(/RDFDatastream$/i, '').underscore
+        return "#{pre}__#{name}".to_sym
       end
     end
 
-
-    class TermProxy
-
-      attr_reader :graph, :subject, :predicate
-      delegate :class, :to_s, :==, :kind_of?, :each, :map, :empty?, :as_json, :is_a?, :to => :values
-
-      def initialize(graph, subject, predicate)
-        @graph = graph
-
-        @subject = subject
-        @predicate = predicate
-      end
-
-      def <<(*values)
-        values.each { |value| graph.append(subject, predicate, value) }
-        values
-      end
-
-      def delete(*values)
-        values.each do |value| 
-          graph.delete_predicate(subject, predicate, value)
-        end
-
-        values
-      end
-
-      def values
-        values = []
-
-        graph.query(subject, predicate).each do |solution|
-          v = solution.value
-          v = v.to_s if v.is_a? RDF::Literal
-          values << v
-        end
-
-        values
-      end
-      
-      def method_missing(method, *args, &block)
-
-        if values.respond_to? method
-          values.send(method, *args, &block)
-        else
-          super
-        end
-      end
-    end
-    
     attr_accessor :loaded
     def metadata?
       true
     end
-    def ensure_loaded
-    end
 
     def content
       serialize
@@ -180,57 +59,21 @@ module ActiveFedora
       super || content_changed?
     end
 
-    # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
-    def fields
-      field_map = {}
-
-      rdf_subject = self.rdf_subject
-      query = RDF::Query.new do
-        pattern [rdf_subject, :predicate, :value]
-      end
-
-      query.execute(graph).each do |solution|
-        predicate = solution.predicate
-        value = solution.value
-        
-        vocab_sym, name = predicate.qname
-        uri, vocab = self.class.vocabularies.select { |ns, v| v.__prefix__ == vocab_sym }.first
-        next unless vocab
-
-        config = self.class.config[:predicate_mapping][vocab.to_s]
-
-        name, indexed_as = config.select { |k, v| name.to_s == v.to_s && k.to_s.split("__")[0] == self.class.prefix(name).to_s.split("__")[0]}.first
-        next unless name and config.has_key?("#{name}__type".to_sym) and config.has_key?("#{name}__behaviors".to_sym)
-        type = config["#{name}__type".to_sym]
-        behaviors = config["#{name}__behaviors".to_sym]
-        field_map[name.to_sym] ||= {:values => [], :type => type, :behaviors => behaviors}
-        field_map[name.to_sym][:values] << value.to_s
-      end
-      field_map
-    end
 
     def to_solr(solr_doc = Hash.new) # :nodoc:
       fields.each do |field_key, field_info|
-        values = field_info.fetch(:values, false)
+        values = get_values(rdf_subject, field_key)
+        directive = Solrizer::Directive.new(field_info[:type], field_info[:behaviors])
         if values
-          field_info[:behaviors].each do |index_type|
-            field_symbol = ActiveFedora::SolrService.solr_name(field_key, field_info[:type], index_type)
-            values = [values] unless values.respond_to? :each
-            values.each do |val|    
-              ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val)         
-            end
+          Array(values).each do |val|    
+            val = val.to_s if val.kind_of? RDF::URI
+            self.class.create_and_insert_terms(self.class.prefix(field_key), val, directive, solr_doc)
           end
         end
       end
       solr_doc
     end
 
-    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-    def find_predicate(predicate)
-      predicate = self.class.prefix(predicate) unless predicate.kind_of? RDF::URI
-      result = ActiveFedora::Predicates.find_predicate(predicate)
-      RDF::URI(result.reverse.join)
-    end
 
     # Populate a RDFDatastream object based on the "datastream" content 
     # Assumes that the datastream contains RDF content
@@ -257,101 +100,10 @@ module ActiveFedora
       end      
     end
 
-    def query subject, predicate, &block
-      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
-      
-      q = RDF::Query.new do
-        pattern [subject, predicate, :value]
-      end
-
-      q.execute(graph, &block)
-    end
-
-    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-    def get_values(subject, predicate)
-
-      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
-
-      return TermProxy.new(self, subject, predicate)
-    end
-
-    # if there are any existing statements with this predicate, replace them
-    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-
-    def set_value(subject, predicate, values)
-      
-      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
-
-      delete_predicate(subject, predicate)
-
-      Array(values).each do |arg|
-        arg = arg.to_s if arg.kind_of? RDF::Literal
-        next if arg.empty?
-
-        graph.insert([subject, predicate, arg])
-      end
-
-      return TermProxy.new(self, subject, predicate)
-    end
- 
-    def delete_predicate(subject, predicate, values = nil)
-      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
-
-      if values.nil?
-        query = RDF::Query.new do
-          pattern [subject, predicate, :value]
-        end
-
-        query.execute(graph).each do |solution|
-          graph.delete [subject, predicate, solution.value]
-        end
-      else
-        Array(values).each do |v|
-          graph.delete [subject, predicate, v]
-        end
-      end
-
-    end
-
-    # append a value 
-    # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-    def append(subject, predicate, args)
-      graph.insert([subject, predicate, args])
-
-
-      return TermProxy.new(self, subject, predicate)
-    end
-
     def serialization_format
       raise "you must override the `serialization_format' method in a subclass"
     end
 
-    def method_missing(name, *args)
-      if (md = /^([^=]+)=$/.match(name.to_s)) && pred = find_predicate(md[1])
-        set_value(rdf_subject, pred, *args)  
-       elsif pred = find_predicate(name)
-        get_values(rdf_subject, name)
-      else 
-        super
-      end
-    rescue ActiveFedora::UnregisteredPredicateError
-      super
-    end
-
-    ##
-    # Get the subject for this rdf/xml datastream
-    def rdf_subject
-      @subject ||= begin
-        s = self.class.rdf_subject.call(self)
-        s &&= RDF::URI.new(s) if s.is_a? String
-        s
-      end
-    end   
-
-    def reset_rdf_subject!
-      @subject = nil
-    end
-
     # Creates a RDF datastream for insertion into a Fedora Object
     # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
     def serialize
@@ -359,6 +111,9 @@ module ActiveFedora
       RDF::Writer.for(serialization_format).dump(graph)
     end
 
+    
+    private 
+
     def update_subjects_to_use_a_real_pid!
       return unless new?
 
@@ -377,6 +132,30 @@ module ActiveFedora
 
       @graph = new_repository
     end
+
+    # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
+    def fields
+      field_map = {}
+
+      rdf_subject = self.rdf_subject
+      query = RDF::Query.new do
+        pattern [rdf_subject, :predicate, :value]
+      end
+
+      query.execute(graph).each do |solution|
+        predicate = solution.predicate
+        value = solution.value
+        
+        name, config = self.class.config_for_predicate(predicate)
+        next unless config
+        type = config[:type]
+        behaviors = config[:behaviors]
+        next unless type and behaviors 
+        field_map[name] ||= {:values => [], :type => type, :behaviors => behaviors}
+        field_map[name][:values] << value.to_s
+      end
+      field_map
+    end
   end
 end