stibium-bundled 0.0.1 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 872a10da7e3924dd1b8dca69f57bcbd7f31ab6b82097b3cd45ddfaf4ff8e0aa9
-  data.tar.gz: 97e4ccd6cd8211e1e4ad9d8ab63feec5294168b8971187ad44d6d80ee78c957b
+  metadata.gz: 3be68fcb9db04232974861f121d822dec6236d7b45a6ed3eec003d1814811e77
+  data.tar.gz: 3962f200a155fe9931eafc6664c3fb1787d6c25378fcd54c45b38b013bf7da5d
 SHA512:
-  metadata.gz: 1c253d6972da289b0ef2c78826e3d4b88d17fd19370afe47938c1cc44d6c79fd47a22f05312ade86318059e6d97c8a85937c9ed2b7817d4156ca63a4ff757479
-  data.tar.gz: 38c53b363286e39f45360d12717e9c5dd262906b770b04759e8ab7231b283175484fe674ae8d89db3a31b4cb83fe41c07bb179a5d507871312e2ebed4e5e5e8d
+  metadata.gz: dc8e6621dabc968957985f69253abae2f02c5909f51c906b8298b1cd4e9ef19ad038a9bab0aa743272f06e59d3baed1bf7155c83ee888762e5ef10e0a5d1a1c4
+  data.tar.gz: '08eb70137990b8174da7d5165c965d45b4c9820d0469ed5601aafecffd1378615aff8f97398e1ac6db75cce28c290cf5d98fa1c6711332ccb75dc715c3d5a7d2'

data/README.md

@@ -0,0 +1,129 @@
+# ``stibium-bundled`` [![Gem Version](https://badge.fury.io/rb/stibium-bundled.svg)][rubygems:stibium-bundled] [![Maintainability](https://api.codeclimate.com/v1/badges/7121242b44c7a3cc4f61/maintainability)](https://codeclimate.com/github/SwagDevOps/stibium-bundled/maintainability)
+
+This gem is intended to mimic Bundler's behavior and conform to [bundler configuration options][bundler:config].
+
+``stibium-bundled`` detects ``gems.rb`` and ``gems.locked``
+(or ``Gemfile`` and ``Gemfile.lock``)
+and [``bundler/setup``][bundler:setup] (for [standalone][man:install#options] installation).
+
+``standalone`` makes a bundle that can work __without depending__ on Bundler (or Rubygems) at runtime. Bundler generates
+a ``bundler/setup.rb`` file to replace Bundler's own setup in the manner required.
+
+[Configuration settings][bundler:config] are loaded in this order:
+
+1. Local config (``.bundle/config`` or ``"$BUNDLE_APP_CONFIG/config``)
+2. Environment variables (``ENV``)
+3. Global config (``~/.bundle/config``)
+4. Default config
+
+## Sample of use
+
+```ruby
+# file: lib/awesome_gem.rb
+
+require 'stibium/bundled'
+
+module AwesomeGem
+  include(Stibium::Bundled)
+
+  self.bundled_from("#{__dir__}/..", setup: true)
+end
+```
+
+or more concise:
+
+```ruby
+# file: lib/awesome_gem.rb
+
+require 'stibium/bundled'
+
+module AwesomeGem
+  include(Stibium::Bundled).bundled_from("#{__dir__}/..", setup: true)
+end
+```
+
+or load a gem depending on status:
+
+```ruby
+# file: lib/awesome_gem.rb
+
+require 'stibium/bundled'
+
+module AwesomeGem
+  include(Stibium::Bundled).bundled_from("#{__dir__}/..", setup: true) do |bundle|
+    if Object.const_defined?(:Gem) and bundle.locked? and bundle.installed?
+      'foo-bar'.tap do |gem_name|
+        unless bundle.specifications.keep_if { |spec| spec.name == gem_name }.empty?
+          require gem_name.gsub('-', '/')
+        end
+      end
+    end
+  end
+end
+```
+
+if ``stibium-bundled`` is not system wide installed, it can be necessary to
+locate it:
+
+```ruby
+# file: lib/awesome_gem.rb
+
+autoload(:Pathname, 'pathname')
+autoload(:RbConfig, 'rbconfig')
+
+module AwesomeGem
+  Pathname.new("#{__dir__}/..").expand_path.yield_self do |basedir|
+    begin
+      require 'stibium/bundled'
+    rescue LoadError
+      [
+        [RUBY_ENGINE, RbConfig::CONFIG.fetch('ruby_version'), 'bundler/gems/*/stibium-bundled.gemspec'],
+        [RUBY_ENGINE, RbConfig::CONFIG.fetch('ruby_version'), 'gems/stibium-bundled-*/lib/'],
+      ].map { |parts| basedir.join(*['{**/,}bundle'].concat(parts)) }.yield_self do |patterns|
+        Pathname.glob(patterns).first&.dirname.tap { |gem_dir| require gem_dir.join('lib/stibium/bundled') }
+      end
+    end
+
+    include(::Stibium::Bundled).bundled_from(basedir, setup: true) do |bundle|
+      if bundle.locked? and bundle.installed? and Object.const_defined?(:Gem)
+        require 'fabulous/feature' if bundle.specifications.keep_if { |s| s.name == 'fabulous' }.any?
+      end
+    end
+  end
+end
+```
+
+## Benchmarks
+
+Using ``Stibium::Bundled`` setup leads to minor overhead compared to direct require for ``bundler/setup``,
+on the other hand ``Stibium::Bundled`` setup is compatible with standalone's bundler setup without code change.
+And ``bundle exec`` is known to be [slow][stackoverflow/running-scripts-with-bundle-exec-is-slow].
+
+Install [hypefine][sharkdp/hyperfine] and run benchmarks:
+
+```shell
+rake bench runs=20
+```
+
+| Command | Mean [ms] | Min [ms] | Max [ms] | Relative |
+|:---|---:|---:|---:|---:|
+| `bundler/setup` | 205.7 ± 7.1 | 200.1 | 232.5 | 1.00 ± 0.05 |
+| `bundled` | 205.7 ± 6.2 | 196.8 | 222.4 | 1.00 |
+| `bundle exec` | 559.4 ± 13.0 | 543.2 | 587.8 | 2.72 ± 0.10 |
+
+## Install
+
+```sh
+bundle config set --local clean 'true'
+bundle config set --local path 'vendor/bundle'
+bundle install --standalone
+```
+
+<!-- hyperlinks -->
+
+[rubygems:stibium-bundled]: https://rubygems.org/gems/stibium-bundled
+[bundler:config]: https://bundler.io/v2.2/bundle_config.html
+[bundler:setup]: https://bundler.io/v1.5/bundler_setup.html
+[man:install#options]: https://bundler.io/man/bundle-install.1.html#OPTIONS
+[sharkdp/hyperfine]: https://github.com/sharkdp/hyperfine
+[stackoverflow/running-scripts-with-bundle-exec-is-slow]: https://stackoverflow.com/questions/13894966/running-scripts-with-bundle-exec-is-slow

data/lib/stibium/bundled.rb

@@ -17,72 +17,95 @@ end
 # ```ruby
 # # file: lib/awesome_gem.rb
 # module AwesomeGem
-#   Stibium::Bundled.call(self, basedir: "#{__dir__}/..")
+#   include(Stibium::Bundled)
 #
-#   bundled&.tap do |bundle|
-#     unless bundle.standalone!
-#         require 'bundler/setup' if bundle.locked?
-#     end
-#   end
+#   self.bundled_from("#{__dir__}/..", setup: true)
 # end
 # ```
-#
-# or:
-#
-# ```ruby
-# # file: lib/awesome_gem.rb
-# module AwesomeGem
-#   class << self
-#     include(Stibium::Bundled)
-#   end
-#
-#   self.bundled_from("#{__dir__}/..") do |bundle|
-#     unless bundle.standalone!
-#       require 'bundler/setup' if bundle.locked?
-#     end
-#   end
-# end
 module Stibium::Bundled
   {
     Bundle: 'bundle',
     VERSION: 'version',
   }.each { |k, v| autoload(k, "#{__dir__}/bundled/#{v}") }
 
-  # @!method bundled?
-  #   Denote bundle is locked or standalone.
-  #   @return [Boolean]
+  class << self
+    private
 
-  # @!method bundled
-  #   @return [Bundle, nil]
+    # Callback invoked whenever the receiver is included in another module or class.
+    #
+    # @param [Class, Module] othermod
+    #
+    # @see https://ruby-doc.org/core-2.5.3/Module.html#method-i-included
+    def included(othermod)
+      othermod.singleton_class.__send__(:include, self) unless othermod.singleton_class?
+    end
+  end
 
-  # @param [String, Pathname] basedir
+  # Denote bundle is locked or standalone.
+  #
+  # @return [Boolean]
+  #
+  # @see .call
+  def bundled?
+    false
+  end
+
+  # @return [Bundle, nil]
+  #
+  # @see .call
+  def bundled
+    nil
+  end
+
+  protected
+
+  # @param basedir [String, Pathname]
+  # @param setup [Boolean, Array<Symbol>]
+  # @param env [Hash{String => String}]
+  # @param ruby_config [Hash{Symbol => Object}]
   #
   # @return [Bundle. nil]
-  def bundled_from(basedir)
-    Stibium::Bundled
-      .call(self, basedir: basedir)
-      .bundled
-      .tap { |bundle| yield(bundle) if block_given? and bundle }
+  #
+  # @see Stibium::Bundled::Bundle#setup
+  def bundled_from(basedir, setup: false, env: ENV.to_h, ruby_config: {})
+    # @type [Stibium::Bundled::Bundle] bundle
+    Stibium::Bundled.call(self, basedir: basedir, env: env, ruby_config: ruby_config).bundled&.tap do |bundle|
+      bundle.__send__(:setup, **{ guards: setup.is_a?(Array) ? setup : nil }.compact) if setup
+
+      yield(bundle) if block_given?
+    end
   end
 
   class << self
     # @param target [Class, Module]
     # @param basedir [String, Pathname]
+    # @param env [Hash{String => String}]
+    # @param ruby_config [Hash{Symbol => Object}]
     #
-    # @return [Class, Module]
-    def call(target, basedir:)
+    # @return [Class, Module] given ``Class`` or ``Module``
+    def call(target, basedir:, env: ENV.to_h, ruby_config: nil)
       target.tap do |t|
         t.singleton_class.tap do |sc|
           sc.singleton_class.__send__(:include, self)
-          sc.define_method(:bundled?) { !bundled?.nil? }
+          sc.define_method(:bundled?) { !bundled.nil? }
           sc.define_method(:bundled) do
-            # @type [Bundle] bundle
-            # rubocop:disable Style/TernaryParentheses
-            Bundle.new(basedir).yield_self { |bundle| (bundle.locked? or bundle.standalone?) ? bundle : nil }
-            # rubocop:enable Style/TernaryParentheses
+            Stibium::Bundled.__send__(:bundler).call(basedir, env: env, ruby_config: ruby_config)
           end
         end
       end
     end
+
+    protected
+
+    # @api private
+    #
+    # @return [Proc]
+    def bundler
+      lambda do |basedir, env:, ruby_config: nil|
+        Bundle.new(basedir, env: env, ruby_config: ruby_config).yield_self do |bundle|
+          bundle.bundled? ? bundle : nil
+        end
+      end
+    end
   end
 end

data/lib/stibium/bundled/bundle.rb

@@ -11,19 +11,36 @@ require_relative '../bundled'
 # Describe a bundle.
 class Stibium::Bundled::Bundle
   autoload(:Pathname, 'pathname')
+  autoload(:Gem, 'rubygems') # @see .specifications
+
+  {
+    Config: 'config',
+    Directory: 'directory',
+  }.each { |k, v| autoload(k, "#{__dir__}/bundle/#{v}") }
 
   # @return [Pathname]
   attr_reader :path
 
+  # @return [Config]
+  attr_reader :config
+
+  # @return [Directory]
+  attr_reader :directory
+
   # @param path [String, Pathname]
+  # @param env [Hash{String => String}]
+  # @param ruby_config [Hash{Symbol => Object}]
   #
   # @raise [Errno::ENOENT]
   # @raise [ArgumentError] when given ``path`` is not a directory.
-  def initialize(path)
+  def initialize(path, env: ENV.to_h, ruby_config: {})
     self.tap do
-      @path = Pathname.new(path).realpath.freeze
+      (@path = Pathname.new(path).realpath.freeze).tap do |base_path|
+        raise ArgumentError, 'path is not a directory' unless base_path.directory?
+      end
 
-      raise ArgumentError, 'path is not a directory' unless self.path.directory?
+      @config = Config.new(self.path, env: env).freeze
+      @directory = Directory.new(self.bundle_path, ruby_config: ruby_config).freeze
     end.freeze
   end
 
@@ -38,7 +55,30 @@ class Stibium::Bundled::Bundle
   #
   # @return [Boolean]
   def locked?
-    !!gemfiles[1]
+    !!gemfiles&.fetch(1, nil)
+  end
+
+  # Get specifications.
+  #
+  # @see https://docs.ruby-lang.org/en/3.0.0/Gem/Specification.html
+  #
+  # @return [Array<Gem::Specification>]
+  def specifications
+    directory.specifications.map { |file| instance_eval(file.read, file.to_path) }.sort_by(&:name)
+  end
+
+  # Denote install seems to be happened (since specifications are present).
+  #
+  # @return [Boolean]
+  def installed?
+    !directory.specifications.empty?
+  end
+
+  # Denote bundle seems installed by bundler.
+  #
+  # @return [Boolean]
+  def bundled?
+    locked? or standalone?
   end
 
   # Get path to gemfile.
@@ -47,7 +87,7 @@ class Stibium::Bundled::Bundle
   #
   # @return [Pathname, nil]
   def gemfile
-    gemfiles[0]
+    gemfiles&.fetch(0, nil)
   end
 
   # Get gemfile files (gemfile + lockfile) or nothing.
@@ -67,23 +107,71 @@ class Stibium::Bundled::Bundle
   #
   # @return [Boolean]
   def standalone?
-    standalone_setupfile.file?
+    bundler_setup.yield_self { |fp| fp.file? and fp.readable? }
   end
 
-  # Load standalone setup if present
+  protected
+
+  # Load standalone setup if present.
   #
-  # @return [Boolean]
-  def standalone!
+  # @return [self]
+  #
+  # @raise [Errno::ENOENT, LoadError]
+  def standalone!(&fallback)
     # noinspection RubyResolve
-    standalone?.tap { |b| require standalone_setupfile if b }
+    require(bundler_setup.realpath)
+  rescue Errno::ENOENT, LoadError => e
+    fallback ? fallback.call(self) : raise(e)
+  ensure
+    self
   end
 
-  protected
+  # Load standalone setup if present, else fallback to <code>bundler/setup</code>.
+  #
+  # Load Bundler's setup (<code>bundler/setup</code>) when all guards are ``true``,
+  # as a result, default behavior, is to load <code>bundler/setup</code>
+  # only when locked and installed.
+  #
+  # @param guards [Array<Symbol>]
+  #
+  # @return [self]
+  #
+  # @raise [LoadError] when <code>bundle/setup</code> is loaded and bundler is not present.
+  #
+  # @see https://bundler.io/v1.5/bundler_setup.html
+  # @see https://github.com/ruby/ruby/blob/0e40cc9b194a5e46024d32b85a61e651372a65cb/lib/bundler.rb#L139
+  # @see https://github.com/ruby/ruby/blob/0e40cc9b194a5e46024d32b85a61e651372a65cb/lib/bundler/setup.rb
+  # @see https://github.com/ruby/ruby/blob/69ed64949b0c02d4b195809fa104ff23dd100093/lib/bundler.rb#L11
+  # @see https://github.com/ruby/ruby/blob/69ed64949b0c02d4b195809fa104ff23dd100093/lib/bundler/rubygems_integration.rb
+  def setup(guards: [:bundled, :installed])
+    self.tap do
+      unless guards.map { |s| self.public_send('%s?' % s.to_s.gsub(/\?$/, '')) }.include?(false)
+        standalone! { require 'bundler/setup' }
+      end
+    end
+  end
+
+  # @return [Pathname]
+  def bundle_path
+    Pathname.new(config.fetch('BUNDLE_PATH')).yield_self do |bundle_path|
+      (bundle_path.absolute? ? bundle_path : path.join(bundle_path))
+    end
+  end
 
+  # Standalone setup file.
+  #
+  # ``bundle install --standalone[=<list>]`` makes a bundle that can work without depending on
+  # Rubygems or Bundler at runtime.
+  # A space separated list of groups to install has to be specified.
+  # Bundler creates a directory named ``bundle`` and installs the bundle there.
+  # It also generates a ``bundle/bundler/setup.rb`` file to replace Bundler's own setup in the manner required.
+  #
   # @see #standalone?
+  # @see #standalone!
+  # @see https://bundler.io/v2.2/man/bundle-install.1.html#OPTIONS
   #
   # @return [Pathname]
-  def standalone_setupfile
-    path.join('bundle', 'bundler', 'setup.rb')
+  def bundler_setup
+    bundle_path.join('bundler/setup.rb')
   end
 end

data/lib/stibium/bundled/bundle/config.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2020-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../bundle'
+
+# Describe bundler configuration settings.
+#
+# Bundler loads configuration settings in this order:
+#
+# 1. Local config (``.bundle/config`` or ``$BUNDLE_APP_CONFIG/config``)
+# 2. Environment variables (``ENV``)
+# 3. Global config (``~/.bundle/config``)
+# 4. Bundler default config - PARTIAL support is implemented in ``Config.defaults``
+#
+# @note Executing bundle with the ``BUNDLE_IGNORE_CONFIG`` environment set will cause it to ignore all configuration.
+#
+# @see https://bundler.io/v2.2/bundle_config.html
+# @see https://evilmartians.com/chronicles/ruby-on-whales-docker-for-ruby-rails-development
+# @see .load
+# @see .read
+# @see .env
+# @see .defaults
+class Stibium::Bundled::Bundle::Config < ::Hash
+  autoload(:Pathname, 'pathname')
+  autoload(:YAML, 'yaml')
+
+  {
+    Reader: 'reader',
+  }.each { |k, v| autoload(k, "#{__dir__}/config/#{v}") }
+
+  # @param basedir [String, Pathname]
+  # @param env [Hash{String => String}]
+  def initialize(basedir, env: ENV.to_h)
+    super().tap do
+      @basedir = Pathname.new(basedir).freeze
+      @env = self.class.__send__(:env, source: env).freeze
+
+      self.class.__send__(:call, self.resolve_file, env: env).each { |k, v| self[k.freeze] = v.freeze }
+    end.freeze
+  end
+
+  # @return [Hash{String => Object}]
+  attr_reader :env
+
+  # @return [Pathname]
+  attr_reader :basedir
+
+  protected
+
+  # Resolve path to local config (depending on ``BUNDLE_APP_CONFIG`` value).
+  #
+  # @return [Pathname]
+  def resolve_file
+    begin
+      'BUNDLE_APP_CONFIG'.yield_self do |k|
+        self.env.fetch(k) { self.class.defaults.fetch(k) }
+      end
+    end.yield_self do |s|
+      Pathname.new(s)
+    end.yield_self do |path|
+      (path.absolute? ? path : basedir.join(path)).join('config')
+    end
+  end
+
+  class << self
+    # Default config values (as seen from an empty environment).
+    #
+    # ```shell
+    # rm -rfv ~/.bundle/config .bundle/config
+    # env -i $(which bundle) install --standalone
+    # cat .bundle/config
+    # ```
+    #
+    # @see Stibium::Bundled::Bundle#bundler_setup
+    def defaults
+      {
+        'BUNDLE_APP_CONFIG' => '.bundle',
+        'BUNDLE_PATH' => 'bundle',
+      }
+    end
+
+    protected
+
+    # Load config.
+    #
+    # @param file [Pathname]
+    # @param env [Hash{String => String}]
+    #
+    # @api private
+    # @see https://bundler.io/v2.2/bundle_config.html
+    #
+    # @return [Hash{String => Object}]
+    def call(file, env: ENV.to_h)
+      # @formatter:off
+      self.defaults                            # 4. Bundler default config
+          .merge(self.global_config(env: env)) # 3. Global config
+          .merge(self.env(source: env))        # 2. Environmental variables
+          .merge(self.read(file, env: env))    # 1. Local config
+          .sort.map { |k, v| [k.freeze, v.freeze] }.to_h.freeze
+      # @formatter:on
+    end
+
+    # Get global config.
+    #
+    # @api private
+    #
+    # @param env [Hash{String => String}]
+    #
+    # @return [Hash{String => Object}]
+    def global_config(env: ENV.to_h)
+      env['HOME'].yield_self do |home_path|
+        return {} if home_path.nil?
+
+        Pathname.new(home_path).expand_path.join('.bundle/config').yield_self { |file| self.read(file, env: env) }
+      end
+    end
+
+    # Get bundler related environment variables (``/^BUNDLE_.+/``)
+    #
+    # @param source [Hash{String => String}]
+    #
+    # @api private
+    #
+    # @return [Hash{String => Object}]
+    def env(source: ENV.to_h)
+      source.dup.keep_if { |k, _| /^BUNDLE_.+/ =~ k }
+            .transform_keys(&:freeze)
+            .transform_values { |v| (v.is_a?(String) ? YAML.safe_load(v) : v).freeze }
+            .sort.to_h
+    end
+
+    # Read given config file.
+    #
+    # @api private
+    #
+    # @param file [Pathname]
+    # @param env [Hash{String => String}]
+    #
+    # @return [Hash{String => Object}]
+    def read(file, env: ENV.to_h)
+      Reader.new(env: env).read(file)
+    end
+  end
+end

data/lib/stibium/bundled/bundle/config/reader.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2020-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../config'
+
+# Config file reader.
+class Stibium::Bundled::Bundle::Config::Reader
+  autoload(:YAML, 'yaml')
+
+  # @return [Hash{String => String}]
+  attr_reader :env
+
+  def initialize(env: ENV.to_h)
+    self.tap do
+      @env = env.dup.map { |k, v| [k.freeze, v.freeze] }.to_h.freeze
+    end.freeze
+  end
+
+  # @return [Boolean]
+  def ignore_config?
+    env.key?('BUNDLE_IGNORE_CONFIG')
+  end
+
+  # Read given config file.
+  #
+  # @param file [Pathname]
+  #
+  # @return [Hash{String => Object}]
+  def read(file)
+    scrutinize(file).transform_values { |v| v.is_a?(String) ? YAML.safe_load(v) : v }
+  end
+
+  protected
+
+  # @api private
+  #
+  # @param file [Pathname]
+  #
+  # @raise [RuntimeError]
+  # @return [Hash{String => Object}]
+  def scrutinize(file)
+    return {} if ignore_config?
+
+    return {} unless file.file? and file.readable?
+
+    file.read
+        .yield_self { |content| YAML.safe_load(content) }
+        .yield_self { |result| result.nil? ? {} : result }
+        .tap { |result| raise RuntimeError, "Hash expected, got #{result.class}" unless result.is_a?(Hash) }
+  end
+end

data/lib/stibium/bundled/bundle/directory.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2020-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../bundle'
+
+# Describe vendor directory.
+class Stibium::Bundled::Bundle::Directory
+  autoload(:RbConfig, 'rbconfig')
+  autoload(:Pathname, 'pathname')
+
+  # @return [Pathname]
+  attr_reader :path
+
+  # @param path [String, Pathname]
+  # @param ruby_config [Hash{Symbol => Object}]
+  def initialize(path, ruby_config: {})
+    @path = Pathname.new(path).expand_path.freeze
+    @ruby_config = {
+      engine: RUBY_ENGINE,
+      version: RbConfig::CONFIG['ruby_version'],
+    }.merge(ruby_config.to_h)
+  end
+
+  # @return [String]
+  def to_path
+    path.to_path
+  end
+
+  alias to_s to_path
+
+  # @return [Array<Pathname>]
+  def specifications
+    [
+      [ruby_config.fetch(:engine), ruby_config.fetch(:version), 'specifications', '*.gemspec'],
+      [ruby_config.fetch(:engine), ruby_config.fetch(:version), 'bundler', 'gems', '*/*.gemspec'],
+    ].map do |parts|
+      self.path.join(*parts).yield_self do |s|
+        Dir.glob(s).sort.map { |fp| Pathname.new(fp) }.keep_if(&:file?)
+      end
+    end.flatten.sort
+  end
+
+  protected
+
+  # @return [Hash{Symbol => Object}]
+  attr_reader :ruby_config
+end

data/lib/stibium/bundled/version.rb

@@ -7,11 +7,24 @@
 # There is NO WARRANTY, to the extent permitted by law.
 
 require_relative '../bundled'
-require 'kamaze/version'
 
-module Stibium::Bundled
-  # Version
-  #
-  # @type [Kamaze::Version]
-  VERSION = Kamaze::Version.new.freeze
+Stibium::Bundled.instance_eval do
+  autoload(:YAML, 'yaml')
+  autoload(:Pathname, 'pathname')
+
+  Pathname.new(__dir__).join('version.yml').tap do |file|
+    YAML.safe_load(file.read).yield_self do |v|
+      %w[major minor patch].map { |key| v.fetch(key) }.join('.')
+    end.tap do |version|
+      lambda do
+        require 'kamaze/version'
+      rescue LoadError
+        # :nocov:
+        version
+        # :nocov:
+      else
+        Kamaze::Version.new.freeze
+      end.tap { |func| self.const_set(:VERSION, func.call) }
+    end
+  end
 end

data/lib/stibium/bundled/version.yml

@@ -1,12 +1,12 @@
 ---
 major: 0
 minor: 0
-patch: 1
+patch: 6
 authors: ['Dimitri Arrigoni']
 email: 'dimitri@arrigoni.me'
-date: '2021-01-11'
+date: '2021-02-22'
 summary: 'Denote bundle state'
-description: 'Denote bundle state, based on conventions.'
+description: 'Denote bundle state and (optionally) load bundler/setup according to the configuration.'
 homepage: 'https://github.com/SwagDevOps/stibium-bundled'
 licenses: ['GPL-3.0']
 license_header: |

metadata

@@ -1,39 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: stibium-bundled
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.6
 platform: ruby
 authors:
 - Dimitri Arrigoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-11 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: kamaze-version
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-description: Denote bundle state, based on conventions.
+date: 2021-02-22 00:00:00.000000000 Z
+dependencies: []
+description: Denote bundle state and (optionally) load bundler/setup according to
+  the configuration.
 email: dimitri@arrigoni.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".yardopts"
+- README.md
 - lib/stibium-bundled.rb
 - lib/stibium/bundled.rb
 - lib/stibium/bundled/bundle.rb
+- lib/stibium/bundled/bundle/config.rb
+- lib/stibium/bundled/bundle/config/reader.rb
+- lib/stibium/bundled/bundle/directory.rb
 - lib/stibium/bundled/version.rb
 - lib/stibium/bundled/version.yml
 homepage: https://github.com/SwagDevOps/stibium-bundled