ocran 1.4.3 → 1.4.5

data/lib/ocran/gem_spec_queryable.rb

@@ -131,8 +131,11 @@ module Ocran
 
     def gem_root = Pathname(gem_dir)
 
-    # Find the selected files
-    def gem_root_files = gem_root.find.select(&:file?)
+    # Find the selected files. Default gems (e.g. fiddle, singleton on
+    # Homebrew or distro-packaged Ruby) may have a gemspec without a
+    # materialized gem directory - their files live in Ruby's stdlib and
+    # are packed via the load path instead.
+    def gem_root_files = gem_root.directory? ? gem_root.find.select(&:file?) : []
 
     def script_files
       gem_root_files.select { |path| path.extname =~ GEM_SCRIPT_RE }
@@ -154,7 +157,25 @@ module Ocran
         when :spec
           files.map { |file| Pathname(file) }
         when :loaded
-          features_from_gems.select { |feature| feature.subpath?(gem_dir) }
+          # Some distros expose gem files under additional paths via symlinks
+          # (e.g. Fedora symlinks /usr/share/ruby/psych.rb into the psych gem
+          # directory) and $LOADED_FEATURES records the symlink path. Resolve
+          # each feature to its realpath so such files count as gem files and
+          # are packed inside the gem directory. Packing them at the symlink
+          # location instead would break require_relative, which resolves
+          # against the realpath on the build host but not in the packed app.
+          features_from_gems.filter_map do |feature|
+            if feature.subpath?(gem_dir)
+              feature
+            else
+              real = begin
+                feature.realpath
+              rescue SystemCallError
+                next
+              end
+              real if real.subpath?(gem_dir)
+            end
+          end
         when :files
           resource_files
         when :extras

data/lib/ocran/inno_setup_script_builder.rb

@@ -14,7 +14,14 @@ module Ocran
 
     class << self
       def compile(iss_filename, quiet: false)
-        unless Gem.win_platform? || system("where #{quote_and_escape(ISCC_CMD)} >NUL 2>&1")
+        # "where" and ">NUL" only exist on Windows; use "command -v" on POSIX
+        # (e.g. when testing the pipeline with a fake ISCC on Linux/macOS).
+        iscc_found = if Gem.win_platform?
+                       true # ISCC is invoked directly; failure is reported below
+                     else
+                       system("command -v #{quote_and_escape(ISCC_CMD)} > /dev/null 2>&1")
+                     end
+        unless iscc_found
           raise "ISCC command not found. Is the InnoSetup directory in your PATH?"
         end
 
@@ -79,6 +86,13 @@ module Ocran
       @dirs.add?("/", target)
     end
 
+    # Symbolic links cannot be expressed in an Inno Setup script. They only
+    # occur when building from POSIX hosts (e.g. libruby.so links); Windows
+    # installations do not need them, so they are skipped.
+    def symlink(_target, _link_name)
+      nil
+    end
+
     def cp(source, target)
       unless File.exist?(source)
         raise "The file does not exist (#{source})"

data/lib/ocran/launcher_event_recorder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ocran
+  # Records launcher-directed build events (environment exports and the
+  # application exec command) while forwarding them to another launcher
+  # builder. The recorded events can later be replayed into a further
+  # builder — e.g. to produce a wrapper stub executable alongside the
+  # launcher batch file in Inno Setup builds.
+  class LauncherEventRecorder
+    def initialize(launcher)
+      @launcher = launcher
+      @events = []
+    end
+
+    def export(name, value)
+      @events << [:export, name, value]
+      @launcher.export(name, value)
+    end
+
+    def exec(image, script, *argv)
+      @events << [:exec, image, script, *argv]
+      @launcher.exec(image, script, *argv)
+    end
+
+    def replay(builder)
+      @events.each { |event, *args| builder.public_send(event, *args) }
+    end
+  end
+end

data/lib/ocran/option.rb

@@ -16,6 +16,10 @@ module Ocran
         :macosx_bundle => nil,
         :macosx_bundle? => false,
         :chdir_before? => false,
+        :chdir_exe_dir? => false,
+        :cosmo_cc => nil,
+        :cosmo_ruby => nil,
+        :cosmo_zip? => false,
         :enable_compression? => true,
         :enable_debug_extract? => false,
         :enable_debug_mode? => false,
@@ -37,6 +41,7 @@ module Ocran
         :source_files => [],
         :verbose? => false,
         :warning? => true,
+        :wrapper_exe? => true,
       }
     end
 
@@ -90,6 +95,8 @@ Output options:
 --output <file>    Name the exe to generate. Defaults to ./<scriptname>.exe.
 --output-dir <dir> Output all files to a directory with a launch script instead of an exe.
 --output-zip <file> Output a zip archive containing all files and a launch script.
+--no-wrapper-exe   Do not add the wrapper executable to installer, directory or
+                   zip output (a launch script is always included there).
 --macosx-bundle    Build a macOS .app bundle. Use --output to name it (default: <scriptname>.app).
 --bundle-id <id>   Bundle identifier for the macOS app bundle (default: com.example.<appname>).
 --no-lzma          Disable LZMA compression of the executable.
@@ -100,13 +107,62 @@ Executable options:
 --windows          Force Windows application (rubyw.exe)
 --console          Force console application (ruby.exe)
 --chdir-first      When exe starts, change working directory to app dir.
+--chdir-exe-dir    When exe starts, change working directory to the directory
+                   containing the executable itself.
 --icon <ico>       Replace icon with a custom one.
---rubyopt <str>    Set the RUBYOPT environment variable when running the executable
+--rubyopt <str>    Set the RUBYOPT environment variable when running the executable.
+                   -I/-r entries with absolute build-machine paths are
+                   translated to their packed locations at build time.
 --debug            Executable will be verbose.
 --debug-extract    Executable will unpack to local dir and not delete after.
+
+Experimental options:
+
+--cosmo-ruby <ruby.com>  Package the given cosmopolitan-built Ruby (an APE,
+                   e.g. ruby.com) as the interpreter instead of the host
+                   Ruby: the result is a single <scriptname>.com that runs
+                   on Linux, Windows and macOS. The APE must be fully
+                   self-contained (stdlib embedded in its ZIP store).
+                   Dependency detection still runs under the host Ruby;
+                   native-extension gems are rejected (pure-Ruby gems are
+                   packed as usual).
+                   When the given interpreter runs an embedded /zip/main.rb
+                   (CosmoRuby builds do), the application is injected into
+                   its ZIP store: no compiler is needed and the executable
+                   starts without unpacking anything. Otherwise OCRAN falls
+                   back to an APE launcher stub that extracts the
+                   application at every start, and locates the cosmocc
+                   toolchain to build that stub automatically (COSMOCC
+                   environment variable, cosmocc in PATH, then conventional
+                   install locations such as ~/.cosmocc/*/bin/cosmocc).
+--cosmo <path>     Use the Cosmopolitan toolchain (cosmocc) at <path> to
+                   build the launcher stub, overriding the automatic
+                   toolchain lookup. <path> is the cosmocc executable or
+                   its install dir. Given together with --cosmo-ruby it
+                   forces the launcher-stub build even when the interpreter
+                   supports ZIP packaging. Given without --cosmo-ruby, it
+                   packages the host Ruby behind an APE stub. Console-only;
+                   output defaults to <scriptname>.com.
+                   (Alias: --cosmo-toolchain)
 EOF
     end
 
+    # Pulls in Ocran::CosmoToolchain for the --cosmo/--cosmo-ruby options.
+    #
+    # Deliberately Kernel#load and not require_relative: OCRAN detects the
+    # application's dependencies by diffing $LOADED_FEATURES around the
+    # dependency run, and the "before" snapshot is taken *before* the command
+    # line is parsed (Runner#initialize). Anything require'd from here would
+    # therefore show up in that diff and be packed into the user's
+    # application - packing OCRAN's own source file with it, and (because the
+    # src prefix is the common parent of all source files) moving the whole
+    # application down into a deeper src/ subdirectory. Kernel#load leaves
+    # $LOADED_FEATURES untouched; the same idiom is used for
+    # refine_pathname.rb above.
+    def load_cosmo_toolchain
+      load File.expand_path("cosmo_toolchain.rb", __dir__) unless defined? CosmoToolchain
+    end
+
     def parse(argv)
       while (arg = argv.shift)
         case arg
@@ -125,6 +181,8 @@ EOF
         when "--output-zip"
           path = argv.shift
           @options[:output_zip] = Pathname.new(path).expand_path if path
+        when "--no-wrapper-exe"
+          @options[:wrapper_exe?] = false
         when "--macosx-bundle"
           @options[:macosx_bundle?] = true
         when "--bundle-id"
@@ -144,12 +202,22 @@ EOF
           @options[:load_autoload?] = false
         when "--chdir-first"
           @options[:chdir_before?] = true
+        when "--chdir-exe-dir"
+          @options[:chdir_exe_dir?] = true
         when "--icon"
           path = argv.shift
           raise "Icon file #{path} not found" unless path && File.exist?(path)
           @options[:icon_filename] = Pathname.new(path).expand_path
         when "--rubyopt"
           @options[:rubyopt] = argv.shift
+        when "--cosmo", "--cosmo-toolchain"
+          # Kept unresolved until validation: resolving here would report
+          # "cosmocc ... is not executable" on a Windows build host, ahead of
+          # the clearer "not supported when building on Windows" check.
+          @options[:cosmo_cc] = argv.shift
+        when "--cosmo-ruby"
+          load_cosmo_toolchain
+          @options[:cosmo_ruby] = CosmoToolchain.resolve_ruby(argv.shift)
         when "--gemfile"
           path = argv.shift
           raise "Gemfile #{path} not found" unless path && File.exist?(path)
@@ -214,8 +282,15 @@ EOF
           executable = script
           # If debug mode is enabled, append "-debug" to the filename
           executable = executable.append_to_filename("-debug") if enable_debug_mode?
-          # Build output files are created in the current directory
-          ext = Gem.win_platform? ? ".exe" : ""
+          # Build output files are created in the current directory.
+          # APE binaries built with cosmocc conventionally use .com.
+          ext = if cosmo?
+                  ".com"
+                elsif Gem.win_platform?
+                  ".exe"
+                else
+                  ""
+                end
           executable.basename.sub_ext(ext).expand_path
         end
 
@@ -224,6 +299,10 @@ EOF
         @options[:macosx_bundle] = Pathname(bundle_base).sub_ext(".app").expand_path
       end
 
+      if chdir_before? && chdir_exe_dir?
+        raise "--chdir-first and --chdir-exe-dir cannot be used together"
+      end
+
       @options[:use_inno_setup?] = !!inno_setup_script
 
       @options[:verbose?] &&= !quiet?
@@ -248,6 +327,41 @@ EOF
         raise "--output-dir and --output-zip cannot be used together"
       end
 
+      if cosmo?
+        opt = cosmo_cc ? "--cosmo" : "--cosmo-ruby"
+
+        if Gem.win_platform?
+          raise "#{opt} is not supported when building on Windows (build the APE package on a Linux/macOS host)"
+        end
+
+        if force_windows?
+          raise "--windows cannot be used with #{opt}: cosmocc has no GUI (stubw) equivalent; APE stubs are console-only"
+        end
+
+        load_cosmo_toolchain
+
+        # A cosmopolitan Ruby that runs an embedded /zip/main.rb can carry
+        # the application inside its own ZIP store, which needs no compiler
+        # and no launcher stub at all - so that is what --cosmo-ruby does
+        # on its own. Naming a toolchain with --cosmo is the way to ask for
+        # the launcher stub explicitly; the other output formats
+        # (--output-dir, --output-zip, --innosetup, --macosx-bundle) are
+        # directory layouts rather than a single binary, so they keep using
+        # it too.
+        @options[:cosmo_zip?] =
+          !!cosmo_ruby && !cosmo_cc && !single_binary_output_conflict &&
+          CosmoToolchain.zip_main_support?(cosmo_ruby)
+
+        unless cosmo_zip?
+          # The APE stub is compiled with cosmocc. --cosmo names that
+          # toolchain explicitly; otherwise it is discovered on the build
+          # host (COSMOCC, PATH, conventional install locations), so one
+          # option is still enough. Resolved here, before the dependency
+          # run, so a missing toolchain fails fast.
+          @options[:cosmo_cc] = CosmoToolchain.require_cc(cosmo_cc)
+        end
+      end
+
       if macosx_bundle && (output_dir || output_zip || inno_setup_script)
         raise "--macosx-bundle cannot be combined with --output-dir, --output-zip, or --innosetup"
       end
@@ -267,6 +381,29 @@ EOF
 
     def chdir_before? = @options[__method__]
 
+    def chdir_exe_dir? = @options[__method__]
+    def cosmo_cc = @options[__method__]
+
+    def cosmo_ruby = @options[__method__]
+
+    # True when the application is packaged by injecting it into the ZIP
+    # store of the cosmopolitan Ruby itself: no cosmocc, no launcher stub,
+    # and no extraction to a temporary directory at run time.
+    def cosmo_zip? = @options[__method__]
+
+    # Output formats that are not a single self-contained binary, and
+    # therefore cannot be produced by injecting into the interpreter.
+    def single_binary_output_conflict
+      output_dir || output_zip || inno_setup_script || @options[:macosx_bundle?]
+    end
+    private :single_binary_output_conflict
+
+    # True when the build produces an APE (Actually Portable Executable),
+    # i.e. an APE launcher stub is used: an explicit toolchain (--cosmo), a
+    # cosmopolitan Ruby payload (--cosmo-ruby, whose toolchain is inferred),
+    # or both.
+    def cosmo? = !!(cosmo_cc || cosmo_ruby)
+
     def enable_compression? = @options[__method__]
 
     def enable_debug_extract? = @options[__method__]
@@ -301,12 +438,44 @@ EOF
 
     def quiet? = @options[__method__]
 
+    def wrapper_exe? = @options[__method__]
+
     def rubyopt = @options[__method__]
 
     def run_script? = @options[__method__]
 
     def script = @options[__method__]
 
+    # The names Bundler accepts for a Gemfile, most common first.
+    GEMFILE_NAMES = %w[Gemfile gems.rb].freeze
+    private_constant :GEMFILE_NAMES
+
+    # The Gemfile the application runs under: the one named by --gemfile,
+    # or else the nearest Gemfile at or above the script's directory, which
+    # is where Bundler itself would look. Returns nil when the application
+    # has no Gemfile at all.
+    #
+    # This is how the application's own bundle is told apart from whatever
+    # bundle OCRAN happens to have been started under. Running
+    # `bundle exec ocran app.rb` from the application's own directory is the
+    # ordinary case, and there the two are the same file; packaging some
+    # other project from inside this one's bundle is not.
+    def application_gemfile
+      return gemfile if gemfile
+
+      dir = script.expand_path.dirname
+      loop do
+        GEMFILE_NAMES.each do |name|
+          candidate = dir + name
+          return candidate if candidate.file?
+        end
+        parent = dir.parent
+        return nil if parent == dir
+
+        dir = parent
+      end
+    end
+
     def source_files = @options[__method__]
 
     def use_inno_setup? = @options[__method__]

data/lib/ocran/rubyopt_processor.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Ocran
+  # Parses the RUBYOPT environment variable the way Ruby itself does
+  # (whitespace-separated words; -I and -r may take their argument either
+  # attached or as the following word) and translates -I/-r entries that
+  # refer to absolute build-machine paths into their locations inside the
+  # packed application.
+  #
+  # Translated entries cannot simply be rewritten inside RUBYOPT: the
+  # extraction directory is only known at runtime and may contain spaces,
+  # and Ruby does not support any form of quoting in RUBYOPT. The
+  # translated entries are therefore removed from RUBYOPT and returned
+  # separately so that the build can apply them through a generated
+  # launcher script instead. See GitHub issue #20.
+  class RubyoptProcessor
+    # -r entries whose feature path matches this pattern are always removed.
+    # When building under `bundle exec` (Ruby 3.2+), Bundler injects
+    # `-r<absolute path>/bundler/setup` into RUBYOPT; requiring it inside
+    # the packed application would make Bundler look for the build
+    # machine's Gemfile, so it must not survive into the executable.
+    BUNDLER_SETUP_PATTERN = %r{/bundler/setup\z}
+
+    # rubyopt:    the RUBYOPT string with all translated/removed entries
+    #             stripped; safe to bake into the executable as-is.
+    # load_paths: packed locations (relative to the extraction root) for
+    #             translated -I entries, in the order given.
+    # requires:   packed locations (relative to the extraction root) for
+    #             translated -r entries, in the order given.
+    # dropped:    -I/-r entries with absolute paths that are not part of
+    #             the package; they cannot work at runtime and were removed.
+    Result = Struct.new(:rubyopt, :load_paths, :requires, :dropped) do
+      def translated?
+        !load_paths.empty? || !requires.empty?
+      end
+    end
+
+    def initialize(rubyopt)
+      @rubyopt = rubyopt.to_s
+    end
+
+    # Translates absolute -I/-r paths. For each absolute path the block is
+    # called with the path (String) and must return the corresponding
+    # location inside the packed application (relative to the extraction
+    # root), or nil when the path is not part of the package.
+    def translate
+      remaining, load_paths, requires, dropped = [], [], [], []
+
+      words = @rubyopt.split
+      until words.empty?
+        word = words.shift
+        case word
+        when /\A-I(.*)\z/m
+          arg = $1.empty? ? words.shift : $1
+          next if arg.nil?
+
+          kept = []
+          arg.split(File::PATH_SEPARATOR).each do |dir|
+            next if dir.empty?
+
+            if File.absolute_path?(dir)
+              if (packed = yield(dir))
+                load_paths << packed
+              else
+                dropped << "-I#{dir}"
+              end
+            else
+              kept << dir
+            end
+          end
+          remaining << "-I#{kept.join(File::PATH_SEPARATOR)}" unless kept.empty?
+        when /\A-r(.*)\z/m
+          feature = $1.empty? ? words.shift : $1
+          next if feature.nil?
+
+          if feature.match?(BUNDLER_SETUP_PATTERN)
+            # Silently stripped, see BUNDLER_SETUP_PATTERN above.
+          elsif File.absolute_path?(feature)
+            if (packed = yield(feature))
+              requires << packed
+            else
+              dropped << "-r#{feature}"
+            end
+          else
+            remaining << "-r#{feature}"
+          end
+        else
+          remaining << word
+        end
+      end
+
+      Result.new(remaining.join(" "), load_paths, requires, dropped)
+    end
+  end
+end

data/lib/ocran/runner.rb

@@ -44,10 +44,88 @@ module Ocran
       end
 
       exit unless @option.run_script?
+      if @option.gemfile
+        apply_gemfile_to_bundler_env
+      else
+        warn_about_foreign_bundle
+      end
       say "Loading script to check dependencies"
       $PROGRAM_NAME = @option.script.to_s
     end
 
+    # --gemfile names the Gemfile the application runs under, so it has to
+    # govern the dependency run as well, not just the later Gemfile scan.
+    # The script is loaded in this very process, and a BUNDLE_GEMFILE
+    # inherited from the environment would otherwise win: invoke OCRAN from
+    # inside another project's `bundle exec` and the script's
+    # `require "bundler/setup"` sets up that project's bundle instead of the
+    # application's. Gems only the application's Gemfile provides are then
+    # missing, and local development gems declared with `path:` or `gemspec`
+    # always are, since they exist nowhere else. The dependency run dies with
+    # a LoadError before anything can be packed (github issue #34).
+    def apply_gemfile_to_bundler_env
+      gemfile = @option.gemfile.to_s
+      active = active_bundler_gemfile
+
+      ENV["BUNDLE_GEMFILE"] = gemfile
+      return if active.nil? || same_file?(active, gemfile)
+
+      # Past this point the ambient bundle is a different one, so anything
+      # else describing it has to go: BUNDLE_LOCKFILE names the lockfile of
+      # the bundle being displaced, and Bundler would sooner believe it than
+      # the Gemfile we just pointed it at.
+      ENV.delete("BUNDLE_LOCKFILE")
+      return unless defined?(Bundler) && Bundler.respond_to?(:reset!)
+
+      # `bundle exec` puts -rbundler/setup in RUBYOPT as well, so the wrong
+      # bundle may already be set up by the time this runs. The variable
+      # alone is then too late: bundler/setup sits in $LOADED_FEATURES, and
+      # the script's own `require "bundler/setup"` would be a no-op. Drop
+      # Bundler's memoized state and let it be set up afresh, against the
+      # Gemfile we were given.
+      verbose "Rebinding Bundler from #{active} to #{gemfile}"
+      Bundler.reset!
+      $LOADED_FEATURES.delete_if { |feature| feature.match?(RuntimeEnvironment::BUNDLER_SETUP_FEATURE) }
+    end
+
+    # Without --gemfile the dependency run inherits whatever bundle the
+    # environment carries, and when that is some other project's bundle the
+    # script's own gems are simply absent. The failure that follows is a
+    # LoadError from deep inside the script, which says nothing about the
+    # bundle being the wrong one, so say it here while the reason is still
+    # visible.
+    def warn_about_foreign_bundle
+      # Only when a bundle really is set up. BUNDLE_GEMFILE alone is
+      # inherited by any child process and governs nothing on its own.
+      return unless @pre_env.bundler_setup_loaded?
+
+      active = active_bundler_gemfile
+      return if active.nil? || active.empty?
+
+      app_gemfile = @option.application_gemfile
+      return if app_gemfile && same_file?(active, app_gemfile)
+
+      warning "Running under Bundler with #{active}, which is not the Gemfile " \
+              "#{@option.script} runs under" +
+              (app_gemfile ? "; pass --gemfile #{app_gemfile} to package against that bundle" : "")
+    end
+
+    # The Gemfile this process was started against, if any.
+    def active_bundler_gemfile
+      return ENV["BUNDLE_GEMFILE"] unless ENV["BUNDLE_GEMFILE"].to_s.empty?
+      return nil unless defined?(Bundler) && Bundler.respond_to?(:default_gemfile)
+
+      Bundler.default_gemfile.to_s
+    rescue StandardError
+      # Bundler raises when there is no Gemfile anywhere above the working
+      # directory, which just means there is no ambient bundle to displace.
+      nil
+    end
+
+    def same_file?(a, b)
+      File.identical?(a, b) || File.expand_path(a) == File.expand_path(b)
+    end
+
     # Force loading autoloaded constants. Searches through all modules
     # (and hence classes), and checks their constants for autoloaded
     # ones, then attempts to load them.
@@ -94,10 +172,12 @@ module Ocran
       direction = Direction.new(@post_env, @pre_env, @option)
 
       if @option.use_inno_setup?
-        if Gem.win_platform?
+        # Native on Windows; on POSIX allow it when an ISCC command is
+        # available (e.g. via Wine wrapper scripts or in tests).
+        if Gem.win_platform? || system("command -v ISCC > /dev/null 2>&1")
           direction.build_inno_setup_installer
         else
-          raise "Inno Setup is only supported on Windows"
+          raise "Inno Setup is only supported on Windows (no ISCC command found in PATH)"
         end
       elsif @option.macosx_bundle
         direction.build_macosx_bundle(@option.macosx_bundle)
@@ -105,6 +185,8 @@ module Ocran
         direction.build_output_dir(@option.output_dir)
       elsif @option.output_zip
         direction.build_zip(@option.output_zip)
+      elsif @option.cosmo_zip?
+        direction.build_cosmo_zip_exe
       else
         direction.build_stab_exe
       end

data/lib/ocran/runtime_environment.rb

@@ -10,13 +10,31 @@ module Ocran
       alias save new
     end
 
-    attr_reader :env, :load_path, :loaded_features, :pwd
+    # Matches the bundler/setup feature by which `bundle exec` sets a
+    # process up, whatever prefix the bundler gem happens to be installed
+    # under.
+    BUNDLER_SETUP_FEATURE = %r{[\\/]bundler[\\/]setup\.rb\z}
+
+    attr_reader :env, :load_path, :loaded_features, :pwd, :activated_gems
 
     def initialize
       @env = ENV.to_hash.freeze
       @load_path = $LOAD_PATH.dup.freeze
       @loaded_features = $LOADED_FEATURES.dup.freeze
       @pwd = Dir.pwd.freeze
+      # The gems RubyGems had activated at this point. Under `bundle exec`
+      # that is the entire bundle, activated before OCRAN's first line runs,
+      # so a snapshot taken before the dependency run is what tells the build
+      # environment's gems apart from the application's.
+      @activated_gems = (defined?(Gem) ? Gem.loaded_specs.keys : []).freeze
+    end
+
+    # Whether Bundler had already set this process up when the snapshot was
+    # taken. `bundle exec` arranges that through RUBYOPT (and, with newer
+    # RubyGems, through the BUNDLER_SETUP variable), so bundler/setup is in
+    # $LOADED_FEATURES before the command it runs gets to say anything.
+    def bundler_setup_loaded?
+      @loaded_features.any? { |feature| feature.to_s.match?(BUNDLER_SETUP_FEATURE) }
     end
 
     # Expands the given path using the working directory stored in this