active-fedora 9.1.2 → 9.2.0.rc1

data/lib/active_fedora/rdf/field_map_entry.rb

@@ -0,0 +1,28 @@
+module ActiveFedora::RDF
+  # Transient class that represents a field that we send to solr.
+  # It might be possible for two properties to share a single field map entry if they use the same solr key.
+  # @attribute [Symbol] type the data type hint for Solrizer
+  # @attribute [Array] behaviors the indexing hints such as :stored_searchable or :symbol
+  # @attribute [Array] values the actual values that get sent to solr
+  class FieldMapEntry
+
+    attr_accessor :type, :behaviors, :values
+
+    def initialize
+      @behaviors = []
+      @values = []
+    end
+
+    # Merges any existing values for solr fields with new, incoming values and ensures that resulting values are unique.
+    # @param [Symbol] type the data type for the field such as :string, :date, :integer
+    # @param [Array] behaviors Solrizer's behaviors for indexing such as :stored_searhable, :symbol
+    # @param [Array] values existing values for the solr field
+    def merge!(type, behaviors, values)
+      self.type ||= type
+      self.behaviors += behaviors
+      self.behaviors.uniq!
+      self.values += values
+    end
+
+  end
+end

data/lib/active_fedora/rdf/indexing_service.rb

@@ -22,7 +22,7 @@ module ActiveFedora::RDF
       def add_assertions(prefix_method, solr_doc = {})
         fields.each do |field_key, field_info|
           solr_field_key = solr_document_field_name(field_key, prefix_method)
-          Array(field_info[:values]).each do |val|
+          field_info.values.each do |val|
             append_to_solr_doc(solr_doc, solr_field_key, field_info, val)
           end
         end
@@ -38,7 +38,7 @@ module ActiveFedora::RDF
       def append_to_solr_doc(solr_doc, solr_field_key, field_info, val)
         self.class.create_and_insert_terms(solr_field_key,
                                            solr_document_field_value(val),
-                                           field_info[:behaviors], solr_doc)
+                                           field_info.behaviors, solr_doc)
       end
 
       def solr_document_field_name(field_key, prefix_method)
@@ -54,7 +54,7 @@ module ActiveFedora::RDF
           when ::RDF::URI
             val.to_s
           when ActiveTriples::Resource
-            val.solrize
+            val.node? ? val.rdf_label : val.rdf_subject.to_s
           else
             val
         end
@@ -64,35 +64,21 @@ module ActiveFedora::RDF
         object.resource
       end
 
-      def properties
-        object.class.properties
-      end
-
       def index_config
         object.class.index_config
       end
 
-      # returns a Hash, e.g.: {field => { values: [], type: :something, behaviors: [] }, ...}
+      # returns the field map instance
       def fields
-        field_map = {}.with_indifferent_access
-
-        index_config.each do |name, index_field_config|
-          type = index_field_config.data_type
-          behaviors = index_field_config.behaviors
-          next unless type and behaviors
-          next if kind_of_af_base?(name)
-          field_map[name] = { values: find_values(name), type: type, behaviors: behaviors}
+        field_map_class.new do |field_map| 
+          index_config.each { |name, index_field_config| field_map.insert(name, index_field_config, object) }
         end
-        field_map
       end
 
-      def kind_of_af_base?(name)
-        config = properties[name.to_s]
-        config && config[:class_name] && config[:class_name] < ActiveFedora::Base
+      # Override this method to use your own FieldMap class for custom indexing of objects and properties
+      def field_map_class
+        ActiveFedora::RDF::FieldMap
       end
 
-      def find_values(name)
-        object.send(name) || []
-      end
   end
 end

data/lib/active_fedora/rdf/rdf_datastream.rb

@@ -23,8 +23,7 @@ module ActiveFedora
 
       def add_attribute_indexing_config(name, &block)
         Deprecation.warn(RDFDatastream, "Adding indexing to datastreams is deprecated")
-        # TODO the hash can be initalized to return on of these
-        index_config[name] ||= ActiveFedora::Indexing::Map::IndexObject.new &block
+        index_config[name] ||= ActiveFedora::Indexing::Map::IndexObject.new(name, &block)
       end
 
       # Trim the last segment off the URI to get the parents uri

data/lib/active_fedora/reflection.rb

@@ -10,7 +10,7 @@ module ActiveFedora
     module ClassMethods
       def create_reflection(macro, name, options, active_fedora)
         klass = case macro
-          when :has_many, :belongs_to, :has_and_belongs_to_many, :contains
+          when :has_many, :belongs_to, :has_and_belongs_to_many, :contains, :directly_contains, :directly_contains_one, :indirectly_contains
             AssociationReflection
           when :rdf, :singular_rdf
             RDFPropertyReflection
@@ -106,11 +106,10 @@ module ActiveFedora
 
       # Returns a new, unsaved instance of the associated class. +options+ will
       # be passed to the class's constructor.
-      def build_association(*options)
-        klass.new(*options)
+      def build_association(*options, &block)
+        klass.new(*options, &block)
       end
 
-
       # Returns the class name for the macro.
       #
       # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
@@ -167,14 +166,7 @@ module ActiveFedora
 
       def initialize(macro, name, options, active_fedora)
         super
-        @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
-      end
-
-
-      # Returns a new, unsaved instance of the associated class. +options+ will
-      # be passed to the class's constructor.
-      def build_association(*options)
-        klass.new(*options)
+        @collection = [:has_many, :has_and_belongs_to_many, :directly_contains, :indirectly_contains].include?(macro)
       end
 
       # Creates a new instance of the associated class, and immediately saves it
@@ -193,10 +185,13 @@ module ActiveFedora
         options[:predicate]
       end
 
+      def predicate_for_solr
+        predicate.fragment || predicate.to_s.rpartition(/\//).last
+      end
+
       def solr_key
         @solr_key ||= begin
-          predicate_string = predicate.fragment || predicate.to_s.rpartition(/\//).last
-          ActiveFedora::SolrQueryBuilder.solr_name(predicate_string, :symbol)
+          ActiveFedora::SolrQueryBuilder.solr_name(predicate_for_solr, :symbol)
         end
       end
 
@@ -247,7 +242,7 @@ module ActiveFedora
       def association_class
         case macro
         when :contains
-          Associations::ContainsAssociation
+          Associations::BasicContainsAssociation
         when :belongs_to
           Associations::BelongsToAssociation
         when :has_and_belongs_to_many
@@ -258,6 +253,12 @@ module ActiveFedora
           Associations::SingularRDF
         when :rdf
           Associations::RDF
+        when :directly_contains
+          Associations::DirectlyContainsAssociation
+        when :directly_contains_one
+          Associations::DirectlyContainsOneAssociation
+        when :indirectly_contains
+          Associations::IndirectlyContainsAssociation
         end
       end
 

data/lib/active_fedora/relation/delegation.rb

@@ -6,14 +6,25 @@ module ActiveFedora
     # subsequent calls to that method faster by avoiding method_missing. The delegations
     # may vary depending on the klass of a relation, so we create a subclass of Relation
     # for each different klass, and the delegations are compiled into that subclass only.
-    
+
+    BLACKLISTED_ARRAY_METHODS = [
+      :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
+      :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
+      :keep_if, :pop, :shift, :delete_at, :select!
+    ].to_set
+
     delegate :length, :collect, :map, :each, :all?, :include?, :to_ary, :to => :to_a
 
+    protected
+
+    def array_delegable?(method)
+      Array.method_defined?(method) && BLACKLISTED_ARRAY_METHODS.exclude?(method)
+    end
 
     def method_missing(method, *args, &block)
-      if Array.method_defined?(method)
-        self.class.delegate method, :to => :to_a
-        to_a.send(method, *args, &block)
+      if array_delegable?(method)
+        self.class.delegate method, to: :to_a
+        to_a.public_send(method, *args, &block)
       else
         super
       end

data/lib/active_fedora/relation/finder_methods.rb

@@ -28,7 +28,7 @@ module ActiveFedora
       end
     end
 
-    # Returns an Array of objects of the Class that +find+ is being 
+    # Returns an Array of objects of the Class that +find+ is being
     # called on
     #
     # @param[String,Hash] args either an id or a hash of conditions
@@ -40,12 +40,12 @@ module ActiveFedora
       options = options.dup
       cast = if @klass == ActiveFedora::Base && !options.has_key?(:cast)
         true
-      else 
+      else
         options.delete(:cast)
       end
       if options[:sort]
         # Deprecate sort sometime?
-        sort = options.delete(:sort) 
+        sort = options.delete(:sort)
         options[:order] ||= sort if sort.present?
       end
 
@@ -251,7 +251,7 @@ module ActiveFedora
       ids.map{|id| find_one(id, cast)}
     end
 
-    private 
+    private
 
     # Returns a solr query for the supplied conditions
     # @param[Hash] conditions solr conditions to match

data/lib/active_fedora/schema.rb

@@ -0,0 +1,26 @@
+module ActiveFedora
+  ##
+  # Implement the .apply_schema method from ActiveTriples to allow for
+  # externally defined schemas to be put on an AF::Base object.
+  module Schema
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Applies a schema to an ActiveFedora::Base.
+      # @note The default application strategy adds no indexing hints. You may
+      #   want to implement a different strategy if you want to set values on the
+      #   property reflection.
+      # @param schema [ActiveTriples::Schema] The schema to apply.
+      # @param strategy [#apply] The strategy to use for applying the schema.
+      # @example Apply a schema and index everything as symbol.
+      #   apply_schema MySchema, ActiveFedora::SchemaIndexingStrategy.new(
+      #     ActiveFedora::GlobalIndexer.new(:symbol)
+      #   )
+      def apply_schema(schema, strategy=ActiveFedora::SchemaIndexingStrategy.new)
+        schema.properties.each do |property|
+          strategy.apply(self, property)
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/schema_indexing_strategy.rb

@@ -0,0 +1,25 @@
+module ActiveFedora
+  ##
+  # An extension strategy to also apply solr indexes for each property.
+  # @note If how a field is indexed changes based on property, this would be a
+  #   good place to define that.
+  class SchemaIndexingStrategy
+    # @param [#index] indexer The indexer to use
+    def initialize(indexer=Indexers::NullIndexer.instance)
+      @indexer = indexer
+    end
+
+    # @param [ActiveFedora::Base] object The object to apply the property to.
+    # @param [ActiveTriples::Property, #name, #to_h] property The property to define.
+    def apply(object, property)
+      object.property property.name, property.to_h do |index|
+        indexer.new(property).index(index)
+      end
+    end
+
+    private
+
+    attr_reader :indexer
+  end
+end
+

data/lib/active_fedora/simple_datastream.rb

@@ -20,9 +20,9 @@ module ActiveFedora
 
     #Constructor. this class will call self.field for each DCTERM. In short, all DCTERMS fields will already exist
     #when this method returns. Each term is marked as a multivalue string.
-    def initialize(digital_object=nil, dsid=nil, options={})
-      super
+    def initialize(digital_object=nil, dsid=nil, options={}, &block)
       self.fields={}
+      super
     end
 
     # This method generates the various accessor and mutator methods on self for the datastream metadata attributes.

data/lib/active_fedora/solr_query_builder.rb

@@ -5,8 +5,9 @@ module ActiveFedora
     # If the id_array is empty, defaults to a query of "id:NEVER_USE_THIS_ID", which will return an empty solr response
     # @param [Array] id_array the ids that you want included in the query
     def self.construct_query_for_ids(id_array)
-      q = id_array.reject { |x| x.blank? }.map { |id| raw_query(SOLR_DOCUMENT_ID, id) }
-      q.empty? ? "id:NEVER_USE_THIS_ID" : q.join(" OR ".freeze)
+      ids = id_array.reject { |x| x.blank? }
+      return "id:NEVER_USE_THIS_ID" if ids.empty?
+      "{!terms f=#{SOLR_DOCUMENT_ID}}#{ids.join(',')}"
     end
 
     # Create a raw query clause suitable for sending to solr as an fq element

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "9.1.2"
+  VERSION = "9.2.0.rc1"
 end

data/lib/active_fedora/with_metadata.rb

@@ -9,7 +9,7 @@ module ActiveFedora
       @metadata_node ||= self.class.metadata_schema.new(self)
     end
 
-    def save(*)
+    def create_or_update(*)
       if super && !new_record?
         metadata_node.metadata_uri = described_by # TODO only necessary if the URI was < > before
         metadata_node.save # TODO if changed?

data/spec/integration/associations/rdf_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "rdf associations" do
+  context "when there is one relationship for the predicate" do
+    before do
+      class Foo < ActiveFedora::Base
+      end
+      class Library < ActiveFedora::Base
+        has_and_belongs_to_many :foos, predicate: ::RDF::URI('http://example.com')
+      end
+    end
+    after do
+      Object.send(:remove_const, :Foo)
+      Object.send(:remove_const, :Library)
+    end
+
+    let(:library) { Library.new }
+
+    it "doesn't not bother to filter by class type" do
+      expect(library.association(:foo_ids)).not_to receive(:filter_by_class)
+      library.foos.to_a
+    end
+  end
+
+  context "when two relationships have the same predicate" do
+    before do
+      class Foo < ActiveFedora::Base
+      end
+      class Bar < ActiveFedora::Base
+      end
+      class Library < ActiveFedora::Base
+        has_and_belongs_to_many :foos, predicate: ::RDF::URI('http://example.com')
+        has_and_belongs_to_many :bars, predicate: ::RDF::URI('http://example.com')
+      end
+    end
+    after do
+      Object.send(:remove_const, :Foo)
+      Object.send(:remove_const, :Bar)
+      Object.send(:remove_const, :Library)
+    end
+
+    let(:library) { Library.new }
+
+    it "filters by class type" do
+      expect(library.association(:foo_ids)).to receive(:filter_by_class).and_call_original
+      library.foos.to_a
+    end
+  end
+end

data/spec/integration/base_spec.rb

@@ -135,6 +135,25 @@ describe ActiveFedora::Base do
     end
   end
   
+  describe "#apply_schema" do
+    before do
+      class ExampleSchema < ActiveTriples::Schema
+        property :title, predicate: RDF::DC.title
+      end
+      class ExampleBase < ActiveFedora::Base
+        apply_schema ExampleSchema, ActiveFedora::SchemaIndexingStrategy.new(ActiveFedora::Indexers::GlobalIndexer.new(:symbol))
+      end
+    end
+    after do
+      Object.send(:remove_const, :ExampleSchema)
+      Object.send(:remove_const, :ExampleBase)
+    end
+    let(:obj) { ExampleBase.new }
+    it "should configure properties and solrize them" do
+      obj.title = ["Test"]
+      expect(obj.to_solr[ActiveFedora::SolrQueryBuilder.solr_name("title", :symbol)]).to eq ["Test"]
+    end
+  end
 
   describe "#exists?" do
     let(:obj) { ActiveFedora::Base.create } 

data/spec/integration/belongs_to_association_spec.rb

@@ -106,13 +106,13 @@ describe ActiveFedora::Base do
       end
 
       class SimpleCollection < ActiveFedora::Base
-        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject', autosave: true
-        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject', autosave: true
+        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject'
+        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject'
       end
 
       class ComplexCollection < SimpleCollection
-        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject', autosave: true
-        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject', autosave: true
+        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject'
+        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject'
 
         def assert_content_model
           self.has_model = [self.class.to_s, self.class.superclass.to_s]
@@ -172,7 +172,7 @@ describe ActiveFedora::Base do
           simple_collection.objects = [complex_object, simple_object]
           simple_collection.save!
         end
-        it "ignores objects who's classes aren't specified" do
+        it "ignores objects whose classes aren't specified" do
           expect(simple_collection.complex_objects.size).to eq 1
           expect(simple_collection.complex_objects[0]).to be_instance_of ZComplexObject
           expect(simple_collection.complex_objects[1]).to be_nil
@@ -223,7 +223,7 @@ describe ActiveFedora::Base do
       end
 
       class SuperclassCollection < ActiveFedora::Base
-        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SuperclassObject', autosave: true
+        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SuperclassObject'
       end
     end
     after :all do