hyrax 2.8.0 → 3.0.0.pre.rc2

data/lib/valkyrie/indexing_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Valkyrie
+  # IndexingAdapter is the primary DataMapper object for indexing.
+  #  Used to register and locate adapters, for individual
+  #  indexing backends (such as solr, elasticsearch, etc)
+  class IndexingAdapter
+    class_attribute :adapters
+    self.adapters = {}
+    class << self
+      # Register an adapter by a short name.
+      # Registering an adapter by a short name makes the adapter easier to find and reference.
+      # @param adapter Adapter to register.
+      # @param short_name [Symbol] Name to register it under.
+      def register(adapter, short_name)
+        adapters[short_name.to_sym] = adapter
+      end
+
+      # Find an adapter by its short name.
+      # @param short_name [Symbol]
+      # @return adapter
+      # @raise RuntimeError when the given short_name is not found amongst the registered adapters
+      def find(short_name)
+        symbolized_key = short_name.to_sym
+        return adapters[symbolized_key] if adapters.key?(symbolized_key)
+        raise KeyError, "Unable to find unregistered adapter `#{short_name}'"
+      end
+    end
+  end
+end

data/lib/wings.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+##
+# Wings is a toolkit integrating Valkyrie into Hyrax as a bridge away from the
+# hard dependency on ActiveFedora.
+#
+# Requiring this module with `require 'wings'` injects a variety of behavior
+# supporting a gradual transition from existing `ActiveFedora` models and
+# persistence middleware to Valkyrie.
+#
+# `Wings` is primarily an isolating namespace for code intended to be removed
+# after a full transition to `Valkyrie` as the persistence middleware for Hyrax.
+# Applications may find it useful to depend directly on this code to facilitate
+# a smooth code migration, much in the way it is being used in this engine.
+# However, these dependencies should be considered temprorary: this code will
+# be deprecated for removal in a future release.
+#
+# @example casting an ActiveFedora model to Valkyrie
+#   work     = GenericWork.create(title: ['Comet in Moominland'])
+#   resource = work.valkyrie_resource
+#
+#   resource.title # => ["Comet in Moominland"]
+#   resource.title = ["Mumintrollet på kometjakt"]
+#
+#   Hyrax.persister.save(resource: resource)
+#
+#   work.reload
+#   work.title # => ["Mumintrollet på kometjakt"]
+#
+# @example defining a native Valkyrie model for use with Wings
+#   # given an `ActiveFodora` model like
+#   class Book < ActiveFedora::Base
+#     property :author, predicate: ::RDF::URI('http://example.com/ns/author')
+#     property :title,  predicate: ::RDF::URI('http://example.com/ns/title')
+#   end
+#
+#   # define a `Valkyrie` model with matching attributes,
+#   class BookResource < Hyrax::Resource
+#     attribute :author, Valkyrie::Types::String
+#     attribute :title,  Valkyrie::Types::String
+#   end
+#
+#   # and register the relationship with `Wings`
+#   Wings::ModelRegistry.register(BookResource, Book)
+#
+#   # `Wings` will cast the `BookResource` to a `Book` to persist via `ActiveFedora`
+#   resource = BookResource.new(author: 'Tove Jansson', title: 'Comet in Moominland')
+#   adapter  = Wings::Valkyrie::MetadataAdapter.new
+#   resource = adapter.persister.save(resource: resource)
+#
+#   resource.title  # => ["Comet in Moominland"]
+#   resource.author # => ["Tove Jansson"]
+#
+#   resource.is_a?(BookResource) # => true
+#
+# @see https://wiki.duraspace.org/display/samvera/Hyrax-Valkyrie+Development+Working+Group
+#      for further context regarding the approach
+module Wings
+  ##
+  # @api public
+  #
+  # Provides a search builder for new valkyrie types that are indexed as their
+  # corresponding legacy ActiveFedora classes.
+  #
+  # @example
+  #   builder = Wings::WorkSearchBuilder(Monograph)
+  def self.WorkSearchBuilder(work_type) # rubocop:disable Naming/MethodName
+    Class.new(Hyrax::WorkSearchBuilder) do
+      class_attribute :legacy_work_type, instance_writer: false
+      self.legacy_work_type = Wings::ModelRegistry.lookup(work_type)
+
+      def work_types
+        [legacy_work_type]
+      end
+
+      def self.inspect
+        "Wings::WorkSearchBuilder(#{legacy_work_type})"
+      end
+    end
+  end
+end
+
+require 'valkyrie'
+require 'wings/active_fedora_classifier'
+require 'wings/model_registry'
+require 'wings/model_transformer'
+require 'wings/orm_converter'
+require 'wings/attribute_transformer'
+require 'wings/services/custom_queries/find_access_control'
+require 'wings/services/custom_queries/find_collections_by_type'
+require 'wings/services/custom_queries/find_file_metadata'
+require 'wings/services/custom_queries/find_many_by_alternate_ids'
+require 'wings/valkyrizable'
+require 'wings/valkyrie/metadata_adapter'
+require 'wings/valkyrie/resource_factory'
+require 'wings/valkyrie/persister'
+require 'wings/valkyrie/query_service'
+require 'wings/valkyrie/storage/active_fedora'
+
+Hydra::AccessControl.send(:define_method, :valkyrie_resource) do
+  attrs = attributes.symbolize_keys
+  attrs[:new_record]  = new_record?
+  attrs[:created_at]  = create_date
+  attrs[:updated_at]  = modified_date
+
+  attrs[:permissions] = 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
+
+  Hyrax::AccessControl.new(**attrs)
+end
+
+begin
+  require 'wings/setup'
+rescue NameError, Hyrax::SimpleSchemaLoader::UndefinedSchemaError => err
+  raise(err) if ENV['RAILS_ENV'] == 'production'
+  :noop
+end
+
+# some aliases for use by diners of varying sophistication
+BuffaloWings = Wings
+MightyWings = Wings
+HotWings = Wings
+SpicyWings = Wings
+SwissWings = Wings
+BuffaloCauliflowerWings = Wings

data/lib/wings/active_fedora_classifier.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Wings
+  class ActiveFedoraClassifier < ActiveFedora::ModelClassifier
+    private
+
+    def classify(model_value)
+      if (match = model_value.match(/Wings\((.*)\)/))
+        valkyrie_class = match[1].constantize
+        Wings::ActiveFedoraConverter::DefaultWork(valkyrie_class)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/wings/active_fedora_converter.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'wings/converter_value_mapper'
+
+module Wings
+  ##
+  # Converts `Valkyrie::Resource` objects to legacy `ActiveFedora::Base` objects.
+  #
+  # @example
+  #   work     = GenericWork.new(title: ['Comet in Moominland'])
+  #   resource = GenericWork.valkyrie_resource
+  #
+  #   ActiveFedoraConverter.new(resource: resource).convert == work # => true
+  #
+  # @note the `Valkyrie::Resource` object passed to this class **must** have an
+  #   `#internal_resource` mapping it to an `ActiveFedora::Base` class.
+  class ActiveFedoraConverter
+    ##
+    # Accesses the Class implemented for handling resource attributes
+    # @return [Class]
+    def self.attributes_class
+      ActiveFedoraAttributes
+    end
+
+    ##
+    # @params [Valkyrie::Resource] resource
+    #
+    # @return [ActiveFedora::Base]
+    def self.convert(resource:)
+      new(resource: resource).convert
+    end
+
+    ##
+    # @!attribute [rw] resource
+    #   @return [Valkyrie::Resource]
+    attr_accessor :resource
+
+    ##
+    # @param [Valkyrie::Resource]
+    def initialize(resource:)
+      @resource = resource
+    end
+
+    ##
+    # Accesses and parses the attributes from the resource through ConverterValueMapper
+    #
+    # @return [Hash] attributes with values mapped for building an ActiveFedora model
+    def attributes
+      @attributes ||= self.class.attributes_class.mapped_attributes(attributes: resource.attributes)
+    end
+
+    ##
+    # @return [ActiveFedora::Base]
+    def convert
+      active_fedora_class.new(normal_attributes).tap do |af_object|
+        af_object.id = id unless id.empty?
+        add_access_control_attributes(af_object)
+        convert_members(af_object)
+        convert_member_of_collections(af_object)
+        convert_files(af_object)
+      end
+    end
+
+    def active_fedora_class
+      klass = begin
+                resource.internal_resource.constantize
+              rescue NameError
+                Wings::ActiveFedoraClassifier.new(resource.internal_resource).best_model
+              end
+
+      return klass if klass <= ActiveFedora::Base
+
+      ModelRegistry.lookup(klass)
+    end
+
+    ##
+    # In the context of a Valkyrie resource, prefer to use the id if it
+    # is provided and fallback to the first of the alternate_ids. If all else fails
+    # then the id hasn't been minted and shouldn't yet be set.
+    # @return [String]
+    def id
+      return resource[:id].to_s if resource[:id]&.is_a?(::Valkyrie::ID) && resource[:id].present?
+      return "" unless resource.respond_to?(:alternate_ids)
+
+      resource.alternate_ids.first.to_s
+    end
+
+    def self.DefaultWork(resource_class)
+      Class.new(DefaultWork) do
+        self.valkyrie_class = resource_class
+
+        # extract AF properties from the Valkyrie schema;
+        # skip reserved attributes, proctected properties, and those already defined
+        resource_class.schema.each do |schema_key|
+          next if resource_class.reserved_attributes.include?(schema_key.name)
+          next if protected_property_name?(schema_key.name)
+          next if properties.keys.include?(schema_key.name.to_s)
+
+          property schema_key.name, predicate: RDF::URI("http://hyrax.samvera.org/ns/wings##{schema_key.name}")
+        end
+
+        # nested attributes in AF don't inherit! this needs to be here until we can drop it completely.
+        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::WorkBehavior
+      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_default_name_class.new(valkyrie_class)
+        end
+
+        def to_rdf_representation
+          "Wings(#{valkyrie_class})"
+        end
+        alias inspect to_rdf_representation
+        alias to_s inspect
+      end
+
+      def to_global_id
+        GlobalID.create(valkyrie_class.new(id: id))
+      end
+    end
+
+    class NestedResource < ActiveTriples::Resource
+      property :title, predicate: ::RDF::Vocab::DC.title
+      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
+
+    private
+
+    def convert_members(af_object)
+      return unless resource.respond_to?(:member_ids) && resource.member_ids
+      # TODO: It would be better to find a way to add the members without resuming all the member AF objects
+      af_object.ordered_members = resource.member_ids.map { |valkyrie_id| ActiveFedora::Base.find(valkyrie_id.to_s) }
+    end
+
+    def convert_member_of_collections(af_object)
+      return unless resource.respond_to?(:member_of_collection_ids) && resource.member_of_collection_ids
+      # TODO: It would be better to find a way to set the parent collections without resuming all the collection AF objects
+      af_object.member_of_collections = resource.member_of_collection_ids.map { |valkyrie_id| ActiveFedora::Base.find(valkyrie_id.to_s) }
+    end
+
+    def convert_files(af_object)
+      return unless resource.respond_to? :file_ids
+
+      af_object.files = resource.file_ids.map do |fid|
+        pcdm_file = Hydra::PCDM::File.new(fid.id)
+        assign_association_target(af_object, pcdm_file)
+      end
+    end
+
+    def assign_association_target(af_object, pcdm_file)
+      case pcdm_file.metadata_node.type
+      when ->(types) { types.include?(RDF::URI.new('http://pcdm.org/use#OriginalFile')) }
+        af_object.association(:original_file).target = pcdm_file
+      when ->(types) { types.include?(RDF::URI.new('http://pcdm.org/use#ExtractedText')) }
+        af_object.association(:extracted_text).target = pcdm_file
+      when ->(types) { types.include?(RDF::URI.new('http://pcdm.org/use#Thumbnail')) }
+        af_object.association(:thumbnail).target = pcdm_file
+      else
+        pcdm_file
+      end
+    end
+
+    # Normalizes the attributes parsed from the resource
+    #   (This ensures that scalar values are passed to the constructor for the
+    #   ActiveFedora::Base Class)
+    # @return [Hash]
+    def normal_attributes
+      attributes.each_with_object({}) do |(attr, value), hash|
+        property = active_fedora_class.properties[attr.to_s]
+        hash[attr] = property&.multiple? ? Array.wrap(value) : value
+      end
+    end
+
+    # Add attributes from resource which aren't AF properties into af_object
+    def add_access_control_attributes(af_object)
+      return unless af_object.is_a? Hydra::AccessControl
+      cache = af_object.permissions.to_a
+
+      # if we've saved this before, it has a cache that won't clear
+      # when setting permissions! we need to reset it manually and
+      # rewrite with the values already in there, or saving will fail
+      # to delete cached items
+      af_object.permissions.reset if af_object.persisted?
+
+      af_object.permissions = cache.map do |permission|
+        permission.access_to_id = resource.try(:access_to)&.id
+        permission
+      end
+    end
+  end
+end

data/lib/wings/attribute_transformer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'wings/transformer_value_mapper'
+
+module Wings
+  ##
+  # Transform AF attributes to Valkyrie::Resource attributes representation.
+  #
+  class AttributeTransformer
+    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|
+        mem[attr_name.to_sym] =
+          TransformerValueMapper.for(obj.try(attr_name)).result ||
+          TransformerValueMapper.for(attribute_ids_for(name: attr_name.chomp('_ids'), obj: obj)).result ||
+          TransformerValueMapper.for(attribute_ids_for(name: attr_name.chomp('_ids').pluralize, obj: obj)).result || []
+      end
+      keys.each_with_object(attrs) do |attr_name, mem|
+        next unless obj.respond_to?(attr_name) && !mem.key?(attr_name.to_sym)
+        mem[attr_name.to_sym] = TransformerValueMapper.for(obj.public_send(attr_name)).result
+      end
+    end
+
+    def self.attribute_ids_for(name:, obj:)
+      attribute_value = obj.try(name)
+      return if attribute_value.nil?
+      Array(attribute_value).map(&:id)
+    end
+  end
+end

data/lib/wings/converter_value_mapper.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Wings
+  ##
+  # A base value mapper for converting property values in the
+  # `Valkyrie` type system to `ActiveFedora`/`ActiveTriples` type
+  #
+  # This top level matcher has registered several internal mappers which handle
+  # indivdual value types from the source data.
+  class ConverterValueMapper < ::Valkyrie::ValueMapper; end
+
+  class ReservedAttributeValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    ATTRIBUTES = [:internal_resource, :access_to, :new_record, :id,
+                  :alternate_ids, :created_at, :updated_at,
+                  :optimistic_lock_token].freeze
+
+    def self.handles?(value)
+      ATTRIBUTES.include?(value.first)
+    end
+
+    def result
+      nil
+    end
+  end
+
+  class ReflectionIdValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first.to_s.end_with?('_id')
+    end
+
+    def result
+      return nil if value.last.blank?
+
+      [value.first, value.last.to_s]
+    end
+  end
+
+  ##
+  # @todo ensure reflections round trip correctly, even though we avoid handling ids
+  class ReflectionIdsValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first.to_s.end_with?('_ids')
+    end
+
+    def result
+      nil
+    end
+  end
+
+  class PermissionValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first == :permissions
+    end
+
+    def result
+      [value.first, permissions]
+    end
+
+    private
+
+    def permissions
+      value.last.map do |permission_attrs|
+        if permission_attrs[:agent].starts_with? Hyrax::Group.name_prefix
+          type = 'group'
+          name = permission_attrs[:agent].dup
+          name.slice!(Hyrax::Group.name_prefix)
+        else
+          type = 'person'
+          name = permission_attrs[:agent].dup
+        end
+
+        hsh = { type: type, access: permission_attrs[:mode].to_s, name: name }
+        hsh[:id] = permission_attrs[:id] if permission_attrs[:id]
+        Hydra::AccessControls::Permission.new(hsh)
+      end
+    end
+  end
+
+  class NestedEmbargoValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first == :embargo
+    end
+
+    def result
+      embargo = ActiveFedoraConverter.new(resource: Hyrax::Embargo.new(**value.last)).convert
+
+      [:embargo, embargo]
+    end
+  end
+
+  class IdValueMapper < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.last.is_a? ::Valkyrie::ID
+    end
+
+    def result
+      [value.first, values]
+    end
+
+    def values
+      value.last.id
+    end
+  end
+
+  class NestedLeaseValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.first == :lease
+    end
+
+    def result
+      lease = ActiveFedoraConverter.new(resource: Hyrax::Lease.new(**value.last)).convert
+
+      [:lease, lease]
+    end
+  end
+
+  class NestedResourceArrayValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+    def self.handles?(value)
+      value.last.is_a?(Array) && value.last.any? { |x| x.is_a? Dry::Struct }
+    end
+
+    def result
+      ["#{value.first}_attributes".to_sym, values]
+    end
+
+    def values
+      value.last.map do |val|
+        calling_mapper.for([value.first, val]).result
+      end.flat_map(&:last)
+    end
+  end
+
+  class ArrayValue < ::Valkyrie::ValueMapper
+    ConverterValueMapper.register(self)
+
+    def self.handles?(value)
+      value.last.is_a?(Array)
+    end
+
+    def result
+      [value.first, values]
+    end
+
+    def values
+      value.last.map do |val|
+        calling_mapper.for([value.first, val]).result
+      end.flat_map(&:last)
+    end
+  end
+
+  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]
+    end
+  end
+
+  class ActiveFedoraAttributes
+    attr_reader :attributes
+
+    def initialize(attributes)
+      @attributes = attributes.compact
+    end
+
+    def self.mapped_attributes(attributes:)
+      new(attributes).result
+    end
+
+    def result
+      Hash[
+        attributes.map do |value|
+          ConverterValueMapper.for(value).result
+        end.select(&:present?)
+      ]
+    end
+  end
+end