require-hooks 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 25df07edf75eef2e55e17548e0e02d54ba54e542e4ee3ebe20ec54958d3e2385
+  data.tar.gz: 8337f6fc90e9ee9e917ce30c3f1eb7536309ca590b0882798e70969d519cf626
+SHA512:
+  metadata.gz: 55979ba3219aacfc8a1626e4c198518f29e527a1bb547e39d86f4fd170d1562c71166df87e50c5d4ad5a7deb58adfa5248dfeac85baa21a41839cecac4441460
+  data.tar.gz: 33c22e744609eccfd80eb46949e7e5740a563cabbbfb9e0a6d68e6fede8a377ea10cfb47998670ae67003e7723e6b2f9c58e3a7cce832488409f254624a4f2f0

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Change log
+
+## master
+
+## 0.1.0 (2023-07-14)
+
+- Extracted from Ruby Next. ([@palkan][]])
+
+[@palkan]: https://github.com/palkan

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2023 Vladimir Dementyev
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,130 @@
+[![Gem Version](https://badge.fury.io/rb/require-hooks.svg)](https://rubygems.org/gems/require-hooks)
+[![Build](https://github.com/ruby-next/require-hooks/workflows/Build/badge.svg)](https://github.com/palkan/require-hooks/actions)
+[![JRuby Build](https://github.com/ruby-next/require-hooks/workflows/JRuby%20Build/badge.svg)](https://github.com/ruby-next/require-hooks/actions)
+[![TruffleRuby Build](https://github.com/ruby-next/require-hooks/workflows/TruffleRuby%20Build/badge.svg)](https://github.com/ruby-next/require-hooks/actions)
+
+# Require Hooks
+
+Require Hooks is a library providing universal interface for injecting custom code into the Ruby's loading mechanism. It works on MRI, JRuby, and TruffleRuby.
+
+Require hooks allows you to interfere with `Kernel#require` (incl. `Kernel#require_relative`) and `Kernel#load`.
+
+<a href="https://evilmartians.com/">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+## Examples
+
+- [Ruby Next][ruby-next]
+- [Freezolite](https://github.com/ruby-next/freezolite)
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "require-hooks"
+```
+
+or gemspec:
+
+```ruby
+spec.add_dependency "require-hooks"
+```
+
+## Usage
+
+To enable hooks, you need to load `require-hooks/setup` as early as possible. For example, in your gem's entrypoint:
+
+```ruby
+require "require-hooks/setup"
+```
+
+Then, you can add hooks:
+
+- **around_load:** a hook that wraps code loading operation. Useful for logging and debugging purposes.
+
+```ruby
+# Simple logging
+RequireHooks.around_load do |path, &block|
+  puts "Loading #{path}"
+  block.call.tap { puts "Loaded #{path}" }
+end
+
+# Error enrichment
+RequireHooks.around_load do |path, &block|
+  block.call
+rescue SyntaxError => e
+  raise "Oops, your Ruby is not Ruby: #{e.message}"
+end
+```
+
+The return value MUST be a result of calling the passed block.
+
+- **source_transform:** perform source-to-source transformations.
+
+```ruby
+RequireHooks.source_transform do |path, source|
+  next unless path =~ /my_project\/.*/
+  source ||= File.read(path)
+  "# frozen_string_literal: true\n#{source}"
+end
+```
+
+The return value MUST be either String (new source code) or `nil` (indicating that no transformations were performed). The second argument (`source`) MAY be `nil``, indicating that no transformer tried to transform the source code.
+
+- **hijack_load:** a hook that is used to manually compile byte code for VM to load it.
+
+```ruby
+RequireHooks.hijack_load do |path, source|
+  next unless path =~ /my_project\/.*/
+
+  source ||= File.read(path)
+  if defined?(RubyVM::InstructionSequence)
+    RubyVM::InstructionSequence.compile(source)
+  elsif defined?(JRUBY_VERSION)
+    JRuby.compile(source)
+  end
+end
+```
+
+The return value is platform-specific. If there are multiple _hijackers_, the first one that returns a non-`nil` value is used, others are ignored.
+
+## Modes
+
+Depending on the runtime conditions, Require Hooks picks an optimal strategy for injecting the code. You can enforce a particular _mode_ by setting the `REQUIRE_HOOKS_MODE` env variable (`patch`, `load_iseq` or `bootsnap`). In practice, only setting to `patch` may makes sense.
+
+### Via `#load_iseq`
+
+If `RubyVM::InstructionSequence` is available, we use more robust way of hijacking code loading—`RubyVM::InstructionSequence#load_iseq`.
+
+Keep in mind that if there is already a `#load_iseq` callback defined, it will only have an effect if Require Hooks hijackers return `nil`.
+
+### Kernel patching
+
+In this mode, Require Hooks monkey-patches `Kernel#require` and friends. This mode is used in JRuby by default.
+
+### Bootsnap integration
+
+[Bootsnap][] is a great tool to speed-up your application load and it's included into the default Rails Gemfile. And it uses `#load_iseq`. Require Hooks activates a custom Bootsnap-compatible mode, so you can benefit from both tools.
+
+You can use require-hooks with Bootsnap to customize code loading. Just make sure you load `require-hooks/setup` after setting up Bootsnap, for example:
+
+```ruby
+require "bootsnap/setup"
+require "require-hooks/setup"
+```
+
+The _around load_ hooks are executed for all files independently of whether they are cached or not. Source transformation and hijacking is only done for non-cached files.
+
+Thus, if you introduce new source transformers or hijackers, you must invalidate the cache. (We plan to implement automatic invalidation in future versions.)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/ruby-next/require-hooks](https://github.com/ruby-next/require-hooks).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[Bootsnap]: https://github.com/Shopify/bootsnap
+[ruby-next]: https://github.com/ruby-next/ruby-next

data/lib/require-hooks/api.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RequireHooks
+  @@around_load = []
+  @@source_transform = []
+  @@hijack_load = []
+
+  class << self
+    # Define a block to wrap the code loading.
+    # The return value MUST be a result of calling the passed block.
+    # For example, you can use such hooks for instrumentation, debugging purposes.
+    #
+    #    RequireHooks.around_load do |path, &block|
+    #      puts "Loading #{path}"
+    #      block.call.tap { puts "Loaded #{path}" }
+    #    end
+    def around_load(&block)
+      @@around_load << block
+    end
+
+    # Define hooks to perform source-to-source transformations.
+    # The return value MUST be either String (new source code) or nil (indicating that no transformations were performed).
+    #
+    # NOTE: The second argument (`source`) MAY be nil, indicating that no transformer tried to transform the source code.
+    #
+    # For example, you can prepend each file with `# frozen_string_literal: true` pragma:
+    #
+    #    RequireHooks.source_transform do |path, source|
+    #      "# frozen_string_literal: true\n#{source}"
+    #    end
+    def source_transform(&block)
+      @@source_transform << block
+    end
+
+    # This hook should be used to manually compile byte code to be loaded by the VM.
+    # The arguments are (path, source = nil), where source is only defined if transformations took place.
+    # Otherwise, you MUST read the source code from the file yourself.
+    #
+    # The return value MUST be either nil (continue to the next hook or default behavior) or a platform-specific bytecode object (e.g., RubyVM::InstructionSequence).
+    #
+    #   RequireHooks.hijack_load do |path, source|
+    #     source ||= File.read(path)
+    #     if defined?(RubyVM::InstructionSequence)
+    #       RubyVM::InstructionSequence.compile(source)
+    #     elsif defined?(JRUBY_VERSION)
+    #       JRuby.compile(source)
+    #     end
+    #   end
+    def hijack_load(&block)
+      @@hijack_load << block
+    end
+
+    def run_around_load_callbacks(path)
+      return yield if @@around_load.empty?
+
+      chain = @@around_load.reverse.inject do |acc_proc, next_proc|
+        proc { |path, &block| acc_proc.call(path) { next_proc.call(path, &block) } }
+      end
+
+      chain.call(path) { yield }
+    end
+
+    def perform_source_transform(path)
+      return unless @@source_transform.any?
+
+      source = nil
+
+      @@source_transform.each do |transform|
+        source = transform.call(path, source) || source
+      end
+
+      source
+    end
+
+    def try_hijack_load(path, source)
+      return unless @@hijack_load.any?
+
+      @@hijack_load.each do |hijack|
+        result = hijack.call(path, source)
+        return result if result
+      end
+      nil
+    end
+  end
+end

data/lib/require-hooks/mode/bootsnap.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RequireHooks
+  module Bootsnap
+    module CompileCacheExt
+      def input_to_storage(source, path, *)
+        new_contents = RequireHooks.perform_source_transform(path)
+        hijacked = RequireHooks.try_hijack_load(path, new_contents)
+
+        if hijacked
+          raise TypeError, "Unsupported bytecode format for #{path}: #{hijack.class}" unless hijacked.is_a?(::RubyVM::InstructionSequence)
+          return hijacked.to_binary
+        elsif new_contents
+          return RubyVM::InstructionSequence.compile(new_contents, path, path, 1).to_binary
+        end
+
+        super
+      rescue SyntaxError, TypeError
+        raise Bootsnap::CompileCache::Uncompilable
+      end
+    end
+
+    module LoadIseqExt
+      # Around hooks must be performed every time we trigger a file load, even if
+      # the file is already cached.
+      def load_iseq(path)
+        RequireHooks.run_around_load_callbacks(path) { super }
+      end
+    end
+  end
+end
+
+Bootsnap::CompileCache::ISeq.singleton_class.prepend(RequireHooks::Bootsnap::CompileCacheExt)
+RubyVM::InstructionSequence.singleton_class.prepend(RequireHooks::Bootsnap::LoadIseqExt)

data/lib/require-hooks/mode/kernel_patch.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require "mutex_m"
+require "pathname"
+
+module RequireHooks
+  module KernelPatch
+    class << self
+      def load(path)
+        RequireHooks.run_around_load_callbacks(path) do
+          new_contents = RequireHooks.perform_source_transform(path)
+          hijacked = RequireHooks.try_hijack_load(path, new_contents)
+
+          return try_evaluate(path, hijacked) if hijacked
+
+          if new_contents
+            evaluate(new_contents, path)
+            true
+          else
+            load_without_require_hooks(path)
+          end
+        end
+      end
+
+      private
+
+      def try_evaluate(path, bytecode)
+        if defined?(::RubyVM::InstructionSequence) && bytecode.is_a?(::RubyVM::InstructionSequence)
+          bytecode.eval
+        else
+          raise TypeError, "Unknown bytecode format for #{path}: #{bytecode.inspect}"
+        end
+
+        true
+      end
+
+      if defined?(JRUBY_VERSION) || defined?(TruffleRuby)
+        def evaluate(code, filepath)
+          new_toplevel.eval(code, filepath)
+        end
+
+        def new_toplevel
+          # Create new "toplevel" binding to avoid lexical scope re-use
+          # (aka "leaking refinements")
+          eval "proc{binding}.call", TOPLEVEL_BINDING, __FILE__, __LINE__
+        end
+      else
+        def evaluate(code, filepath)
+          # This is workaround to solve the "leaking refinements" problem in MRI
+          RubyVM::InstructionSequence.compile(code, filepath).tap do |iseq|
+            iseq.eval
+          end
+        end
+      end
+    end
+
+    module Features
+      class Locker
+        class PathLock
+          def initialize
+            @mu = Mutex.new
+            @resolved = false
+          end
+
+          def owned?
+            @mu.owned?
+          end
+
+          def locked?
+            @mu.locked?
+          end
+
+          def lock!
+            @mu.lock
+          end
+
+          def unlock!
+            @mu.unlock
+          end
+
+          def resolve!
+            @resolved = true
+          end
+
+          def resolved?
+            @resolved
+          end
+        end
+
+        attr_reader :features, :mu
+
+        def initialize
+          @mu = Mutex.new
+          @features = {}
+        end
+
+        def lock_feature(fname)
+          lock = mu.synchronize do
+            features[fname] ||= PathLock.new
+          end
+
+          # Can this even happen?
+          return yield(true) if lock.resolved?
+
+          # Recursive require
+          if lock.owned? && lock.locked?
+            warn "circular require considered harmful: #{fname}"
+            return yield(true)
+          end
+
+          lock.lock!
+          begin
+            yield(lock.resolved?).tap do
+              lock.resolve!
+            end
+          ensure
+            lock.unlock!
+
+            mu.synchronize do
+              features.delete(fname)
+            end
+          end
+        end
+
+        def locked_feature?(fname)
+          mu.synchronize { features.key?(fname) }
+        end
+      end
+
+      LOCK = Locker.new
+
+      class << self
+        def feature_path(path, implitic_ext: true)
+          path = resolve_feature_path(path, implitic_ext: implitic_ext)
+          return if path.nil?
+          return if File.extname(path) != ".rb" && implitic_ext
+          path
+        end
+
+        # Based on https://github.com/ruby/ruby/blob/b588fd552390c55809719100d803c36bc7430f2f/load.c#L403-L415
+        def feature_loaded?(feature)
+          return true if $LOADED_FEATURES.include?(feature) && !LOCK.locked_feature?(feature)
+
+          feature = Pathname.new(feature).cleanpath.to_s
+          efeature = File.expand_path(feature)
+
+          # Check absoulute and relative paths
+          return true if $LOADED_FEATURES.include?(efeature) && !LOCK.locked_feature?(efeature)
+
+          candidates = []
+
+          $LOADED_FEATURES.each do |lf|
+            candidates << lf if lf.end_with?("/#{feature}")
+          end
+
+          return false if candidates.empty?
+
+          $LOAD_PATH.each do |lp|
+            lp_feature = File.join(lp, feature)
+            return true if candidates.include?(lp_feature) && !LOCK.locked_feature?(lp_feature)
+          end
+
+          false
+        end
+
+        private
+
+        def lookup_feature_path(path, implitic_ext: true)
+          path = "#{path}.rb" if File.extname(path).empty? && implitic_ext
+
+          # Resolve relative paths only against current directory
+          if path.match?(/^\.\.?\//)
+            path = File.expand_path(path)
+            return path if File.file?(path)
+            return nil
+          end
+
+          if Pathname.new(path).absolute?
+            path = File.expand_path(path)
+            return File.file?(path) ? path : nil
+          end
+
+          # not a relative, not an absolute path — bare path; try looking relative to current dir,
+          # if it's in the $LOAD_PATH
+          if $LOAD_PATH.include?(Dir.pwd) && File.file?(path)
+            return File.expand_path(path)
+          end
+
+          $LOAD_PATH.find do |lp|
+            lpath = File.join(lp, path)
+            return File.expand_path(lpath) if File.file?(lpath)
+          end
+        end
+
+        if $LOAD_PATH.respond_to?(:resolve_feature_path)
+          def resolve_feature_path(feature, implitic_ext: true)
+            if implitic_ext
+              path = $LOAD_PATH.resolve_feature_path(feature)
+              path.last if path # rubocop:disable Style/SafeNavigation
+            else
+              lookup_feature_path(feature, implitic_ext: implitic_ext)
+            end
+          rescue LoadError
+          end
+        else
+          def resolve_feature_path(feature, implitic_ext: true)
+            lookup_feature_path(feature, implitic_ext: implitic_ext)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Patch Kernel to hijack require/require_relative/load
+module Kernel
+  module_function
+
+  alias_method :require_without_require_hooks, :require
+  # See https://github.com/ruby/ruby/blob/d814722fb8299c4baace3e76447a55a3d5478e3a/load.c#L1181
+  def require(path)
+    path = path.to_path if path.respond_to?(:to_path)
+    raise TypeError unless path.respond_to?(:to_str)
+
+    path = path.to_str
+
+    raise TypeError unless path.is_a?(::String)
+
+    realpath = nil
+
+    # if extname == ".rb" => lookup feature -> resolve feature -> load
+    # if extname != ".rb" => append ".rb" - lookup feature -> resolve feature -> lookup orig (no ext) -> resolve orig (no ext) -> load
+    if File.extname(path) != ".rb"
+      return false if RequireHooks::KernelPatch::Features.feature_loaded?(path + ".rb")
+
+      loaded = RequireHooks::KernelPatch::Features::LOCK.lock_feature(path + ".rb") do |loaded|
+        return false if loaded
+
+        realpath = RequireHooks::KernelPatch::Features.feature_path(path + ".rb")
+
+        if realpath
+          $LOADED_FEATURES << realpath
+          RequireHooks::KernelPatch.load(realpath)
+          true
+        end
+      end
+
+      return true if loaded
+    end
+
+    return false if RequireHooks::KernelPatch::Features.feature_loaded?(path)
+
+    loaded = RequireHooks::KernelPatch::Features::LOCK.lock_feature(path) do |loaded|
+      return false if loaded
+
+      realpath = RequireHooks::KernelPatch::Features.feature_path(path)
+
+      if realpath
+        $LOADED_FEATURES << realpath
+        RequireHooks::KernelPatch.load(realpath)
+        true
+      end
+    end
+
+    return true if loaded
+
+    require_without_require_hooks(path)
+  rescue LoadError => e
+    $LOADED_FEATURES.delete(realpath) if realpath
+    warn "RequireHooks failed to require '#{path}': #{e.message}"
+    require_without_require_hooks(path)
+  rescue Errno::ENOENT, Errno::EACCES
+    raise LoadError, "cannot load such file -- #{path}"
+  rescue
+    $LOADED_FEATURES.delete(realpath) if realpath
+    raise
+  end
+
+  alias_method :require_relative_without_require_hooks, :require_relative
+  def require_relative(path)
+    path = path.to_path if path.respond_to?(:to_path)
+    raise TypeError unless path.respond_to?(:to_str)
+    path = path.to_str
+
+    raise TypeError unless path.is_a?(::String)
+
+    return require(path) if Pathname.new(path).absolute?
+
+    loc = caller_locations(1..1).first
+    from = loc.absolute_path || loc.path || File.join(Dir.pwd, "main")
+    realpath = File.absolute_path(
+      File.join(
+        File.dirname(File.absolute_path(from)),
+        path
+      )
+    )
+
+    require(realpath)
+  end
+
+  alias_method :load_without_require_hooks, :load
+  def load(path, wrap = false)
+    if wrap
+      warn "RequireHooks does not support `load(smth, wrap: ...)`. Falling back to original `Kernel#load`"
+      return load_without_require_hooks(path, wrap)
+    end
+
+    path = path.to_path if path.respond_to?(:to_path)
+    raise TypeError unless path.respond_to?(:to_str)
+
+    path = path.to_str
+
+    raise TypeError unless path.is_a?(::String)
+
+    realpath =
+      if path =~ /^\.\.?\//
+        path
+      else
+        RequireHooks::KernelPatch::Features.feature_path(path, implitic_ext: false)
+      end
+
+    return load_without_require_hooks(path, wrap) unless realpath
+
+    RequireHooks::KernelPatch.load(realpath)
+  rescue Errno::ENOENT, Errno::EACCES
+    raise LoadError, "cannot load such file -- #{path}"
+  rescue LoadError => e
+    warn "RuquireHooks failed to load '#{path}': #{e.message}"
+    load_without_require_hooks(path)
+  end
+end

data/lib/require-hooks/mode/load_iseq.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RequireHooks
+  module LoadIseq
+    def load_iseq(path)
+      RequireHooks.run_around_load_callbacks(path) do
+        new_contents = RequireHooks.perform_source_transform(path)
+        hijacked = RequireHooks.try_hijack_load(path, new_contents)
+
+        if hijacked
+          raise TypeError, "Unsupported bytecode format for #{path}: #{hijack.class}" unless hijacked.is_a?(::RubyVM::InstructionSequence)
+          return hijacked
+        elsif new_contents
+          return RubyVM::InstructionSequence.compile(new_contents, path, path, 1)
+        end
+
+        defined?(super) ? super : RubyVM::InstructionSequence.compile_file(path)
+      end
+    end
+  end
+end
+
+if RubyVM::InstructionSequence.respond_to?(:load_iseq)
+  warn "require-hooks: RubyVM::InstructionSequence.load_iseq is already defined. It won't be used by files processed by require-hooks."
+end
+
+RubyVM::InstructionSequence.singleton_class.prepend(RequireHooks::LoadIseq)

data/lib/require-hooks/setup.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "require-hooks/api"
+
+mode = ENV["REQUIRE_HOOKS_MODE"]
+
+case mode
+when "patch"
+  require "require-hooks/mode/kernel_patch"
+when "load_iseq"
+  require "require-hooks/mode/load_iseq"
+when "bootsnap"
+  require "require-hooks/mode/bootsnap"
+else
+  if defined?(::RubyVM::InstructionSequence)
+    # Check if Bootsnap has been loaded.
+    # Based on https://github.com/kddeisz/preval/blob/master/lib/preval.rb
+    if RubyVM::InstructionSequence.respond_to?(:load_iseq) &&
+        (load_iseq = RubyVM::InstructionSequence.method(:load_iseq)) &&
+        load_iseq.source_location[0].include?("/bootsnap/")
+      require "require-hooks/mode/bootsnap"
+    else
+      require "require-hooks/mode/load_iseq"
+    end
+  else
+    require "require-hooks/mode/kernel_patch"
+  end
+end

data/lib/require-hooks/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RequireHooks
+  VERSION = "0.1.0"
+end

data/lib/require-hooks.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "require-hooks/version"

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: require-hooks
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vladimir Dementyev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-15 00:00:00.000000000 Z
+dependencies: []
+description: Require Hooks provide infrastructure for intercepting require/load calls
+  in Ruby
+email:
+- dementiev.vm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/require-hooks.rb
+- lib/require-hooks/api.rb
+- lib/require-hooks/mode/bootsnap.rb
+- lib/require-hooks/mode/kernel_patch.rb
+- lib/require-hooks/mode/load_iseq.rb
+- lib/require-hooks/setup.rb
+- lib/require-hooks/version.rb
+homepage: https://github.com/ruby-next/ruby-next
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/ruby-next/ruby-next/issues
+  changelog_uri: https://github.com/ruby-next/ruby-next/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/ruby-next/ruby-next/blob/master/README.md
+  homepage_uri: https://github.com/ruby-next/ruby-next
+  source_code_uri: https://github.com/ruby-next/ruby-next
+  funding_uri: https://github.com/sponsors/palkan
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.8
+signing_key:
+specification_version: 4
+summary: Require Hooks provide infrastructure for intercepting require/load calls
+  in Ruby.
+test_files: []