ocran 1.4.4 → 1.4.6

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,
@@ -103,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
@@ -149,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,13 +277,28 @@ EOF
 
       @options[:output_executable] =
         if output_override
-          output_override
+          # Windows runs a program only by its extension, so a name given
+          # without .exe - `--output myapp`, as a build script shared with
+          # Linux and macOS writes it - gets one there. .exe and .com names
+          # are used as given.
+          if Gem.win_platform? && !output_override.extname?(".exe") && !output_override.extname?(".com")
+            Pathname("#{output_override}.exe")
+          else
+            output_override
+          end
         else
           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
 
@@ -229,6 +307,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?
@@ -253,6 +335,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
@@ -272,6 +389,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__]
@@ -314,6 +454,36 @@ EOF
 
     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,141 @@ module Ocran
       end
 
       exit unless @option.run_script?
+      if @option.gemfile
+        apply_gemfile_to_bundler_env
+      else
+        warn_about_foreign_bundle
+      end
+      expose_bundle_install_path
       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
+
+    # `bundle install` puts the gems where Bundler is configured to put them,
+    # and a configured path - `bundle config set path vendor/bundle`, which is
+    # what ruby/setup-ruby's `bundler-cache: true` does - is a place only
+    # Bundler looks. The dependency run loads the script as plain Ruby, so
+    # its first `require` of a gem from such a bundle raised LoadError
+    # although the bundle was installed (github issue #61).
+    #
+    # Add the bundle's install directory to the gem path. Its gems become
+    # visible exactly as if they had been installed into Ruby's own gem
+    # directory, and nothing more: setting the bundle up would also hide
+    # every gem the Gemfile does not list, breaking scripts that work today.
+    # A bundle installed into the system gems, the ordinary case outside CI,
+    # changes nothing, and under `bundle exec` Bundler has already put its
+    # gems on the gem path.
+    def expose_bundle_install_path
+      return if @pre_env.bundler_setup_loaded?
+
+      gemfile = @option.application_gemfile or return
+      path = bundle_install_path(gemfile) or return
+      return if Gem.path.any? { |gem_path| same_file?(gem_path, path) }
+
+      verbose "Adding #{path}, where the bundle of #{gemfile} is installed, to the gem path"
+      Gem.paths = { "GEM_HOME" => Gem.dir, "GEM_PATH" => (Gem.path + [path]).join(File::PATH_SEPARATOR) }
+    end
+
+    # Ruby run in a child process to print where Bundler installs the bundle
+    # of BUNDLE_GEMFILE, or nothing when that is the system gems.
+    BUNDLE_PATH_QUERY = <<~RUBY
+      require "bundler"
+      print Bundler.bundle_path unless Bundler.configured_bundle_path.use_system_gems?
+    RUBY
+    private_constant :BUNDLE_PATH_QUERY
+
+    # The directory the bundle of the given Gemfile is installed into when
+    # that is not the system gems, or nil. Bundler decides it from its
+    # settings - .bundle/config beside the Gemfile, the user's configuration
+    # and BUNDLE_* variables - without evaluating the Gemfile.
+    #
+    # Asked in a child process: loading Bundler here, before the dependency
+    # run, would put Bundler's files among the script's loaded features and
+    # pack them into every application with a Gemfile.
+    def bundle_install_path(gemfile)
+      env = { "BUNDLE_GEMFILE" => gemfile.to_s, "RUBYOPT" => nil, "BUNDLER_SETUP" => nil }
+      path = IO.popen(env, [RbConfig.ruby, "-e", BUNDLE_PATH_QUERY], err: File::NULL, &:read)
+      return nil unless $?.success? && !path.empty? && File.directory?(path)
+
+      path
+    rescue SystemCallError => e
+      verbose "Could not ask Bundler where the bundle of #{gemfile} is installed: #{e.message}"
+      nil
+    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.
@@ -107,6 +238,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,39 @@ 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, :loaded_specs
 
     def initialize
       @env = ENV.to_hash.freeze
       @load_path = $LOAD_PATH.dup.freeze
       @loaded_features = $LOADED_FEATURES.dup.freeze
       @pwd = Dir.pwd.freeze
+      # The specs of the gems RubyGems had activated at this point. Taken
+      # with the loaded features for the same reason: OCRAN goes on to
+      # activate gems of its own while it builds (fiddle for DLL detection,
+      # tempfile for the builder, ...), and those are not the application's.
+      # Under `bundle exec` the snapshot taken before the dependency run is
+      # the entire bundle, activated before OCRAN's first line runs, which is
+      # what tells the build environment's gems apart from the application's.
+      @loaded_specs = (defined?(Gem) ? Gem.loaded_specs.values : []).freeze
+    end
+
+    # The names of the gems in #loaded_specs.
+    def activated_gems
+      @loaded_specs.map(&:name)
+    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

data/lib/ocran/stub_builder.rb

@@ -21,6 +21,7 @@ module Ocran
     CHDIR_BEFORE_SCRIPT = 0x08
     DATA_COMPRESSED     = 0x10
     RUN_IN_EXE_DIR      = 0x20
+    CHDIR_TO_EXE_DIR    = 0x40
 
     WINDOWS = Gem.win_platform?
 
@@ -77,6 +78,12 @@ module Ocran
     # When set to true, the working directory is changed to the application's
     # deployment location at runtime.
     #
+    # chdir_to_exe_dir:
+    # When set to true, the working directory is changed to the directory
+    # containing the (stub) executable before the script starts. This makes
+    # relative file access resolve next to the executable regardless of how
+    # it was invoked. Mutually exclusive with chdir_before.
+    #
     # debug_mode:
     # When the debug_mode option is set to true, the stub will output debug information
     # when the exe file is executed. Debug mode can also be enabled within the directive
@@ -103,9 +110,16 @@ module Ocran
     # are installed next to the stub (pre-1.4/OCRA behavior). The directory
     # is never deleted on exit.
     #
-    def initialize(path, chdir_before: nil, debug_extract: nil, debug_mode: nil,
+    # stub_path:
+    # Path to a stub binary to package with instead of the pre-built
+    # stub shipped with the gem (e.g. an APE stub freshly compiled with
+    # cosmocc, see --cosmo). When set, it takes precedence over both
+    # STUB_PATH and STUBW_PATH.
+    #
+    def initialize(path, chdir_before: nil, chdir_to_exe_dir: nil,
+                   debug_extract: nil, debug_mode: nil,
                    enable_compression: nil, gui_mode: nil, icon_path: nil,
-                   run_in_exe_dir: nil)
+                   run_in_exe_dir: nil, stub_path: nil)
       @dirs = FilePathSet.new
       @files = FilePathSet.new
       @data_size = 0
@@ -117,7 +131,9 @@ module Ocran
       output_dir = File.dirname(path)
       FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
       stub_tmp = File.join(output_dir, ".ocran_stub_#{$$}_#{Time.now.to_i}")
-      stub_src = if gui_mode && WINDOWS
+      stub_src = if stub_path
+                   stub_path
+                 elsif gui_mode && WINDOWS
                    STUBW_PATH
                  else
                    STUB_PATH
@@ -138,7 +154,7 @@ module Ocran
         @of = of
         @opcode_offset = @of.size
 
-        write_header(debug_mode, debug_extract, chdir_before, enable_compression, run_in_exe_dir)
+        write_header(debug_mode, debug_extract, chdir_before, enable_compression, run_in_exe_dir, chdir_to_exe_dir)
 
         b = proc {
           yield(self)
@@ -222,7 +238,7 @@ module Ocran
     end
     private :compress
 
-    def write_header(debug_mode, debug_extract, chdir_before, compressed, run_in_exe_dir = nil)
+    def write_header(debug_mode, debug_extract, chdir_before, compressed, run_in_exe_dir = nil, chdir_to_exe_dir = nil)
       next_to_exe, delete_after = debug_extract, !debug_extract
       if run_in_exe_dir
         # Wrapper mode: run in place next to the executable — never extract,
@@ -235,7 +251,8 @@ module Ocran
                 (delete_after ? AUTO_CLEAN_INST_DIR : 0) |
                 (chdir_before ? CHDIR_BEFORE_SCRIPT : 0) |
                 (compressed ? DATA_COMPRESSED : 0) |
-                (run_in_exe_dir ? RUN_IN_EXE_DIR : 0)
+                (run_in_exe_dir ? RUN_IN_EXE_DIR : 0) |
+                (chdir_to_exe_dir ? CHDIR_TO_EXE_DIR : 0)
       ].pack("C")
     end
     private :write_header

data/lib/ocran/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ocran
-  VERSION = "1.4.4"
+  VERSION = "1.4.6"
 end