hyrax 3.0.0.pre.rc4 → 3.1.0

data/lib/wings/converter_value_mapper.rb

@@ -73,7 +73,7 @@ module Wings
     end
 
     def result
-      collections = value.last.map { |id| ActiveFedora::Base.find(id.id) }
+      collections = value.last.map { |id| ActiveFedora::Base.find(id.to_s) }
       [:member_of_collections, collections]
     end
   end
@@ -86,7 +86,7 @@ module Wings
     end
 
     def result
-      members = value.last.map { |id| ActiveFedora::Base.find(id.id) }
+      members = value.last.map { |id| ActiveFedora::Base.find(id.to_s) }
       [:members, members]
     end
   end

data/lib/wings/model_transformer.rb

@@ -110,39 +110,25 @@ module Wings
     private
 
     def mint_id
-      id = pcdm_object.assign_id
+      id = pcdm_object.try(:assign_id)
 
       pcdm_object.id = id if id.present?
     end
 
     def attributes
-      attribute_source = pcdm_object.try(:metadata_node) || pcdm_object
-
-      all_keys =
-        attribute_source.attributes.keys +
-        OrmConverter.relationship_keys_for(reflections: pcdm_object.try(:reflections))
-
-      result = AttributeTransformer.for(pcdm_object)
-                                   .run(pcdm_object, all_keys)
-                                   .merge(reflection_ids)
-                                   .merge(additional_attributes)
+      transformer = AttributeTransformer.for(pcdm_object)
+      result = transformer.run(pcdm_object).merge(additional_attributes)
 
       append_embargo(result)
       append_lease(result)
+      append_permissions(result)
 
       result
     end
 
-    def reflection_ids
-      keys = pcdm_object.try(:reflections)&.keys || []
-
-      keys.select { |k| k.to_s.end_with? '_id' }.each_with_object({}) do |k, mem|
-        mem[k] = pcdm_object.try(k)
-      end
-    end
-
     def additional_attributes
-      { :created_at => pcdm_object.try(:create_date),
+      { :id => pcdm_object.id,
+        :created_at => pcdm_object.try(:create_date),
         :updated_at => pcdm_object.try(:modified_date),
         :member_ids => member_ids,
         ::Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token }
@@ -183,5 +169,20 @@ module Wings
 
       attrs[:lease] = Hyrax::Lease.new(**lease_attrs)
     end
+
+    def append_permissions(attrs)
+      return unless pcdm_object.try(:permissions)
+      attrs[:permissions] = pcdm_object.permissions.map do |permission|
+        agent = permission.type == 'group' ? "group/#{permission.agent_name}" : permission.agent_name
+
+        Hyrax::Permission.new(id: permission.id,
+                              mode: permission.access.to_sym,
+                              agent: agent,
+                              access_to: ::Valkyrie::ID.new(permission.access_to_id),
+                              new_record: permission.new_record?)
+      end
+
+      attrs[:access_to] = attrs[:permissions].find { |p| p.access_to&.id&.present? }&.access_to
+    end
   end
 end

data/lib/wings/orm_converter.rb

@@ -2,20 +2,10 @@
 
 module Wings
   ##
+  # @api private
+  #
   # Transform AF object class to Valkyrie::Resource class representation.
   class OrmConverter
-    ##
-    # @param reflections [Hash<Symbol, Object>]
-    #
-    # @return [Array<Symbol>]
-    def self.relationship_keys_for(reflections:)
-      Hash(reflections).keys.map do |k|
-        key_string = k.to_s
-        next if key_string.include?('id') || key_string.include?('proxies')
-        key_string.singularize + '_ids'
-      end.compact
-    end
-
     ##
     # Selects an existing base class for the generated valkyrie class
     #
@@ -39,9 +29,6 @@ module Wings
     # rubocop:disable Metrics/MethodLength because metaprogramming a class
     #   results in long methods
     def self.to_valkyrie_resource_class(klass:)
-      relationship_keys = klass.respond_to?(:reflections) ? relationship_keys_for(reflections: klass.reflections) : []
-      reflection_id_keys = klass.respond_to?(:reflections) ? klass.reflections.keys.select { |k| k.to_s.end_with? '_id' } : []
-
       Class.new(base_for(klass: klass)) do
         # store a string we can resolve to the internal resource
         @internal_resource = klass.try(:to_rdf_representation) || klass.name
@@ -53,6 +40,12 @@ module Wings
             _canonical_valkyrie_model&.name
           end
 
+          ##
+          # @return [String]
+          def to_s
+            internal_resource
+          end
+
           ##
           # @api private
           def _canonical_valkyrie_model
@@ -60,8 +53,18 @@ module Wings
           end
         end
 
-        def self.to_s
-          internal_resource
+        ##
+        # @return [URI::GID]
+        def to_global_id
+          URI::GID.build([GlobalID.app, internal_resource, id, {}])
+        end
+
+        ##
+        # @return [ActiveModel::Base]
+        def to_model
+          model_class = internal_resource.safe_constantize || self
+
+          Hyrax::ActiveFedoraDummyModel.new(model_class, id)
         end
 
         klass.properties.each_key do |property_name|
@@ -74,14 +77,30 @@ module Wings
           end
         end
 
-        relationship_keys.each do |linked_property_name|
-          next if fields.include?(linked_property_name.to_sym)
-          attribute linked_property_name.to_sym, ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
+        # add reflection associations
+        ldp_reflections = (klass.try(:reflections) || []).select do |_key, reflection|
+          case reflection
+          when ActiveFedora::Reflection::FilterReflection,
+               ActiveFedora::Reflection::OrdersReflection,
+               ActiveFedora::Reflection::BasicContainsReflection,
+               ActiveFedora::Reflection::HasSubresourceReflection
+            false
+          else
+            true
+          end
         end
 
-        reflection_id_keys.each do |property_name|
-          next if fields.include?(property_name.to_sym)
-          attribute property_name, ::Valkyrie::Types::ID
+        ldp_reflections.each do |reflection_key, reflection|
+          if reflection.collection?
+            type           = ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
+            attribute_name = (reflection_key.to_s.singularize + '_ids').to_sym
+          else
+            type           = ::Valkyrie::Types::ID.optional
+            attribute_name = (reflection_key.to_s.singularize + '_id').to_sym
+          end
+
+          next if fields.include?(attribute_name)
+          attribute attribute_name, type
         end
 
         def internal_resource

data/lib/wings/setup.rb

@@ -2,6 +2,7 @@
 
 ActiveFedora::Base.include Wings::Valkyrizable
 ActiveFedora::File.include Wings::Valkyrizable
+Hydra::AccessControl.include Wings::Valkyrizable
 
 module ActiveTriples
   class NodeConfig
@@ -76,6 +77,7 @@ Valkyrie.config.storage_adapter = :active_fedora
 #       A refactor is needed to add the default implementations to hyrax.rb and only handle the wings specific overrides here.
 custom_queries = [Hyrax::CustomQueries::Navigators::CollectionMembers,
                   Hyrax::CustomQueries::Navigators::ChildCollectionsNavigator,
+                  Hyrax::CustomQueries::Navigators::ParentCollectionsNavigator,
                   Hyrax::CustomQueries::Navigators::ChildFilesetsNavigator,
                   Hyrax::CustomQueries::Navigators::ChildWorksNavigator,
                   Hyrax::CustomQueries::Navigators::FindFiles,

data/lib/wings/valkyrie/persister.rb

@@ -41,9 +41,10 @@ module Wings
       # @param [Valkyrie::Resource] resource
       # @return [Valkyrie::Resource] the persisted/updated resource
       def save_all(resources:)
-        resources.map do |resource|
-          save(resource: resource)
-        end
+        resources.map { |resource| save(resource: resource) }
+      rescue ::Valkyrie::Persistence::StaleObjectError => _err
+        raise(::Valkyrie::Persistence::StaleObjectError,
+              "One or more resources have been updated by another process.")
       end
 
       # Deletes a resource persisted using ActiveFedora
@@ -51,8 +52,9 @@ module Wings
       # @return [Valkyrie::Resource] the deleted resource
       def delete(resource:)
         af_object = ActiveFedora::Base.new
-        af_object.id = resource.alternate_ids.first.to_s
+        af_object.id = resource.id
         af_object.delete
+        resource
       end
 
       # Deletes all resources from Fedora and Solr
@@ -83,7 +85,8 @@ module Wings
           etag_lock_token_valid?(af_object: af_object, resource: resource) &&
           last_modified_lock_token_valid?(af_object: af_object, resource: resource)
 
-        raise(::Valkyrie::Persistence::StaleObjectError, resource.id.to_s)
+        raise(::Valkyrie::Persistence::StaleObjectError,
+              "The object #{resource.id} has been updated by another process.")
       end
 
       ##

data/lib/wings/valkyrie/query_service.rb

@@ -2,16 +2,32 @@
 
 module Wings
   module Valkyrie
+    ##
+    # @note does not support duplicates!
     class QueryService
       attr_reader :adapter
       extend Forwardable
       def_delegator :adapter, :resource_factory
 
-      # @param adapter [Wings::Valkyrie::MetadataAdapter] The adapter which holds the resource_factory for this query_service.
+      ##
+      # @param adapter [Wings::Valkyrie::MetadataAdapter] The adapter which
+      #   holds the resource_factory for this query_service.
       def initialize(adapter:)
         @adapter = adapter
       end
 
+      ##
+      # @param :model [Class]
+      #
+      # @return [Integer]
+      def count_all_of_model(model:)
+        ActiveFedora::Base
+          .where(has_model_ssim: [model_class_for(model).to_rdf_representation,
+                                  model.new.internal_resource.to_s])
+          .count
+      end
+
+      ##
       # WARNING: In general, prefer find_by_alternate_identifier over this
       # method.
       #
@@ -23,14 +39,17 @@ module Wings
       # start getting ObjectNotFoundErrors instead of the objects you wanted
       #
       # Find a record using a Valkyrie ID, and map it to a Valkyrie Resource
+      #
       # @param [Valkyrie::ID, String] id
       # @return [Valkyrie::Resource]
-      # @raise [Hyrax::ObjectNotFoundError]
+      # @raise [Valkyrie::Persistence::ObjectNotFoundError]
       def find_by(id:)
         find_by_alternate_identifier(alternate_identifier: id)
       end
 
+      ##
       # Find all work/collection records, and map to Valkyrie Resources
+      #
       # @return [Array<Valkyrie::Resource>]
       def find_all
         ::ActiveFedora::Base.all.map do |obj|
@@ -38,7 +57,10 @@ module Wings
         end
       end
 
-      # Find all work/collection records of a given model, and map to Valkyrie Resources
+      ##
+      # Find all work/collection records of a given model, and map to Valkyrie
+      # Resources
+      #
       # @param model [Class]
       # @return [Array<Valkyrie::Resource>]
       def find_all_of_model(model:)
@@ -47,69 +69,89 @@ module Wings
         end
       end
 
-      # Find an array of record using Valkyrie IDs, and map them to Valkyrie Resources maintaining order based on given ids
+      ##
+      # Find an array of record using Valkyrie IDs, and map them to Valkyrie
+      # Resources maintaining order based on given ids
+      #
+      # @note ignores non-existent ids.
+      #
       # @param [Array<Valkyrie::ID, String>] ids
+      #
       # @return [Array<Valkyrie::Resource>]
-      # NOTE: Ignores non-existent ids.
+      # @raise [ArgumentError]
       def find_many_by_ids(ids:)
-        ids.each do |id|
-          id = ::Valkyrie::ID.new(id.to_s) if id.is_a?(String)
-          validate_id(id)
-        end
-        resources = []
-        ids.uniq.map(&:to_s).each do |id|
+        ids.all? { |i| i.respond_to?(:to_str) } ||
+          raise(ArgumentError, 'id must be a Valkyrie::ID')
+
+        return enum_for(:find_many_by_ids, ids: ids) unless block_given?
+
+        ids.map(&:to_s).uniq.each do |id|
           begin
             af_object = ActiveFedora::Base.find(id)
-            resources << resource_factory.to_resource(object: af_object)
+            yield resource_factory.to_resource(object: af_object)
           rescue ::ActiveFedora::ObjectNotFoundError, Ldp::Gone
             next
           end
         end
-        resources
       end
 
+      ##
       # Find a record using an alternate ID, and map it to a Valkyrie Resource
+      #
       # @param [Valkyrie::ID, String] id
       # @param [boolean] optionally return ActiveFedora object/errors
+      #
       # @return [Valkyrie::Resource]
-      # @raise [Hyrax::ObjectNotFoundError]
+      # @raise [Valkyrie::Persistence::ObjectNotFoundError]
       def find_by_alternate_identifier(alternate_identifier:, use_valkyrie: true)
-        alternate_identifier = ::Valkyrie::ID.new(alternate_identifier.to_s) if alternate_identifier.is_a?(String)
-        validate_id(alternate_identifier)
-        object = ::ActiveFedora::Base.find(alternate_identifier.to_s)
-        return object if use_valkyrie == false
-        resource_factory.to_resource(object: object)
-      rescue ActiveFedora::ObjectNotFoundError, Ldp::Gone
-        raise Hyrax::ObjectNotFoundError
+        raise(ArgumentError, 'id must be a Valkyrie::ID') unless
+          alternate_identifier.respond_to?(:to_str)
+
+        af_object = ActiveFedora::Base.find(alternate_identifier.to_s)
+
+        use_valkyrie ? resource_factory.to_resource(object: af_object) : af_object
+      rescue ActiveFedora::ObjectNotFoundError, Ldp::Gone => err
+        raise err unless use_valkyrie
+        raise ::Valkyrie::Persistence::ObjectNotFoundError
       end
 
+      ##
       # Find all members of a given resource, and map to Valkyrie Resources
+      #
       # @param resource [Valkyrie::Resource]
       # @param model [Class]
+      #
       # @return [Array<Valkyrie::Resource>]
       def find_members(resource:, model: nil)
-        return [] unless resource.respond_to?(:member_ids) && resource.member_ids.present?
-        all_members = find_many_by_ids(ids: resource.member_ids)
-        return all_members unless model
+        return [] if resource.try(:member_ids).blank?
+        return find_many_by_ids(ids: resource.member_ids) unless model
+
         find_model = model_class_for(model)
-        all_members.select { |member_resource| model_class_for(member_resource.class) == find_model }
+        find_many_by_ids(ids: resource.member_ids)
+          .select { |member_resource| model_class_for(member_resource.class) == find_model }
       end
 
+      ##
       # Find the Valkyrie Resources referenced by another Valkyrie Resource
+      #
       # @param resource [<Valkyrie::Resource>]
       # @param property [Symbol] the property holding the references to another resource
       # @return [Array<Valkyrie::Resource>]
-      def find_references_by(resource:, property:)
-        object = resource_factory.from_resource(resource: resource)
-        object.send(property).map do |reference|
-          af_id = find_id_for(reference)
-          resource_factory.to_resource(object: ::ActiveFedora::Base.find(af_id))
+      def find_references_by(resource:, property:, model: nil)
+        return find_many_by_ids(ids: Array(resource.send(property))) unless model
+
+        results = resource.public_send(property).map do |reference|
+          resource_factory.to_resource(object: ::ActiveFedora::Base.find(reference))
         end
+
+        results.select { |r| r.class.name == model.name }
       rescue ActiveFedora::ObjectNotFoundError
         []
       end
 
+      ##
       # Get all resources which link to a resource or id with a given property.
+      #
       # @param resource [Valkyrie::Resource] The resource which is being referenced by
       #   other resources.
       # @param resource [Valkyrie::ID] The id of the resource which is being referenced by
@@ -121,30 +163,37 @@ module Wings
       # @return [Array<Valkyrie::Resource>] All resources in the persistence backend
       #   which have the ID of the given `resource` in their `property` property. Not
       #   in order.
-      def find_inverse_references_by(resource: nil, id: nil, property:)
+      def find_inverse_references_by(resource: nil, id: nil, model: nil, property:)
         raise ArgumentError, "Provide resource or id" unless resource || id
-        id ||= resource.alternate_ids.first
+        id ||= resource.id
         raise ArgumentError, "Resource has no id; is it persisted?" unless id
-        uri = Hyrax::Base.id_to_uri(id.to_s)
-        ActiveFedora::Base.where("+(#{property}_ssim: \"#{uri}\" OR #{property}_ssim: \"#{id}\")").map do |obj|
+
+        active_fedora_model = model ? model_class_for(model) : ActiveFedora::Base
+
+        uri = active_fedora_model.id_to_uri(id.to_s)
+        active_fedora_model.where("+(#{property}_ssim: \"#{uri}\" OR #{property}_ssim: \"#{id}\")").map do |obj|
           resource_factory.to_resource(object: obj)
         end
       end
 
+      ##
       # Find all parents of a given resource.
+      #
       # @param resource [Valkyrie::Resource] The resource whose parents are being searched
       #   for.
       # @return [Array<Valkyrie::Resource>] All resources which are parents of the given
       #   `resource`. This means the resource's `id` appears in their `member_ids`
       #   array.
       def find_parents(resource:)
-        id = resource.alternate_ids.first
-        ActiveFedora::Base.where("member_ids_ssim: \"#{id}\"").map do |obj|
+        ActiveFedora::Base.where("member_ids_ssim: \"#{resource.id}\"").map do |obj|
           resource_factory.to_resource(object: obj)
         end
       end
 
-      # Constructs a Valkyrie::Persistence::CustomQueryContainer using this query service
+      ##
+      # Constructs a Valkyrie::Persistence::CustomQueryContainer using this
+      # query service
+      #
       # @return [Valkyrie::Persistence::CustomQueryContainer]
       def custom_queries
         @custom_queries ||= ::Valkyrie::Persistence::CustomQueryContainer.new(query_service: self)
@@ -152,7 +201,9 @@ module Wings
 
       private
 
+      ##
       # Determines whether or not an Object is a Valkyrie ID
+      #
       # @param [Object] id
       # @raise [ArgumentError]
       def validate_id(id)
@@ -160,10 +211,14 @@ module Wings
       end
 
       def find_id_for(reference)
-        return ::Hyrax::Base.uri_to_id(reference.id) if reference.class == ActiveTriples::Resource
-        return reference if reference.class == String
-        # not a supported type
-        ''
+        case reference
+        when ActiveTriples::Resource
+          ::Hyrax::Base.uri_to_id(reference.id)
+        when String
+          reference
+        else # not a supported type
+          ''
+        end
       end
 
       def model_class_for(model)