active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/solr_instance_loader.rb

@@ -1,67 +1,52 @@
 module ActiveFedora
   class FedoraSolrMismatchError < ActiveFedora::ObjectNotFoundError
-    def initialize(pid, solr_document_id)
-      super("Solr record id and pid do not match; Solr ID=#{solr_document_id}, PID=#{pid}")
+    def initialize(fedora_id, solr_document_id)
+      super("Solr ID and Fedora ID do not match; Solr ID=#{solr_document_id}, Fedora ID=#{fedora_id}")
     end
   end
 
   # Responsible for loading an ActiveFedora::Base proxy from a Solr document.
   class SolrInstanceLoader
-    attr_reader :context, :pid
-    private :context, :pid
-    def initialize(context, pid, solr_doc = nil)
+    attr_reader :context, :id
+    private :context, :id
+    def initialize(context, id, solr_doc = nil)
       @context = context
-      @pid = pid
+      @id = id
       @solr_doc = solr_doc
-      validate_solr_doc_and_pid!(@solr_doc)
+      validate_solr_doc_and_id!(@solr_doc)
     end
 
     def object
       return @object if @object
       @object = allocate_object
-      @object.rels_ext
-      load_object_datastreams(@object)
-      @object.inner_object.freeze
+      @object.readonly!
+      @object.freeze
       @object
     end
 
     private
 
     def allocate_object
-      active_fedora_class.allocate.init_with_object(solr_digital_object)
-    end
-
-    def solr_digital_object
-      SolrDigitalObject.new(solr_doc, profile_hash, active_fedora_class)
-    end
-
-
-    def load_object_datastreams(obj)
-      obj.datastreams.each_value do |ds|
-        if ds.respond_to?(:profile_from_hash) and (ds_prof = profile_hash['datastreams'][ds.dsid])
-          ds.profile_from_hash(ds_prof)
-        end
-        ds.from_solr(solr_doc) if ds.respond_to?(:from_solr)
-      end
+      active_fedora_class.allocate.init_with_json(profile_json)
     end
 
     def solr_doc
       @solr_doc ||= begin
-        result = context.find_with_conditions(:id=>pid)
+        result = context.find_with_conditions(id: id)
         if result.empty?
-          raise ActiveFedora::ObjectNotFoundError, "Object #{pid} not found in solr"
+          raise ActiveFedora::ObjectNotFoundError, "Object #{id} not found in solr"
         end
         @solr_doc = result.first
-        validate_solr_doc_and_pid!(@solr_doc)
+        validate_solr_doc_and_id!(@solr_doc)
         @solr_doc
       end
     end
 
-    def validate_solr_doc_and_pid!(document)
+    def validate_solr_doc_and_id!(document)
       return true if document.nil?
       solr_id = document[SOLR_DOCUMENT_ID]
-      if pid != solr_id
-        raise ActiveFedora::FedoraSolrMismatchError.new(pid, solr_id)
+      if id != solr_id
+        raise ActiveFedora::FedoraSolrMismatchError.new(id, solr_id)
       end
     end
 
@@ -71,17 +56,12 @@ module ActiveFedora
 
     def profile_json
       @profile_json ||= begin
-        profile_json = Array(solr_doc[ActiveFedora::Base.profile_solr_name]).first
+        profile_json = Array(solr_doc[ActiveFedora::IndexingService.profile_solr_name]).first
         unless profile_json.present?
-          raise ActiveFedora::ObjectNotFoundError, "Object #{pid} does not contain a solrized profile"
+          raise ActiveFedora::ObjectNotFoundError, "Object #{id} does not contain a solrized profile"
         end
         profile_json
       end
     end
-
-    def profile_hash
-      @profile_hash ||= ActiveSupport::JSON.decode(profile_json)
-    end
-
   end
 end

data/lib/active_fedora/solr_service.rb

@@ -1,14 +1,16 @@
 require 'rsolr'
+require 'deprecation'
 
 module ActiveFedora
   class SolrService
+    extend Deprecation
 
     attr_reader :conn
 
     def initialize(host, args)
       host = 'http://localhost:8080/solr' unless host
-      args = {:read_timeout => 120, :open_timeout => 120}.merge(args.dup)
-      args.merge!(:url=>host)
+      args = {read_timeout: 120, open_timeout: 120}.merge(args.dup)
+      args.merge!(url: host)
       @conn = RSolr.connect args
     end
 
@@ -46,25 +48,30 @@ module ActiveFedora
 
       def reify_solr_result(hit, opts = {})
         klass = class_from_solr_document(hit)
-        if opts[:load_from_solr]
-          klass.load_instance_from_solr(hit[SOLR_DOCUMENT_ID], hit)
-        else
-          klass.find(hit[SOLR_DOCUMENT_ID], cast: true)
-        end
+        klass.find(hit[SOLR_DOCUMENT_ID], cast: true)
+      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
       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?
-        model = hit.fetch(HAS_MODEL_SOLR_FIELD) do
-          raise "Solr document (id: #{hit['id']}) is missing required #{HAS_MODEL_SOLR_FIELD} field."
-        end
-        model.each do |value|
+        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
 
@@ -79,16 +86,20 @@ module ActiveFedora
         best_model_match || ActiveFedora::Base
       end
 
-      # Construct a solr query for a list of pids
-      # This is used to get a solr response based on the list of pids in an object's RELS-EXT relationhsips
-      # If the pid_array is empty, defaults to a query of "id:NEVER_USE_THIS_ID", which will return an empty solr response
-      # @param [Array] pid_array the pids that you want included in the query
-      def construct_query_for_pids(pid_array)
-        q = pid_array.reject { |x| x.empty? }.map { |pid| raw_query(SOLR_DOCUMENT_ID, pid) }
-
+      # 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 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
 
+      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)
+      end
+
       # Create a raw query clause suitable for sending to solr as an fq element
       # @param [String] key
       # @param [String] value
@@ -108,8 +119,10 @@ module ActiveFedora
       #   # => _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"
       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.map { |(predicate, target_uri)| raw_query(solr_name(predicate, :symbol), target_uri) }
-        clauses.join(" #{join_with} ".freeze)
+
+        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)
       end
 
       def query(query, args={})
@@ -120,6 +133,10 @@ module ActiveFedora
         result['response']['docs']
       end
 
+      def delete(id)
+        SolrService.instance.conn.delete_by_id(id, params: {'softCommit' => true})
+      end
+
       # Get the count of records that match the query
       # @param [String] query a solr query
       # @param [Hash] args arguments to pass through to `args' param of SolrService.query (note that :rows will be overwritten to 0)

data/lib/active_fedora/sparql_insert.rb

@@ -0,0 +1,45 @@
+module ActiveFedora
+  class SparqlInsert
+
+    attr_reader :changes, :subject
+
+    def initialize(changes, subject = ::RDF::URI.new(nil))
+      @changes = changes
+      @subject = subject
+    end
+
+    def execute(uri)
+      result = ActiveFedora.fedora.connection.patch(uri, build, "Content-Type" => "application/sparql-update")
+      return true if result.status == 204
+      raise "Problem updating #{result.status} #{result.body}"
+    end
+
+    def build
+      query = deletes(subject).join
+      query += "INSERT { \n"
+      query +=
+        changes.map do |_, result|
+          result.map do |statement|
+            ::RDF::Query::Pattern.new(subject: subject, predicate: statement.predicate, object: statement.object).to_s
+          end.join("\n")
+        end.join("\n")
+
+      query += "\n}\n WHERE { }"
+      query
+    end
+
+    private
+
+    def deletes(subject)
+      patterns(subject).map do |pattern|
+        "DELETE { #{pattern} }\n  WHERE { #{pattern} } ;\n"
+      end
+    end
+
+    def patterns(subject)
+      changes.map do |key, _|
+        ::RDF::Query::Pattern.new(subject, key, :change).to_s
+      end
+    end
+  end
+end

data/lib/active_fedora/test_support.rb

@@ -1,27 +1,6 @@
 require File.expand_path('../../../spec/support/an_active_model', __FILE__)
 module ActiveFedora
   module TestSupport
-
-    # Assert that all of the :objects are persisted the :subject's RELS-EXT entry
-    # with the :predicate.
-    def assert_rels_ext(subject, predicate, objects = [])
-      assert_equal objects.count, subject.relationships(predicate).count
-      objects.each do |object|
-        internal_uri = object.respond_to?(:internal_uri) ?
-          object.internal_uri : object
-        assert subject.relationships(predicate).include?(internal_uri)
-      end
-    end
-
-    # Assert that the :subject's RELS-EXT for predicate :has_model collection
-    # includes the class_name
-    def assert_rels_ext_has_model(subject, class_name)
-      model_relationships = subject.relationships(:has_model)
-      assert_block("Expected afmodel:#{class_name} to be defined in #{model_relationships.inspect}") do
-        model_relationships.detect {|r| r =~ /\/afmodel:#{class_name}\Z/ }
-      end
-    end
-
     # Assert that the :subject's :association_name equals the input :object
     def assert_active_fedora_belongs_to(subject, association_name, object)
       subject.send(association_name).must_equal object
@@ -36,4 +15,4 @@ module ActiveFedora
       end
     end
   end
-end
+end

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "8.7.0"
+  VERSION = "9.0.0.beta1"
 end

data/lib/active_fedora/versionable.rb

@@ -0,0 +1,90 @@
+module ActiveFedora
+  module Versionable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :versionable
+    end
+
+    module ClassMethods
+      def has_many_versions
+        self.versionable = true
+      end
+    end
+
+    # TODO: This only applies to objects. If we want the same for child resources, it would need to go
+    # under fcr:metadata
+    def model_type
+      if self.respond_to?(:metadata)
+        metadata.ldp_source.graph.query(predicate: ::RDF.type).objects
+      else
+        resource.query(subject: resource.rdf_subject, predicate: ::RDF.type).objects
+      end
+    end
+
+    def versions
+      results = versions_graph.query([nil, ::RDF::URI.new('http://fedora.info/definitions/v4/repository#hasVersionLabel'), nil])
+      results.map(&:object)
+    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})
+      @versions_graph = nil
+      resp.success?
+    end
+
+    # 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) 
+      true
+    rescue Ldp::NotFound
+      false
+    end
+
+    def restore_version label
+      resp = ActiveFedora.fedora.connection.patch(version_url(label), nil)
+      @versions_graph = nil
+      reload
+      refresh_attributes if self.respond_to?("refresh_attributes")
+      resp.success?
+    end
+
+    private
+
+      def versions_request
+        resp = begin
+          ActiveFedora.fedora.connection.get(versions_url)
+        rescue Ldp::NotFound
+          return ''
+        end
+        if !resp.success?
+          raise "unexpected return value #{resp.status} for when getting datastream content at #{uri}\n\t#{resp.body}"
+        elsif resp.headers['content-type'] != 'text/turtle'
+          raise "unknown response format. got '#{resp.headers['content-type']}', but was expecting 'text/turtle'"
+        end
+        resp.body
+      end
+
+      def version_url label
+        versions_url + '/' + label
+      end
+
+      def version_name
+        if versions.empty?
+          "version1"
+        else
+          "version" + (versions.count + 1).to_s
+        end
+      end
+
+  end
+end

data/lib/active_fedora/with_metadata.rb

@@ -0,0 +1,37 @@
+module ActiveFedora
+  module WithMetadata
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :MetadataNode
+
+    def metadata_node
+      @metadata_node ||= self.class.metadata_schema.new(self)
+    end
+
+    def save(*)
+      if super
+        metadata_node.metadata_uri = described_by # TODO only necessary if the URI was < > before
+        metadata_node.save # TODO if changed?
+      end
+    end
+
+    module ClassMethods
+      def metadata(&block)
+        metadata_schema.exec_block(&block)
+      end
+
+      def metadata_schema
+        @metadata_schema ||= MetadataNode(self)
+      end
+
+      # Make a subclass of MetadataNode named GeneratedMetadataSchema and set its
+      # parent_class attribute to have the value of the current class.
+      def MetadataNode(parent_klass)
+        klass = self.const_set(:GeneratedMetadataSchema, Class.new(MetadataNode))
+        klass.parent_class = parent_klass
+        klass
+      end
+    end
+  end
+end

data/lib/active_fedora/with_metadata/metadata_node.rb

@@ -0,0 +1,70 @@
+module ActiveFedora
+  module WithMetadata
+    class MetadataNode < ActiveTriples::Resource
+      include ActiveModel::Dirty
+      attr_reader :file
+
+      def initialize(file)
+        @file = file
+        super(file.uri, ldp_source.graph)
+      end
+
+      def metadata_uri= uri
+        @metadata_uri = uri
+      end
+
+      def metadata_uri
+        @metadata_uri ||= if file.new_record?
+          ::RDF::URI.new nil
+        else
+          raise "#{file} must respond_to described_by" unless file.respond_to? :described_by
+          file.described_by
+        end
+      end
+
+      def set_value(*args)
+        super
+        attribute_will_change! args.first
+      end
+
+      def ldp_source
+        @ldp_source ||= LdpResource.new(ldp_connection, metadata_uri)
+      end
+
+      def ldp_connection
+        ActiveFedora.fedora.connection
+      end
+
+      def save
+        raise "Save the file first" if file.new_record?
+        change_set = ChangeSet.new(self, self, changed_attributes.keys)
+        SparqlInsert.new(change_set.changes, ::RDF::URI.new(file.uri)).execute(metadata_uri)
+        @ldp_source = nil
+        true
+      end
+
+      class << self
+        def parent_class= parent
+          @parent_class = parent
+        end
+
+        def parent_class
+          @parent_class
+        end
+
+        def property(name, options)
+          parent_class.delegate name, :"#{name}=", :"#{name}_changed?", to: :metadata_node
+          super
+        end
+
+        def create_delegating_setter(name)
+          file.class.delegate(name, to: :metadata_node)
+        end
+
+        def exec_block(&block)
+          class_eval &block
+        end
+      end
+    end
+  end
+end