stibium-bundled 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4535c1eb06c410ecd9acbe69eb8b63f580a6d6ed549f9cb9902d1c31dfe8514f
-  data.tar.gz: b1c0044292d53365cc0a8f8328f9622ee55a15fae64b5b98fedcb910978c2225
+  metadata.gz: 63124b549081f71ec8962a7ce60a2d7309cc8a288123744c378e3a504460328d
+  data.tar.gz: 3002be752eca5c11fb5102d1a3db9374c9cd89535507f27f92154a304a13414b
 SHA512:
-  metadata.gz: 50530881617d8161a2ade6ccc269a54a0b3a1aa9ed95158eeba0c5b6ee80160037ac7b309d37c9bb8b3e11019dd5f84c8b41a7cae4ee560be93f1aa3848ddb1f
-  data.tar.gz: 3db4a5036224344e1d9c03a0433075758fbbbe43230b5a4e7fa3260c9c38151c2c9abb53271cb06535f02636836d6560e18f110da56669af44b3ee9f7bf6527c
+  metadata.gz: 4503ed903e66d57c352ba2377d127b20485dbf24d761a32571f1775b4c86b864be1142e15ee8ec883909b6fb9b19a18ee204e78ccf13ba0d7eb65b2cfcc9ec91
+  data.tar.gz: c8c6f97330f328d35c902b4818a90d68dabf53178fc46e3df1fab2acfd077f9a741ce3d8a82ef3f953cd6fff67c4306e66e68973165f92cad3582ea7dcad5f5b

data/README.md

@@ -0,0 +1,78 @@
+# ``stibium-bundled`` [![Gem Version](https://badge.fury.io/rb/stibium-bundled.svg)][rubygems:stibium-bundled]
+
+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
+```
+
+## 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

data/lib/stibium/bundled.rb

@@ -17,69 +17,83 @@ 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
+
+    # 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
+
+  # Denote bundle is locked or standalone.
+  #
+  # @return [Boolean]
+  #
+  # @see .call
+  def bundled?
+    false
+  end
+
+  # @return [Bundle, nil]
+  #
+  # @see .call
+  def bundled
+    nil
+  end
 
-  # @!method bundled
-  #   @return [Bundle, nil]
+  protected
 
-  # @param [String, Pathname] basedir
+  # @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|
+      unless bundle.nil?
+        bundle.__send__(:setup, **(setup.is_a?(Array) ? { guards: setup } : {})) if setup
+
+        yield(bundle) if block_given?
+      end
+    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: {})
       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
+            Bundle.new(basedir, env: env, ruby_config: ruby_config)
+                  .yield_self { |bundle| bundle.bundled? ? bundle : nil }
           end
         end
       end

data/lib/stibium/bundled/bundle.rb

@@ -11,19 +11,39 @@ 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).tap do |config|
+        Pathname.new(config.fetch('BUNDLE_PATH')).expand_path.tap do |directory_path|
+          @directory = Directory.new(directory_path, ruby_config: ruby_config)
+        end
+      end
     end.freeze
   end
 
@@ -41,6 +61,29 @@ class Stibium::Bundled::Bundle
     !!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) }
+  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.
   #
   # @see #gemfiles
@@ -67,23 +110,68 @@ class Stibium::Bundled::Bundle
   #
   # @return [Boolean]
   def standalone?
-    standalone_setupfile.file?
+    !!bundler_setup
   end
 
-  # Load standalone setup if present
+  protected
+
+  # Load standalone setup if present.
   #
-  # @return [Boolean]
-  def standalone!
-    # noinspection RubyResolve
-    standalone?.tap { |b| require standalone_setupfile if b }
+  # @return [self]
+  #
+  # @raise [Errno::ENOENT]
+  def standalone!(&fallback)
+    self.tap do
+      # noinspection RubyResolve
+      bundler_setup.tap { |fp| require(fp.realpath) unless fp.nil? }
+    rescue Errno::ENOENT => e
+      fallback ? fallback.call(self) : raise(e)
+    end
   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: [:locked, :installed])
+    self.standalone! do
+      guards.map { |s| self.public_send('%s?' % s.to_s.gsub(/\?$/, '')) }.tap do |results|
+        require 'bundler/setup' if results.uniq == [true]
+      end
+    end.yield_self { self }
+  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')
+  # @return [Pathname, nil]
+  def bundler_setup
+    Pathname.new(config.fetch('BUNDLE_PATH')).yield_self do |bundle_path|
+      (bundle_path.absolute? ? bundle_path : path.join(bundle_path)).join('bundler/setup.rb').yield_self do |file|
+        (file.file? and file.readable?) ? file : nil # rubocop:disable Style/TernaryParentheses
+      end
+    end
   end
 end

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

@@ -0,0 +1,154 @@
+# 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')
+
+  # @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
+    autoload(:Pathname, 'pathname')
+    autoload(:YAML, 'yaml')
+
+    # 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 do |file|
+          self.read(file, env: env)
+        end
+      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)
+      return {} if env(source: env).key?('BUNDLE_IGNORE_CONFIG')
+
+      return {} unless file.file? and file.readable?
+
+      (file.read.yield_self { |content| YAML.safe_load(content) })
+        .transform_values { |v| v.is_a?(String) ? YAML.safe_load(v) : v }
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# 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'].yield_self do |parts|
+      self.path.join(*parts).yield_self do |s|
+        Dir.glob(s).sort.map { |fp| Pathname.new(fp) }.keep_if(&:file?)
+      end
+    end
+  end
+
+  protected
+
+  # @return [Hash{Symbol => Object}]
+  attr_reader :ruby_config
+end

data/lib/stibium/bundled/version.rb

@@ -9,9 +9,6 @@
 require_relative '../bundled'
 require 'kamaze/version'
 
-module Stibium::Bundled
-  # Version
-  #
-  # @type [Kamaze::Version]
-  VERSION = Kamaze::Version.new.freeze
+Stibium::Bundled.instance_eval do
+  self.const_set(:VERSION, Kamaze::Version.new.freeze)
 end

data/lib/stibium/bundled/version.yml

@@ -1,10 +1,10 @@
 ---
 major: 0
 minor: 0
-patch: 2
+patch: 3
 authors: ['Dimitri Arrigoni']
 email: 'dimitri@arrigoni.me'
-date: '2021-01-11'
+date: '2021-01-22'
 summary: 'Denote bundle state'
 description: 'Denote bundle state, based on conventions.'
 homepage: 'https://github.com/SwagDevOps/stibium-bundled'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stibium-bundled
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Dimitri Arrigoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-11 00:00:00.000000000 Z
+date: 2021-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kamaze-version
@@ -31,9 +31,12 @@ 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/directory.rb
 - lib/stibium/bundled/version.rb
 - lib/stibium/bundled/version.yml
 homepage: https://github.com/SwagDevOps/stibium-bundled