hyrax 3.0.0.pre.rc2 → 3.0.0.pre.rc3

data/lib/wings/active_fedora_converter/default_work.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Wings
+  class ActiveFedoraConverter
+    def self.apply_properties(klass, schema)
+      schema.each { |schema_key| PropertyApplicator.new(schema_key).apply(klass) }
+    end
+
+    ##
+    # Constructs an ActiveFedora property from a Dry::Types schema key. This applicator
+    # is intended to handle details like assocation types, where needed.
+    #
+    # @example
+    #   MyValkyrieResource.schema.each do |schema_key|
+    #     PropertyApplicator.new(schema_key).apply(MyActiveFedoraClass)
+    #   end
+    class PropertyApplicator
+      ##
+      # @param [Dry::Types::Schema::Key] key
+      def initialize(key)
+        @key = key
+      end
+
+      ##
+      # @note this method is a silent no-op if the property is already defined
+      #   or is a protected property on the target class
+      #
+      # @return [void] apply the property
+      def apply(klass)
+        return if klass.properties.keys.include?(name) ||
+                  klass.protected_property_name?(name)
+        klass.send(definition_method, name, options)
+      end
+
+      ##
+      # @return [Symbol] the method name for property/association definition
+      def definition_method
+        return :ordered_aggregation if @key.name == :member_ids
+        return :indirectly_contains if @key.name == :member_of_collection_ids
+        :property
+      end
+
+      ##
+      # @return [Symbol]
+      def name
+        return :members if @key.name == :member_ids
+        return :member_of_collections if @key.name == :member_of_collection_ids
+        @key.name
+      end
+
+      ##
+      # @return [Hash<Symbol, Object>]
+      def options
+        return { has_member_relation: predicate, class_name: 'ActiveFedora::Base', through: :list_source } if
+          @key.name == :member_ids
+
+        if @key.name == :member_of_collection_ids
+          return { has_member_relation: predicate, class_name: 'ActiveFedora::Base',
+                   inserted_content_relation: RDF::Vocab::ORE.proxyFor, through: 'ActiveFedora::Aggregation::Proxy',
+                   foreign_key: :target }
+        end
+
+        { predicate: predicate }
+      end
+
+      ##
+      # @return [RDF::URI]
+      def predicate
+        return Hydra::PCDM::Vocab::PCDMTerms.hasMember if @key.name == :member_ids
+        return Hydra::PCDM::Vocab::PCDMTerms.memberOf if @key.name == :member_of_collection_ids
+
+        RDF::URI.intern("http://hyrax.samvera.org/ns/wings##{name}")
+      end
+    end
+
+    ##
+    # default work class builder
+    def self.DefaultWork(resource_class) # rubocop:disable Naming/MethodName
+      class_cache[resource_class] ||= Class.new(DefaultWork) do
+        self.valkyrie_class = resource_class
+
+        # skip reserved attributes, we assume we don't need to translate valkyrie internals
+        schema = resource_class.schema.reject do |key|
+          resource_class.reserved_attributes.include?(key.name)
+        end
+
+        Wings::ActiveFedoraConverter.apply_properties(self, schema)
+
+        # nested attributes in AF don't inherit! this needs to be here until we can drop it completely.y
+        accepts_nested_attributes_for :nested_resource
+      end
+    end
+
+    ##
+    # A base model class for valkyrie resources that don't have corresponding
+    # ActiveFedora::Base models.
+    class DefaultWork < ActiveFedora::Base
+      include Hyrax::Noid
+      include Hyrax::Permissions
+      include Hydra::AccessControls::Embargoable
+      property :nested_resource, predicate: ::RDF::URI("http://example.com/nested_resource"), class_name: "Wings::ActiveFedoraConverter::NestedResource"
+
+      class_attribute :valkyrie_class
+      self.valkyrie_class = Hyrax::Resource
+
+      class << self
+        delegate :human_readable_type, to: :valkyrie_class
+
+        def model_name(*)
+          Hyrax::Name.new(valkyrie_class)
+        end
+
+        def to_rdf_representation
+          "Wings(#{valkyrie_class})"
+        end
+        alias inspect to_rdf_representation
+        alias to_s inspect
+      end
+
+      def indexing_service
+        Hyrax::ValkyrieIndexer.for(resource: valkyrie_resource)
+      end
+
+      def to_global_id
+        GlobalID.create(valkyrie_class.new(id: id))
+      end
+    end
+  end
+end

data/lib/wings/active_fedora_converter/nested_resource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Wings
+  class ActiveFedoraConverter
+    class NestedResource < ActiveTriples::Resource
+      property :title, predicate: ::RDF::Vocab::DC.title
+      property :author, predicate: ::RDF::URI('http://example.com/ns/author')
+      property :depositor, predicate: ::RDF::URI('http://example.com/ns/depositor')
+      property :nested_resource, predicate: ::RDF::URI("http://example.com/nested_resource"), class_name: NestedResource
+      property :ordered_authors, predicate: ::RDF::Vocab::DC.creator
+      property :ordered_nested, predicate: ::RDF::URI("http://example.com/ordered_nested")
+
+      def initialize(uri = RDF::Node.new, _parent = ActiveTriples::Resource.new)
+        uri = if uri.try(:node?)
+                RDF::URI("#nested_resource_#{uri.to_s.gsub('_:', '')}")
+              elsif uri.to_s.include?('#')
+                RDF::URI(uri)
+              end
+        super
+      end
+
+      include ::Hyrax::BasicMetadata
+    end
+  end
+end

data/lib/wings/attribute_transformer.rb

@@ -5,8 +5,16 @@ require 'wings/transformer_value_mapper'
 module Wings
   ##
   # Transform AF attributes to Valkyrie::Resource attributes representation.
-  #
   class AttributeTransformer
+    def self.for(obj)
+      case obj
+      when Hydra::PCDM::File
+        FileAttributeTransformer.new
+      else
+        self
+      end
+    end
+
     def self.run(obj, keys)
       # TODO: There is an open question about whether we want to treat all these relationships the same.  See Issue #3904.
       attrs = keys.select { |k| k.to_s.end_with? '_ids' }.each_with_object({}) do |attr_name, mem|
@@ -27,4 +35,23 @@ module Wings
       Array(attribute_value).map(&:id)
     end
   end
+
+  class FileAttributeTransformer
+    KEYMAP = {}.freeze
+
+    def run(obj, keys)
+      attributes = keys.each_with_object({}) do |attr_name, mem|
+        next unless obj.respond_to?(attr_name) && !mem.key?(attr_name.to_sym)
+        valkyrie_attribute = KEYMAP.fetch(attr_name.to_sym) { attr_name.to_sym }
+
+        mem[valkyrie_attribute] = TransformerValueMapper.for(obj.public_send(attr_name)).result
+      end
+
+      attributes[:original_filename] = obj.original_name
+      attributes[:file_identifier] = obj.id if obj.id.present?
+      attributes[:type] = obj.metadata_node.type.to_a
+      attributes[:size] = obj.size
+      attributes
+    end
+  end
 end

data/lib/wings/converter_value_mapper.rb

@@ -25,6 +25,32 @@ module Wings
     end
   end
 
+  class FedoraProtectedAttributes < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    ATTRIBUTES = [:create_date, :modified_date, :head, :tail, :has_model].freeze
+
+    def self.handles?(value)
+      ATTRIBUTES.include?(value.first)
+    end
+
+    def result
+      nil
+    end
+  end
+
+  class NilAttributeValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.last.nil?
+    end
+
+    def result
+      value
+    end
+  end
+
   class ReflectionIdValue < ::Valkyrie::ValueMapper
     ConverterValueMapper.register(self)
 
@@ -39,6 +65,45 @@ module Wings
     end
   end
 
+  class MemberOfCollectionIds < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first == :member_of_collection_ids
+    end
+
+    def result
+      collections = value.last.map { |id| ActiveFedora::Base.find(id.id) }
+      [:member_of_collections, collections]
+    end
+  end
+
+  class MemberIds < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first == :member_ids
+    end
+
+    def result
+      members = value.last.map { |id| ActiveFedora::Base.find(id.id) }
+      [:members, members]
+    end
+  end
+
+  class FileIds < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first == :file_ids
+    end
+
+    def result
+      files = value.last.map { |id| Hydra::PCDM::File.new(id.id) }
+      [:files, files]
+    end
+  end
+
   ##
   # @todo ensure reflections round trip correctly, even though we avoid handling ids
   class ReflectionIdsValue < ::Valkyrie::ValueMapper
@@ -165,13 +230,15 @@ module Wings
 
   class NestedResourceValue < ::Valkyrie::ValueMapper
     ConverterValueMapper.register(self)
+
     def self.handles?(value)
       value.last.is_a?(Dry::Struct)
     end
 
     def result
-      attrs = ActiveFedoraAttributes.new(value.last.attributes).result
-      [value.first, attrs]
+      attrs = ActiveFedoraConverter.new(resource: value.last).attributes
+
+      [value.first, ActiveFedoraAttributes.new(attrs).result]
     end
   end
 
@@ -179,7 +246,7 @@ module Wings
     attr_reader :attributes
 
     def initialize(attributes)
-      @attributes = attributes.compact
+      @attributes = attributes
     end
 
     def self.mapped_attributes(attributes:)

data/lib/wings/model_registry.rb

@@ -37,18 +37,19 @@ module Wings
     end
 
     def register(valkyrie, active_fedora)
-      @map[valkyrie] = active_fedora
+      @map[valkyrie.name] = active_fedora.name
     end
 
     def lookup(valkyrie)
       valkyrie = valkyrie._canonical_valkyrie_model if
         valkyrie.respond_to?(:_canonical_valkyrie_model)
 
-      @map.fetch(valkyrie) { ActiveFedoraConverter::DefaultWork(valkyrie) }
+      @map[valkyrie.name]&.safe_constantize ||
+        ActiveFedoraConverter::DefaultWork(valkyrie)
     end
 
     def reverse_lookup(active_fedora)
-      @map.rassoc(active_fedora)&.first
+      @map.rassoc(active_fedora.name)&.first&.safe_constantize
     end
   end
 end

data/lib/wings/model_transformer.rb

@@ -42,9 +42,9 @@ module Wings
     ##
     # Builds a `Valkyrie::Resource` equivalent to the `pcdm_object`
     #
-    # @return [::Valkyrie::Resource] a resource mirroiring `pcdm_object`
+    # @return [::Valkyrie::Resource] a resource mirroring `pcdm_object`
     def build
-      klass = ResourceClassCache.instance.fetch(pcdm_object) do
+      klass = cache.fetch(pcdm_object.class) do
         OrmConverter.to_valkyrie_resource_class(klass: pcdm_object.class)
       end
 
@@ -59,10 +59,20 @@ module Wings
     def ensure_current_permissions(resource)
       return if pcdm_object.try(:access_control).blank?
 
+      # set permissions on the locally cached permission manager if one is present,
+      # otherwise, we can just rely on the `access_control_ids`.
+      return unless resource.respond_to?(:permission_manager)
+
       resource.permission_manager.acl.permissions =
         pcdm_object.access_control.valkyrie_resource.permissions
     end
 
+    ##
+    # @return [ResourceClassCache]
+    def cache
+      ResourceClassCache.instance
+    end
+
     ##
     # Caches dynamically generated `Valkyrie::Resource` subclasses mapped from
     # legacy `ActiveFedora` model classes.
@@ -106,11 +116,16 @@ module Wings
     end
 
     def attributes
+      attribute_source = pcdm_object.try(:metadata_node) || pcdm_object
+
       all_keys =
-        pcdm_object.attributes.keys +
-        OrmConverter.relationship_keys_for(reflections: pcdm_object.reflections)
+        attribute_source.attributes.keys +
+        OrmConverter.relationship_keys_for(reflections: pcdm_object.try(:reflections))
 
-      result = AttributeTransformer.run(pcdm_object, all_keys).merge(reflection_ids).merge(additional_attributes)
+      result = AttributeTransformer.for(pcdm_object)
+                                   .run(pcdm_object, all_keys)
+                                   .merge(reflection_ids)
+                                   .merge(additional_attributes)
 
       append_embargo(result)
       append_lease(result)
@@ -119,7 +134,9 @@ module Wings
     end
 
     def reflection_ids
-      pcdm_object.reflections.keys.select { |k| k.to_s.end_with? '_id' }.each_with_object({}) do |k, mem|
+      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
@@ -142,7 +159,8 @@ module Wings
       result = []
       result << ::Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: 'wings-fedora-etag', token: pcdm_object.etag) unless pcdm_object.new_record?
 
-      last_modified_literal = pcdm_object.resource.first_object([nil, RDF::URI("http://fedora.info/definitions/v4/repository#lastModified"), nil])
+      graph_node = pcdm_object.try(:resource) || pcdm_object.metadata_node
+      last_modified_literal = graph_node.first_object([nil, RDF::URI("http://fedora.info/definitions/v4/repository#lastModified"), nil])
       token = last_modified_literal&.object&.to_s
       result << ::Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: 'wings-fedora-last-modified', token: token) if token
       result

data/lib/wings/orm_converter.rb

@@ -1,27 +1,19 @@
 # frozen_string_literal: true
 
-require 'wings/transformer_value_mapper'
-require 'wings/models/concerns/collection_behavior'
-require 'wings/hydra/works/models/concerns/work_valkyrie_behavior'
-require 'wings/hydra/works/models/concerns/file_set_valkyrie_behavior'
-
 module Wings
   ##
   # 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:)
-      relationships = reflections
-                      .keys
-                      .reject { |k| k.to_s.include?('id') }
-                      .map { |k| k.to_s.singularize + '_ids' }
-      relationships.delete('member_ids') # Remove here.  Members will be extracted as ordered_members in attributes method.
-      relationships.delete('ordered_member_proxy_ids') # This does not have a Valkyrie equivalent.
-      relationships
+      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
 
     ##
@@ -29,9 +21,9 @@ module Wings
     #
     # @return [Class]
     def self.base_for(klass:)
-      klass.try(:valkyrie_class) ||
-        ModelRegistry.reverse_lookup(klass) ||
-        Hyrax::Resource
+      mapped_class = klass.try(:valkyrie_class) || ModelRegistry.reverse_lookup(klass)
+      return mapped_class if mapped_class
+      klass < Hydra::Works::WorkBehavior ? Hyrax::Work : Hyrax::Resource
     end
 
     ##
@@ -43,19 +35,14 @@ module Wings
     # rubocop:disable Metrics/AbcSize
     # rubocop:disable Metrics/BlockLength
     # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     # 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) : []
-      relationship_keys.delete('member_ids')
-      relationship_keys.delete('member_of_collection_ids')
       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
-        include Wings::CollectionBehavior if klass.included_modules.include?(Hyrax::CollectionBehavior)
-        include Wings::Works::WorkValkyrieBehavior if klass.included_modules.include?(Hyrax::WorkBehavior)
-        include Wings::Works::FileSetValkyrieBehavior if klass.included_modules.include?(Hyrax::FileSetBehavior)
-
         # store a string we can resolve to the internal resource
         @internal_resource = klass.try(:to_rdf_representation) || klass.name
 
@@ -78,14 +65,22 @@ module Wings
         end
 
         klass.properties.each_key do |property_name|
-          attribute property_name.to_sym, ::Valkyrie::Types::String
+          next if fields.include?(property_name.to_sym)
+
+          if klass.properties[property_name].multiple?
+            attribute property_name.to_sym, ::Valkyrie::Types::Set.of(::Valkyrie::Types::Anything).optional
+          else
+            attribute property_name.to_sym, ::Valkyrie::Types::Anything.optional
+          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)
         end
 
         reflection_id_keys.each do |property_name|
+          next if fields.include?(property_name.to_sym)
           attribute property_name, ::Valkyrie::Types::ID
         end
 
@@ -100,3 +95,4 @@ end
 # rubocop:enable Metrics/BlockLength
 # rubocop:enable Metrics/MethodLength
 # rubocop:enable Metrics/CyclomaticComplexity
+# rubocop:enable Metrics/PerceivedComplexity