active-fedora 9.0.0.beta2 → 9.0.0.beta3

data/lib/active_fedora/rdf/fcrepo4.rb

@@ -0,0 +1,7 @@
+require 'rdf'
+module ActiveFedora::RDF
+  class Fcrepo4 < RDF::StrictVocabulary("http://fedora.info/definitions/v4/repository#")
+    property :created
+    property :lastModified
+  end
+end

data/lib/active_fedora/rdf/indexing.rb

@@ -32,7 +32,7 @@ module ActiveFedora
         return nil unless config # punt on index names for deep nodes!
         if behaviors = config.behaviors
           behaviors.each do |behavior|
-            result = ActiveFedora::SolrService.solr_name(apply_prefix(field, file_path), behavior, type: config.type)
+            result = ActiveFedora::SolrQueryBuilder.solr_name(apply_prefix(field, file_path), behavior, type: config.type)
             return result if Solrizer::DefaultDescriptors.send(behavior).evaluate_suffix(:text).stored?
           end
           raise RuntimeError "no stored fields were found"

data/lib/active_fedora/rdf/project_hydra.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+require 'rdf'
+class ActiveFedora::RDF::ProjectHydra < ::RDF::StrictVocabulary("http://projecthydra.org/ns/relations#")
+  property :hasProfile,
+    label: "Has Profile".freeze,
+    subPropertyOf: "info:fedora/fedora-system:def/relations-external#fedoraRelationship".freeze,
+    type: "rdf:Property".freeze
+  property :isGovernedBy,
+    label: "Is Governed By".freeze,
+    subPropertyOf: "info:fedora/fedora-system:def/relations-external#fedoraRelationship".freeze,
+    type: "rdf:Property".freeze
+end

data/lib/active_fedora/reflection.rb

@@ -192,7 +192,10 @@ module ActiveFedora
       end
 
       def solr_key
-        ActiveFedora::SolrService.solr_name(predicate.to_s, :symbol)
+        @solr_key ||= begin
+          predicate_string = predicate.fragment || predicate.to_s.rpartition(/\//).last
+          ActiveFedora::SolrQueryBuilder.solr_name(predicate_string, :symbol)
+        end
       end
 
       def check_validity!

data/lib/active_fedora/relation/finder_methods.rb

@@ -178,7 +178,7 @@ module ActiveFedora
       if where_values.empty?
         load_from_fedora(id, cast)
       else
-        conditions = where_values + [ActiveFedora::SolrService.raw_query(SOLR_DOCUMENT_ID, id)]
+        conditions = where_values + [ActiveFedora::SolrQueryBuilder.raw_query(SOLR_DOCUMENT_ID, id)]
         query = conditions.join(" AND ".freeze)
         to_enum(:find_each, query, {}).to_a.first
       end
@@ -204,7 +204,7 @@ module ActiveFedora
 
     # TODO just use has_model
     def has_model_value(resource)
-      Ldp::Orm.new(resource).value(::RDF::URI.new("http://fedora.info/definitions/v4/rels-ext#hasModel")).first.to_s
+      Ldp::Orm.new(resource).value(ActiveFedora::RDF::Fcrepo::Model.hasModel).first.to_s
     end
 
     def find_with_ids(ids, cast)
@@ -259,7 +259,7 @@ module ActiveFedora
         # if the key is a property name, turn it into a solr field
         if @klass.delegated_attributes.key?(key)
           # TODO Check to see if `key' is a possible solr field for this class, if it isn't try :searchable instead
-          key = ActiveFedora::SolrService.solr_name(key, :stored_searchable, type: :string)
+          key = ActiveFedora::SolrQueryBuilder.solr_name(key, :stored_searchable, type: :string)
         end
 
         if value.empty?
@@ -278,7 +278,7 @@ module ActiveFedora
       # The concrete class could could be any subclass of @klass or @klass itself
       unless @klass == ActiveFedora::Base
         clauses = ([@klass] + @klass.descendants).map do |k|
-          ActiveFedora::SolrService.construct_query_for_rel(has_model: k.to_s)
+          ActiveFedora::SolrQueryBuilder.construct_query_for_rel(has_model: k.to_s)
         end
         clauses.size == 1 ? clauses.first : "(#{clauses.join(" OR ")})"
       end

data/lib/active_fedora/simple_datastream.rb

@@ -27,15 +27,15 @@ module ActiveFedora
 
     # This method generates the various accessor and mutator methods on self for the datastream metadata attributes.
     # each field will have the 2 magic methods:
-    #   name=(arg) 
-    #   name 
+    #   name=(arg)
+    #   name
     #
     #
     # 'datatype' is a datatype, currently :string, :integer and :date are supported.
     #
     # opts is an options hash, which  will affect the generation of the xml representation of this datastream.
     #
-    # Currently supported modifiers: 
+    # Currently supported modifiers:
     # For +SimpleDatastream+:
     #   :element_attrs =>{:foo=>:bar} -  hash of xml element attributes
     #   :xml_node => :nodename  - The xml node to be used to represent this object (in dcterms namespace)
@@ -45,8 +45,8 @@ module ActiveFedora
     #
     #There is quite a good example of this class in use in spec/examples/oral_history.rb
     #
-    #!! Careful: If you declare two fields that correspond to the same xml node without any qualifiers to differentiate them, 
-    #you will end up replicating the values in the underlying datastream, resulting in mysterious dubling, quadrupling, etc. 
+    #!! Careful: If you declare two fields that correspond to the same xml node without any qualifiers to differentiate them,
+    #you will end up replicating the values in the underlying datastream, resulting in mysterious dubling, quadrupling, etc.
     #whenever you edit the field's values.
     def field(name, datatype=:string, opts={})
       fields ||= {}
@@ -59,9 +59,8 @@ module ActiveFedora
         self.class.terminology.add_term(term)
         term.generate_xpath_queries!
       end
-      
     end
-    
+
     def update_indexed_attributes(params={}, opts={})
       raise "can't modify frozen #{self.class}" if frozen?
       # if the params are just keys, not an array, make then into an array.
@@ -75,7 +74,7 @@ module ActiveFedora
       end
       super(new_params, opts)
     end
-    
+
 
     def self.xml_template
        Nokogiri::XML::Document.parse("<fields/>")
@@ -85,10 +84,10 @@ module ActiveFedora
       @fields.each do |field_key, field_info|
         next if field_key == :location ## FIXME HYDRA-825
         things = send(field_key)
-        if things 
-          field_symbol = ActiveFedora::SolrService.solr_name(field_key, type: field_info[:type])
-          things.val.each do |val|    
-            ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val.to_s )         
+        if things
+          field_symbol = ActiveFedora::SolrQueryBuilder.solr_name(field_key, type: field_info[:type])
+          things.val.each do |val|
+            ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val.to_s )
           end
         end
       end

data/lib/active_fedora/solr_instance_loader.rb

@@ -51,7 +51,7 @@ module ActiveFedora
     end
 
     def active_fedora_class
-      @active_fedora_class ||= ActiveFedora::SolrService.class_from_solr_document(solr_doc)
+      @active_fedora_class ||= ActiveFedora::QueryResultBuilder.class_from_solr_document(solr_doc)
     end
 
     def profile_json

data/lib/active_fedora/solr_query_builder.rb

@@ -0,0 +1,57 @@
+module ActiveFedora
+  module SolrQueryBuilder
+    # Construct a solr query for a list of ids
+    # This is used to get a solr response based on the list of ids in an object's RELS-EXT relationhsips
+    # 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)
+    end
+
+    # Create a raw query clause suitable for sending to solr as an fq element
+    # @param [String] key
+    # @param [String] value
+    def self.raw_query(key, value)
+      "_query_:\"{!raw f=#{key}}#{value.gsub('"', '\"')}\""
+    end
+
+    def self.solr_name(*args)
+      Solrizer.default_field_mapper.solr_name(*args)
+    end
+
+    # Create a query with a clause for each key, value
+    # @param [Hash, Array<Array<String>>] args key is the predicate, value is the target_uri
+    # @param [String] join_with ('AND') the value we're joining the clauses with
+    # @example
+    #   construct_query_for_rel [[:has_model, "info:fedora/afmodel:ComplexCollection"], [:has_model, "info:fedora/afmodel:ActiveFedora_Base"]], 'OR'
+    #   # => _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"
+    #
+    #   construct_query_for_rel [[Book.reflect_on_association(:library), "foo/bar/baz"]]
+    def self.construct_query_for_rel(field_pairs, join_with = 'AND')
+      field_pairs = field_pairs.to_a if field_pairs.kind_of? Hash
+
+      clauses = pairs_to_clauses(field_pairs.reject { |_, target_uri| target_uri.blank? })
+      clauses.empty? ? "id:NEVER_USE_THIS_ID" : clauses.join(" #{join_with} ".freeze)
+    end
+
+    private
+      # Given an list of 2 element lists, transform to a list of solr clauses
+      def self.pairs_to_clauses(pairs)
+        pairs.map do |field, target_uri|
+          raw_query(solr_field(field), target_uri)
+        end
+      end
+
+      # @param [String, ActiveFedora::Relation] field
+      # @return [String] the corresponding solr field for the string
+      def self.solr_field(field)
+        case field
+        when ActiveFedora::Reflection::AssociationReflection
+          field.solr_key
+        else
+          solr_name(field, :symbol)
+        end
+      end
+  end
+end

data/lib/active_fedora/solr_service.rb

@@ -35,55 +35,30 @@ module ActiveFedora
       end
 
       def lazy_reify_solr_results(solr_results, opts = {})
-        Enumerator.new do |yielder|
-          solr_results.each do |hit|
-            yielder.yield(reify_solr_result(hit, opts))
-          end
-        end
+        Deprecation.warn SolrService, "SolrService.lazy_reify_solr_results is deprecated. Use QueryResultBuilder.lazy_reify_solr_results instead. This will be removed in active-fedora 10.0"
+        QueryResultBuilder.lazy_reify_solr_results(solr_results, opts)
       end
 
       def reify_solr_results(solr_results, opts = {})
-        solr_results.collect {|hit| reify_solr_result(hit, opts)}
+        Deprecation.warn SolrService, "SolrService.reify_solr_results is deprecated. Use QueryResultBuilder.reify_solr_results instead. This will be removed in active-fedora 10.0"
+        QueryResultBuilder.reify_solr_results(solr_results, opts)
       end
 
       def reify_solr_result(hit, opts = {})
-        klass = class_from_solr_document(hit)
-        klass.find(hit[SOLR_DOCUMENT_ID], cast: true)
+        Deprecation.warn SolrService, "SolrService.reify_solr_result is deprecated. Use QueryResultBuilder.reify_solr_result instead. This will be removed in active-fedora 10.0"
+        QueryResultBuilder.reify_solr_result(hit, opts)
       end
 
       #Returns all possible classes for the solr object
       def classes_from_solr_document(hit, opts = {})
-        #Add ActiveFedora::Base as never stored in Solr explicitely.
-        #classes = [ActiveFedora::Base]
-        classes = []
-
-        hit[HAS_MODEL_SOLR_FIELD].each { |value| classes << Model.from_class_uri(value) }
-
-        classes.compact
+        Deprecation.warn SolrService, "SolrService.classes_from_solr_document is deprecated. Use QueryResultBuilder.classes_from_solr_document instead. This will be removed in active-fedora 10.0"
+        QueryResultBuilder.classes_from_solr_document(hit, opts)
       end
 
       #Returns the best singular class for the solr object
       def class_from_solr_document(hit, opts = {})
-        #Set the default starting point to the class specified, if available.
-        best_model_match = Model.from_class_uri(opts[:class]) unless opts[:class].nil?
-        Array(hit[HAS_MODEL_SOLR_FIELD]).each do |value|
-
-          model_value = Model.from_class_uri(value)
-
-          if model_value
-
-            # Set as the first model in case opts[:class] was nil
-            best_model_match ||= model_value
-
-            # If there is an inheritance structure, use the most specific case.
-            if best_model_match > model_value
-              best_model_match = model_value
-            end
-          end
-        end
-
-        ActiveFedora::Base.logger.warn "Could not find a model for #{hit["id"]}, defaulting to ActiveFedora::Base" unless best_model_match if ActiveFedora::Base.logger
-        best_model_match || ActiveFedora::Base
+        Deprecation.warn SolrService, "SolrService.class_from_solr_document is deprecated. Use QueryResultBuilder.class_from_solr_document instead. This will be removed in active-fedora 10.0"
+        QueryResultBuilder.class_from_solr_document(hit, opts)
       end
 
       # Construct a solr query for a list of ids
@@ -91,24 +66,26 @@ 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 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)
+        Deprecation.warn SolrService, "SolrService.construct_query_for_ids is deprecated. Use SolrQueryBuilder.construct_query_for_ids instead. This will be removed in active-fedora 10.0"
+        SolrQueryBuilder.construct_query_for_ids(id_array)
       end
 
       def construct_query_for_pids(id_array)
         Deprecation.warn SolrService, "construct_query_for_pids is deprecated and will be removed in active-fedora 10.0"
-        construct_query_for_ids(id_array)
+        SolrQueryBuilder.construct_query_for_ids(id_array)
       end
 
       # Create a raw query clause suitable for sending to solr as an fq element
       # @param [String] key
       # @param [String] value
       def raw_query(key, value)
-        "_query_:\"{!raw f=#{key}}#{value.gsub('"', '\"')}\""
+        Deprecation.warn SolrService, "SolrService.raw_query is deprecated. Use SolrQueryBuilder.raw_query instead. This will be removed in active-fedora 10.0"
+        SolrQueryBuilder.raw_query(key, value)
       end
 
       def solr_name(*args)
-        Solrizer.default_field_mapper.solr_name(*args)
+        Deprecation.warn SolrService, "SolrService.solr_name is deprecated. Use SolrQueryBuilder.solr_name instead. This will be removed in active-fedora 10.0"
+        SolrQueryBuilder.solr_name(*args)
       end
 
       # Create a query with a clause for each key, value
@@ -117,12 +94,11 @@ module ActiveFedora
       # @example
       #   construct_query_for_rel [[:has_model, "info:fedora/afmodel:ComplexCollection"], [:has_model, "info:fedora/afmodel:ActiveFedora_Base"]], 'OR'
       #   # => _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"
+      #
+      #   construct_query_for_rel [[Book.reflect_on_association(:library), "foo/bar/baz"]]
       def construct_query_for_rel(field_pairs, join_with = 'AND')
-        field_pairs = field_pairs.to_a if field_pairs.kind_of? Hash
-
-        clauses = field_pairs.reject{ |_, target_uri| target_uri.blank? }.
-          map { |predicate, target_uri| raw_query(solr_name(predicate, :symbol), target_uri) }
-        clauses.empty? ? "id:NEVER_USE_THIS_ID" : clauses.join(" #{join_with} ".freeze)
+        Deprecation.warn SolrService, "SolrService.construct_query_for_rel is deprecated. Use SolrQueryBuilder.construct_query_for_rel instead. This will be removed in active-fedora 10.0"
+        SolrQueryBuilder.construct_query_for_rel(field_pairs, join_with)
       end
 
       def query(query, args={})
@@ -157,10 +133,8 @@ module ActiveFedora
       def commit
         SolrService.instance.conn.commit
       end
-    end
-
-    HAS_MODEL_SOLR_FIELD = solr_name("has_model", :symbol).freeze
 
+    end
   end #SolrService
   class SolrNotInitialized < StandardError;end
 end #ActiveFedora

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "9.0.0.beta2"
+  VERSION = "9.0.0.beta3"
 end

data/lib/active_fedora/versionable.rb

@@ -20,23 +20,18 @@ module ActiveFedora
       end
     end
 
-    # Returns an array of RDF::Literal objects where the version label matches
-    # our own version label and excludes auto-snapshot versions from Fedora.
+    # Returns an array of uris matching our own version label, excluding auto-snapshot versions from Fedora.
     def versions
       results = versions_graph.query([nil, ::RDF::URI.new('http://fedora.info/definitions/v4/repository#hasVersionLabel'), nil])
-      numbered_versions(results)
+      numbered_versions(results).map { |v| version_uri(v.to_s) }
     end
 
     def versions_graph
       @versions_graph ||= ::RDF::Graph.new << ::RDF::Reader.for(:ttl).new(versions_request)
     end
 
-    def versions_url
-      uri + '/fcr:versions'
-    end
-
     def create_version
-      resp = ActiveFedora.fedora.connection.post(versions_url, nil, {slug: version_name})
+      resp = ActiveFedora.fedora.connection.post(versions_uri, nil, {slug: version_name})
       @versions_graph = nil
       resp.success?
     end
@@ -44,14 +39,14 @@ module ActiveFedora
     # This method does not rely on the internal versionable flag of the object, instead
     # it queries Fedora directly to figure out if there are versions for the resource.
     def has_versions?
-      ActiveFedora.fedora.connection.head(versions_url) 
+      ActiveFedora.fedora.connection.head(versions_uri) 
       true
     rescue Ldp::NotFound
       false
     end
 
     def restore_version label
-      resp = ActiveFedora.fedora.connection.patch(version_url(label), nil)
+      resp = ActiveFedora.fedora.connection.patch(version_uri(label), nil)
       @versions_graph = nil
       reload
       refresh_attributes if self.respond_to?("refresh_attributes")
@@ -62,7 +57,7 @@ module ActiveFedora
 
       def versions_request
         resp = begin
-          ActiveFedora.fedora.connection.get(versions_url)
+          ActiveFedora.fedora.connection.get(versions_uri)
         rescue Ldp::NotFound
           return ''
         end
@@ -74,10 +69,14 @@ module ActiveFedora
         resp.body
       end
 
-      def version_url label
-        versions_url + '/' + label
+      def versions_uri
+        uri + '/fcr:versions'
       end
 
+      def version_uri label
+        versions_uri + '/' + label
+      end      
+
       def version_name
         if versions.empty?
           "version1"

data/spec/integration/associations_spec.rb

@@ -483,8 +483,8 @@ describe ActiveFedora::Base do
         Object.send(:remove_const, :MediaObject)
       end
 
-      it "it should find the predicate" do
-        expect(MediaObject.new.association(:baubles).send(:find_predicate)).to eq 'http://fedora.info/definitions/v4/rels-ext#isPartOf'
+      it "it should find the reflection that bears the predicate" do
+        expect(MediaObject.new.association(:baubles).send(:find_reflection)).to eq Bauble.reflect_on_association(:media_object)
       end
     end
 
@@ -503,8 +503,8 @@ describe ActiveFedora::Base do
         Object.send(:remove_const, :MediaObject)
       end
 
-      it "it should find the predicate" do
-        expect(MediaObject.new.association(:parts).send(:find_predicate)).to eq 'http://fedora.info/definitions/v4/rels-ext#isPartOf'
+      it "it should find the reflection that bears the predicate" do
+        expect(MediaObject.new.association(:parts).send(:find_reflection)).to eq MasterFile.reflect_on_association(:media_object)
       end
     end
 
@@ -523,8 +523,8 @@ describe ActiveFedora::Base do
         Object.send(:remove_const, :MediaObject)
       end
 
-      it "it should find the predicate" do
-        expect(MediaObject.new.association(:baubles).send(:find_predicate)).to eq 'http://fedora.info/definitions/v4/rels-ext#hasEquivalent'
+      it "it should find the reflection that bears the predicate" do
+        expect(MediaObject.new.association(:baubles).send(:find_reflection)).to eq MediaObject.reflect_on_association(:baubles)
       end
     end
 

data/spec/integration/attributes_spec.rb

@@ -6,6 +6,7 @@ describe "delegating attributes" do
       set_terminology do |t|
         t.root(path: "fields")
         t.depositor index_as: [:symbol, :stored_searchable]
+        t.wrangler index_as: [:facetable]
       end
     end
     class TitledObject < ActiveFedora::Base
@@ -17,6 +18,7 @@ describe "delegating attributes" do
     class RdfObject < ActiveFedora::Base
       contains 'foo', class_name: 'PropertiesDatastream'
       has_attributes :depositor, datastream: :foo, multiple: false
+      has_attributes :wrangler, datastream: :foo, multiple: true
       property :resource_type, predicate: ::RDF::DC.type do |index|
         index.as :stored_searchable, :facetable
       end
@@ -47,7 +49,7 @@ describe "delegating attributes" do
     end
   end
 
-  context "with an rdf property" do
+  context "with multiple datastreams" do
 
     subject { RdfObject.create }
 
@@ -71,22 +73,36 @@ describe "delegating attributes" do
     end
 
     describe "setting attributes" do
-      
-      after do
-        expect(subject.depositor).to eql("foo")
-        expect(subject.resource_type).to eql(["bar"])
-      end
+
       specify "using strings for keys" do
         subject["depositor"] = "foo"
         subject["resource_type"] = "bar"
         subject.save
+        expect(subject.depositor).to eql("foo")
+        expect(subject.resource_type).to eql(["bar"])
       end
       specify "using symbols for keys" do
         subject[:depositor] = "foo"
         subject[:resource_type] = "bar"
         subject.save
+        expect(subject.depositor).to eql("foo")
+        expect(subject.resource_type).to eql(["bar"])
       end
 
+      # TODO: bug logged in issue #540
+      describe "using shift", pending: "has_changed? not returning true" do
+        specify "with rdf properties" do
+          subject.resource_type << "bar"
+          subject.save
+          expect(subject.resource_type).to eql(["bar"])
+        end
+        specify "with om terms" do
+          subject.wrangler << "bar"
+          subject.save
+          expect(subject.wrangler).to eql(["bar"])
+        end
+      end
+          
     end
 
   end