hyrax 5.1.0 → 5.3.0

data/app/services/hyrax/m3_schema_loader.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # @api private
+  #
+  # Read m3 profiles from the database
+  #
+  # @see config/metadata_profiles/m3_profile.yaml for an example configuration
+  class M3SchemaLoader < Hyrax::SchemaLoader
+    def view_definitions_for(schema:, version: 1, contexts: nil)
+      definitions(schema, version, contexts).each_with_object({}) do |definition, hash|
+        view_options = definition.view_options
+        # display_label, admin_only, and editor_only keys are always added to
+        # the view_options hash. If there are no other view options, skip this
+        # field.
+        next if view_options.without(:display_label, :admin_only, :editor_only).empty?
+
+        hash[definition.name] = definition.view_options
+      end
+    end
+
+    def config_paths(schema_name = 'm3_profile')
+      config_search_paths.collect do |root_path|
+        path = root_path.to_s + "/config/metadata_profiles/#{schema_name}.yaml"
+        path if File.exist?(path)
+      end.compact
+    end
+
+    def current_version
+      Hyrax::FlexibleSchema.current_schema_id
+    rescue ActiveRecord::StatementInvalid # allow for moments when the database is not yet initialized
+      0
+    end
+
+    private
+
+    ##
+    # @param [#to_s] schema_name
+    # @return [Enumerable<AttributeDefinition]
+    def definitions(schema_name, version, contexts = nil)
+      schema = Hyrax::FlexibleSchema.find_by(id: version) || Hyrax::FlexibleSchema.create_default_schema
+      attributes = schema.attributes_for(schema_name)
+      attributes ||= fallback_schema_for(schema_name)
+      attributes.map do |name, config|
+        # We might be able to consolidate these conditions, but they have been kept separate to make it easier to reason about
+        # If there is a context filter on the metadata field and no context is set, skip it
+        next if contexts.blank? && config['context'].present?
+
+        # If there is a context filter on the metadata field and we have set a context, but the context does not match, skip it
+        next if contexts.present? && config['context'].present? && !(Array(contexts) & Array(config['context'])).any?
+
+        # Wew, we are in the clear to use this field
+        M3AttributeDefinition.new(name, config)
+      end.compact
+    rescue ActiveRecord::StatementInvalid
+      Rails.logger.error "Skipping definition load for migrations to run"
+      []
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def fallback_schema_for(_schema_name)
+      { "title" =>
+        { "cardinality" => { "minimum" => 1 },
+          "data_type" => "array",
+          "controlled_values" => { "format" => "http://www.w3.org/2001/XMLSchema#string", "sources" => ["null"] },
+          "definition" =>
+          { "default" =>
+            "Enter a standardized title for display. If only one title is needed, transcribe the title from the source itself." },
+          "display_label" => { "default" => "Title" },
+          "index_documentation" => "displayable, searchable",
+          "indexing" => ["title_sim", "title_tesim"],
+          "form" => { "primary" => true, "multiple" => true },
+          "mappings" =>
+          { "metatags" => "twitter:title, og:title",
+            "mods_oai_pmh" => "mods:titleInfo/mods:title",
+            "qualified_dc_pmh" => "dcterms:title",
+            "simple_dc_pmh" => "dc:title" },
+          "property_uri" => "http://purl.org/dc/terms/title",
+          "range" => "http://www.w3.org/2001/XMLSchema#string",
+          "requirement" => "required",
+          "sample_values" => ["Pencil drawn portrait study of woman"],
+          "view" => { "label" => { "en" => "Title", "es" => "Título" }, "html_dl" => true },
+          "type" => "string",
+          "predicate" => "http://purl.org/dc/terms/title",
+          "index_keys" => ["title_sim", "title_tesim"],
+          "multiple" => true,
+          "context" => nil } }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    ##
+    # @api private
+    #
+    # M3-specific AttributeDefinition that properly handles cardinality-based requirements
+    class M3AttributeDefinition < Hyrax::SchemaLoader::AttributeDefinition
+      ##
+      # @return [Hash{Symbol => Object}]
+      def form_options
+        options = super
+
+        # Check if minimum cardinality makes this field required
+        options = options.merge(required: true) if cardinality_required?
+
+        options
+      end
+
+      private
+
+      def cardinality_required?
+        cardinality = config['cardinality']
+        return false unless cardinality.is_a?(Hash)
+
+        minimum = cardinality['minimum']
+        minimum.present? && minimum.to_i >= 1
+      end
+    end
+  end
+end

data/app/services/hyrax/manifest_builder_service.rb

@@ -21,7 +21,7 @@ module Hyrax
     # @return [Hash] a Ruby hash representation of a IIIF manifest document
     #
     # @see Hyrax::WorksControllerBehavior
-    def self.manifest_for(presenter:, iiif_manifest_factory: ::IIIFManifest::ManifestFactory)
+    def self.manifest_for(presenter:, iiif_manifest_factory: Hyrax.config.iiif_manifest_factory)
       new(iiif_manifest_factory: iiif_manifest_factory)
         .manifest_for(presenter: presenter)
     end
@@ -36,7 +36,7 @@ module Hyrax
     #
     # @param iiif_manifest_factory [Class] a class that initializes with presenter
     #        object and returns an object that responds to `#to_h`
-    def initialize(iiif_manifest_factory: ::IIIFManifest::ManifestFactory)
+    def initialize(iiif_manifest_factory: Hyrax.config.iiif_manifest_factory)
       @manifest_factory = iiif_manifest_factory
     end
 
@@ -56,33 +56,27 @@ module Hyrax
     # @api private
     # @param presenter [Hyrax::WorkShowPresenter]
     def sanitized_manifest(presenter:)
-      # ::IIIFManifest::ManifestBuilder#to_h returns a
-      # IIIFManifest::ManifestBuilder::IIIFManifest, not a Hash.
-      # to get a Hash, we have to call its #to_json, then parse.
-      #
-      # wild times. maybe there's a better way to do this with the
-      # ManifestFactory interface?
       manifest = manifest_factory.new(presenter).to_h
-      hash = JSON.parse(manifest.to_json)
-
-      hash['label'] = sanitize_value(hash['label']) if hash.key?('label')
-      hash['description'] = Array(hash['description'])&.collect { |elem| sanitize_value(elem) } if hash.key?('description')
-
-      hash['sequences']&.each do |sequence|
-        sequence['canvases']&.each do |canvas|
-          canvas['label'] = sanitize_value(canvas['label'])
-        end
-      end
-
-      hash
+      hash = manifest.respond_to?(:inner_hash) ? manifest.inner_hash : JSON.parse(manifest.to_json)
+      deep_sanitize(hash)
     end
 
     ##
     # @api private
-    # @param [#to_s] text
-    # @return [String] a sanitized verison of `text`
-    def sanitize_value(text)
-      Loofah.fragment(text.to_s).scrub!(:prune).to_s
+    # Recursively sanitizes all strings in a nested data structure
+    # @param obj [Object] the object to sanitize (Hash, Array, String, or other)
+    # @return [Object] sanitized version maintaining the original structure
+    def deep_sanitize(obj)
+      case obj
+      when Hash
+        obj.transform_values { |v| deep_sanitize(v) }
+      when Array
+        obj.map { |v| deep_sanitize(v) }
+      when String
+        CGI.unescapeHTML(Loofah.fragment(obj.to_s).scrub!(:prune).to_s)
+      else
+        obj
+      end
     end
   end
 end

data/app/services/hyrax/permalink_path.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Hyrax
+  # Returns the canonical, UUID-based path for a Hyrax resource
+  # (e.g. '/concern/generic_works/<uuid>' or '/collections/<uuid>').
+  #
+  # Collections are routed by the Hyrax engine; works are routed by the
+  # host app's curation-concern resources, so the picker consults
+  # `resource.collection?` to choose the right route helper.
+  module PermalinkPath
+    module_function
+
+    # @param resource [#collection?] a Hyrax::Resource (work or collection)
+    # @return [String] the canonical path, e.g. '/concern/generic_works/<uuid>'
+    def call(resource)
+      helpers = collection_resource?(resource) ? Hyrax::Engine.routes.url_helpers : Rails.application.routes.url_helpers
+      helpers.polymorphic_path(resource)
+    end
+
+    def collection_resource?(resource)
+      resource.respond_to?(:collection?) && resource.collection?
+    end
+    private_class_method :collection_resource?
+  end
+end

data/app/services/hyrax/qa_select_service.rb

@@ -27,19 +27,22 @@ module Hyrax
     #
     # @raise [KeyError] when the key has no `active:` status
     def active?(id)
-      authority.find(id).fetch('active')
+      result = authority.find(id)
+      return false if result.empty?
+      result&.fetch('active')
     end
 
     ##
     # @param id [String]
     #
-    # @return [String] the label for the authority
+    # @return [String] the label for the authority, falling back to the id itself
+    #   when no matching term exists. Callers may pass a block to override the
+    #   fallback value.
     #
     # @yield when no 'term' value is present for the id
     # @yieldreturn [String] an alternate label to return
-    #
-    # @raise [KeyError] when no 'term' value is present for the id
     def label(id, &block)
+      block ||= ->(_key) { id }
       authority.find(id).fetch('term', &block)
     end
 
@@ -61,8 +64,9 @@ module Hyrax
     #   that this service knows about HTML rendering details. Maybe a factory
     #   is an appropriate next step?
     def include_current_value(value, _index, render_options, html_options)
+      force_select = html_options[:class].is_a?(Array) ? [' force-select'] : ' force-select'
       unless value.blank? || active?(value)
-        html_options[:class] += ' force-select'
+        html_options[:class] += force_select
         render_options += [[label(value) { value }, value]]
       end
       [render_options, html_options]

data/app/services/hyrax/redirect_path_normalizer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Hyrax
+  # Normalizes a user- or system-supplied redirect path into the canonical
+  # form stored in `hyrax_redirect_paths` and queried by the resolver.
+  # Single source of truth for "what does this path look like on disk?".
+  #
+  # Normalization rules:
+  # 1. If input parses as a URL with scheme/host, keep only the path component
+  #    (drop scheme, host, port, userinfo, query, fragment).
+  # 2. Strip query strings and fragments from path-only inputs.
+  # 3. Ensure a leading slash.
+  # 4. Strip trailing slashes (but never reduce the path to empty).
+  #
+  # Idempotent: normalize(normalize(x)) == normalize(x).
+  #
+  # See documentation/redirects.md.
+  module RedirectPathNormalizer
+    module_function
+
+    def call(input)
+      return input if input.nil?
+      path = input.to_s.strip
+      return path if path.empty?
+
+      path = extract_path(path)
+      path = strip_query_and_fragment(path)
+      path = ensure_leading_slash(path)
+      path = strip_trailing_slashes(path)
+      path
+    end
+
+    def extract_path(path)
+      return path unless path.match?(%r{\A[a-zA-Z][a-zA-Z0-9+.-]*://})
+      uri = URI.parse(path)
+      uri.path.presence || '/'
+    rescue URI::InvalidURIError
+      path
+    end
+    private_class_method :extract_path
+
+    def strip_query_and_fragment(path)
+      path.sub(/[?#].*\z/, '')
+    end
+    private_class_method :strip_query_and_fragment
+
+    def ensure_leading_slash(path)
+      path.start_with?('/') ? path : "/#{path}"
+    end
+    private_class_method :ensure_leading_slash
+
+    def strip_trailing_slashes(path)
+      stripped = path.sub(/\/+\z/, '')
+      stripped.empty? ? '/' : stripped
+    end
+    private_class_method :strip_trailing_slashes
+  end
+end

data/app/services/hyrax/redirects_lookup.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Hyrax
+  # Single point of truth for read-side queries against the
+  # `hyrax_redirect_paths` table. The unique index on `from_path` makes
+  # both lookups (`.find_row` and `.taken?`) indexed equality checks on a
+  # small derived table — sub-millisecond against any reasonable load.
+  #
+  # See documentation/redirects.md.
+  class RedirectsLookup
+    # Returns true if any row exists with the given `from_path`, optionally
+    # excluding rows owned by `except_id`. Used by `Hyrax::RedirectValidator`
+    # at form-submit time to surface "this alias is already in use" before
+    # the DB unique index would reject the insert.
+    #
+    # @param path [String] the alias to check, normalized or not
+    # @param except_id [String, nil] resource_id to exclude from the check
+    # @return [Boolean]
+    def self.taken?(path, except_id: nil)
+      new(path, except_id: except_id).taken?
+    end
+
+    # Returns the `Hyrax::RedirectPath` row matching the given `from_path`,
+    # or nil when no row matches. Used by request-time resolvers
+    # (`Hyrax::RedirectsController` and the `Hyrax::RedirectToDisplayUrl`
+    # before_action) to decide whether the visited path triggers a
+    # redirect or in-process dispatch.
+    #
+    # @param path [String] the visited path, normalized or not
+    # @return [Hyrax::RedirectPath, nil]
+    def self.find_row(path)
+      normalized = Hyrax::RedirectPathNormalizer.call(path)
+      return nil if normalized.blank?
+      Hyrax::RedirectPath.find_by(from_path: normalized)
+    end
+
+    # Returns the `from_path` of the row marked as the resource's display
+    # URL, or nil when no row is marked.
+    #
+    # @param resource_id [String]
+    # @return [String, nil]
+    def self.display_path_for(resource_id)
+      return nil if resource_id.blank?
+      Hyrax::RedirectPath.where(resource_id: resource_id, is_display_url: true).limit(1).pick(:from_path)
+    end
+
+    def initialize(path, except_id: nil)
+      @path = Hyrax::RedirectPathNormalizer.call(path)
+      @except_id = except_id
+    end
+
+    def taken?
+      return false if @path.blank?
+      scope = Hyrax::RedirectPath.where(from_path: @path)
+      scope = scope.where.not(resource_id: @except_id) if @except_id.present?
+      scope.exists?
+    end
+  end
+end

data/app/services/hyrax/resource_permissions_visibility_propagator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Propagates visibility from a valkyrie Work to its FileSets
+  class ResourcePermissionsVisibilityPropagator
+    ##
+    # @!attribute [rw] source
+    #   @return [#visibility]
+    attr_accessor :source
+
+    ##
+    # @!attribute [r] embargo_manager
+    #   @return [Hyrax::EmbargoManager]
+    # @!attribute [r] lease_manager
+    #   @return [Hyrax::LeaseManager]
+    # @!attribute [r] persister
+    #   @return [#save]
+    # @!attribute [r] queries
+    #   @return [Valkyrie::Persistence::CustomQueryContainer]
+    attr_reader :embargo_manager, :lease_manager, :persister, :queries
+
+    ##
+    # @param source [#visibility] the object to propagate visibility from
+    def initialize(source:,
+                   embargo_manager: Hyrax::EmbargoManager,
+                   lease_manager:   Hyrax::LeaseManager,
+                   persister:       Hyrax.persister,
+                   queries:         Hyrax.custom_queries)
+      @persister       = persister
+      @queries         = queries
+      self.source      = source
+      @embargo_manager = embargo_manager.new(resource: source)
+      @lease_manager   = lease_manager.new(resource: source)
+    end
+
+    ##
+    # @return [void]
+    #
+    # @raise [RuntimeError] if visibility propagation fails
+    def propagate
+      queries.find_child_file_sets(resource: source).each do |file_set|
+        file_set.visibility = source.visibility
+        embargo_manager.copy_embargo_to(target: file_set)
+        lease_manager.copy_lease_to(target: file_set)
+
+        Hyrax::AccessControlList
+          .copy_permissions(source: source, target: file_set)
+        file_set.permission_manager.acl.save
+        persister.save(resource: file_set)
+      end
+    end
+  end
+end

data/app/services/hyrax/resource_types_service.rb

@@ -1,26 +1,9 @@
 # frozen_string_literal: true
 module Hyrax
   module ResourceTypesService
-    mattr_accessor :authority
-    self.authority = Qa::Authorities::Local.subauthority_for('resource_types')
+    extend Hyrax::AuthorityService
 
-    def self.select_options
-      authority.all.map do |element|
-        [element[:label], element[:id]]
-      end
-    end
-
-    def self.label(id)
-      authority.find(id).fetch('term')
-    end
-
-    ##
-    # @param [String, nil] id identifier of the resource type
-    #
-    # @return [String] a schema.org type. Gives the default type if `id` is nil.
-    def self.microdata_type(id)
-      return Hyrax.config.microdata_default_type if id.nil?
-      Microdata.fetch("resource_type.#{id}", default: Hyrax.config.microdata_default_type)
-    end
+    authority_name 'resource_types'
+    microdata_namespace 'resource_type.'
   end
 end

data/app/services/hyrax/rights_statement_service.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Hyrax
   # Provide select options for the copyright status (edm:rights) field
-  class RightsStatementService < QaSelectService
+  class RightsStatementService < TolerantSelectService
     def initialize(_authority_name = nil)
       super('rights_statements')
     end

data/app/services/hyrax/schema_loader.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # @api private
+  #
+  # This is a simple yaml config-driven schema loader
+  #
+  # @see config/metadata/basic_metadata.yaml for an example configuration
+  class SchemaLoader
+    class UndefinedSchemaError < ArgumentError; end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash<Symbol, Dry::Types::Type>] a map from attribute names to
+    #   types
+    def attributes_for(schema:, version: 1, contexts: nil)
+      definitions(schema, version, contexts).each_with_object({}) do |definition, hash|
+        hash[definition.name] = definition.type.meta(definition.config)
+      end
+    end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [Hash{Symbol => Hash{Symbol => Object}}]
+    def form_definitions_for(schema:, version: 1, contexts: nil)
+      definitions(schema, version, contexts).each_with_object({}) do |definition, hash|
+        next if definition.form_options.empty?
+
+        hash[definition.name] = definition.form_options
+      end
+    end
+
+    ##
+    # @param [Symbol] schema
+    #
+    # @return [{Symbol => Symbol}] a map from index keys to attribute names
+    def index_rules_for(schema:, version: 1, contexts: nil)
+      definitions(schema, version, contexts).each_with_object({}) do |definition, hash|
+        definition.index_keys.each do |key|
+          hash[key] = definition.name
+        end
+      end
+    end
+
+    def current_version
+      1
+    end
+
+    ##
+    # @api private
+    class AttributeDefinition
+      ##
+      # @!attr_reader :config
+      #   @return [Hash<String, Object>]
+      # @!attr_reader :name
+      #   @return [#to_sym]
+      attr_reader :config, :name
+
+      ##
+      # @param [#to_sym] name
+      # @param [Hash<String, Object>] config
+      def initialize(name, config)
+        @config = config
+        @name   = (config['name'] || name).to_sym
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}]
+      def form_options
+        config.fetch('form', {})&.symbolize_keys || {}
+      end
+
+      ##
+      # @return [Enumerable<Symbol>]
+      def index_keys
+        (config.fetch('indexing', nil) || config.fetch('index_keys', []))&.reject { |k| ['facetable', 'stored_searchable', 'admin_only', 'editor_only'].include?(k) }&.map(&:to_sym) || []
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}]
+      def view_options
+        # prefer display_label over view:label for labels, make available in the view
+        @view_options = config.fetch('view', {})&.with_indifferent_access || {}
+        Deprecation.warn('view: label is deprecated, use display_label instead') if @view_options[:label].present?
+        @view_options.delete(:label)
+        @view_options[:display_label] = display_label
+        @view_options[:admin_only] = admin_only?
+        @view_options[:editor_only] = editor_only?
+        @view_options
+      end
+
+      def display_label
+        return @display_label if @display_label
+        @display_label = config.fetch('display_label', {})&.with_indifferent_access || {}
+        @display_label = { default: @display_label } if @display_label.is_a?(String)
+        @display_label
+      end
+
+      def admin_only?
+        @admin_only ||= config.fetch('admin_only', false) || config['indexing']&.include?('admin_only')
+      end
+
+      def editor_only?
+        @editor_only ||= config.fetch('editor_only', false) || config['indexing']&.include?('editor_only')
+      end
+
+      ##
+      # @return [Dry::Types::Type]
+      def type
+        member_type = type_for(config['type'])
+        wrapper_type = multiple? ? Valkyrie::Types::Array.constructor(&Coerce) : Identity
+        wrapper_type.of(member_type)
+      end
+
+      # Cleans up the input before the type system sees it: drops the
+      # "no value provided" placeholder dry-types uses internally, then
+      # removes blanks. Wraps a bare Hash in a one-element array; using
+      # `Array(hash)` would surprise-flatten it into [[:k, v], ...] pairs.
+      # Valkyrie's JSONValueMapper unwraps single-element arrays on read,
+      # so the type sees a hash here when there was originally one entry.
+      Coerce = lambda do |value|
+        return [] if value.equal?(Dry::Types::Undefined)
+        wrapped = value.is_a?(::Hash) ? [value] : Array(value)
+        wrapped.reject { |v| v.equal?(Dry::Types::Undefined) }.select(&:present?)
+      end
+
+      # Determine whether this attribute allows multiple values.
+      def multiple?
+        return config['multiple'] if config.key?('multiple')
+        return true if config.key?('data_type') && config['data_type'] == 'array'
+        return false unless (card = config['cardinality'])
+
+        max = card['maximum']
+        max.nil? || max.to_i > 1
+      end
+
+      ##
+      # @api private
+      #
+      # Single-value wrapper that matches the multi-value branch's cleanup:
+      # strips the dry-types Undefined placeholder and coerces blank strings to nil.
+      # Booleans, numbers, and other types pass through unchanged.
+      #
+      # @example
+      #   Identity.of(Valkyrie::Types::String) # => Valkyrie::Types::String with blank-string → nil coercion
+      class Identity
+        def self.of(type)
+          type.constructor do |value|
+            next nil if value.equal?(Dry::Types::Undefined)
+            value.is_a?(String) ? value.presence : value
+          end
+        end
+      end
+
+      private
+
+      ##
+      # Resolves a `type:` value from a schema YAML to a Dry::Types::Type.
+      #
+      # Recognized values:
+      #   - `id`, `uri`, `date_time` — Valkyrie type shortcuts.
+      #   - `hash` — for attributes whose entries carry multiple sub-fields
+      #     (e.g. redirects, with path / canonical / sequence). Use this
+      #     instead of nesting a Valkyrie::Resource. See
+      #     `documentation/redirects.md` for a worked example.
+      #   - Any primitive Valkyrie type, looked up under `Valkyrie::Types::*`
+      #     by classified name (e.g. `string` → `Valkyrie::Types::String`).
+      #
+      # Raises `ArgumentError` if nothing matches.
+      #
+      # @param [String]
+      # @return [Dry::Types::Type]
+      def type_for(type)
+        case type
+        when 'id'
+          Valkyrie::Types::ID
+        when 'uri'
+          Valkyrie::Types::URI
+        when 'date_time'
+          Valkyrie::Types::DateTime
+        when 'hash'
+          Dry::Types['hash']
+        else
+          "Valkyrie::Types::#{type.classify}".safe_constantize ||
+            raise(ArgumentError, "Unrecognized type: #{type}")
+        end
+      end
+    end
+
+    class UndefinedSchemaError < ArgumentError; end
+
+    private
+
+    def definitions(_schema_name, _version, _contexts)
+      raise NotImplementedError, 'Implement #definitions in a child class'
+    end
+
+    def config_search_paths
+      Hyrax.config.schema_loader_config_search_paths
+    end
+  end
+end

data/app/services/hyrax/search_service.rb

@@ -10,7 +10,7 @@ module Hyrax
 
     def method_missing(method_name, *arguments, &block)
       if scope&.respond_to?(method_name)
-        Deprecation.warn(self.class, "Calling `#{method_name}` on scope " \
+        Deprecation.warn("Calling `#{method_name}` on scope " \
           'is deprecated and will be removed in Blacklight 8. Call #to_h first if you ' \
           ' need to use hash methods (or, preferably, use your own SearchState implementation)')
         scope&.public_send(method_name, *arguments, &block)