ocran 1.3.15 → 1.3.17

data/lib/ocran/runner.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+load File.expand_path("../ocran.rb", __dir__)
+
+module Ocran
+  class Runner
+    load File.expand_path("command_output.rb", __dir__)
+    include CommandOutput
+
+    def fatal_error(statement)
+      error statement
+      exit false
+    end
+
+    def initialize
+      load File.expand_path("runtime_environment.rb", __dir__)
+      @pre_env = RuntimeEnvironment.save
+
+      load File.expand_path("option.rb", __dir__)
+      @option = Option.new.tap do |opt|
+        opt.parse(ARGV)
+      rescue RuntimeError => e
+        # Capture RuntimeError during parsing and display an appropriate
+        # error message to the user. This error usually occurs from invalid
+        # option arguments.
+        fatal_error e.message
+      else
+        # Update ARGV with the parsed command line arguments to pass to
+        # the user's script. This ensures the script executes based on
+        # the user-specified arguments.
+        ARGV.replace(opt.argv)
+      end
+
+      Ocran.option = @option
+
+      @ignore_modules = ObjectSpace.each_object(Module).to_a
+    end
+
+    def run
+      at_exit do
+        if $!.nil? or $!.kind_of?(SystemExit)
+          build
+          exit
+        end
+      end
+
+      exit unless @option.run_script?
+      say "Loading script to check dependencies"
+      $PROGRAM_NAME = @option.script.to_s
+    end
+
+    # Force loading autoloaded constants. Searches through all modules
+    # (and hence classes), and checks their constants for autoloaded
+    # ones, then attempts to load them.
+    def attempt_load_autoload(ignore_modules = [])
+      checked_modules = ignore_modules.inject({}) { |h, mod| h[mod] = true; h }
+      while ObjectSpace.each_object(Module).count { |mod|
+        next if checked_modules.include?(mod)
+        mod.constants.each do |const|
+          next unless mod.autoload?(const)
+          say "Attempting to trigger autoload of #{mod}::#{const}"
+          begin
+            mod.const_get(const)
+          rescue ScriptError, StandardError => e
+            # Some autoload constants may throw exceptions beyond the expected
+            # errors. This includes issues dependent on the system or execution
+            # environment, so it is preferable to ignore exceptions other than
+            # critical errors.
+            warning "#{mod}::#{const} loading failed: #{e.message}"
+          end
+        end
+        checked_modules[mod] = true
+      }.nonzero?
+        # Loops until all constants have been checked.
+      end
+    end
+
+    def build
+      # If the script was run and autoload is enabled, attempt to autoload libraries.
+      if @option.force_autoload?
+        attempt_load_autoload(@ignore_modules)
+      end
+
+      @post_env = RuntimeEnvironment.save
+      # NOTE: From this point, $LOADED_FEATURES has been captured, so it is now
+      # safe to call require_relative.
+
+      ENV.replace(@pre_env.env)
+
+      # It might be useful to reset the current directory to the point where the
+      # command was launched, especially when implementing the builder object.
+      Dir.chdir(@pre_env.pwd)
+
+      require_relative "direction"
+      direction = Direction.new(@post_env, @pre_env, @option)
+
+      if @option.use_inno_setup?
+        direction.build_inno_setup_installer
+      else
+        direction.build_stab_exe
+      end
+    rescue RuntimeError => e
+      fatal_error e.message
+    end
+  end
+end

data/lib/ocran/runtime_environment.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "pathname"
+
+module Ocran
+  load File.expand_path("refine_pathname.rb", __dir__) unless defined? RefinePathname
+  using RefinePathname
+
+  class RuntimeEnvironment
+    class << self
+      alias save new
+    end
+
+    attr_reader :env, :load_path, :loaded_features, :pwd
+
+    def initialize
+      @env = ENV.to_hash.freeze
+      @load_path = $LOAD_PATH.dup.freeze
+      @loaded_features = $LOADED_FEATURES.dup.freeze
+      @pwd = Dir.pwd.freeze
+    end
+
+    # Expands the given path using the working directory stored in this
+    # instance as the base. This method resolves relative paths to
+    # absolute paths, ensuring they are fully qualified based on the
+    # working directory stored within this instance.
+    def expand_path(path)
+      File.expand_path(path, @pwd)
+    end
+
+    def find_load_path(path)
+      path = Pathname.new(path) unless path.is_a?(Pathname)
+
+      if path.absolute?
+        # For an absolute path feature, find the load path that contains the feature
+        # and determine the longest matching path (most specific path).
+        @load_path.select { |load_path| path.subpath?(expand_path(load_path)) }
+                  .max_by { |load_path| expand_path(load_path).length }
+      else
+        # For a relative path feature, find the load path where the expanded feature exists
+        # and select the longest load path (most specific path).
+        @load_path.select { |load_path| path.expand_path(load_path).exist? }
+                  .max_by { |load_path| load_path.length }
+      end
+    end
+  end
+end

data/lib/ocran/stub_builder.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+require "tempfile"
+require_relative "file_path_set"
+
+module Ocran
+  # Utility class that produces the actual executable. Opcodes
+  # (create_file, mkdir etc) are added by invoking methods on an
+  # instance of OcranBuilder.
+  class StubBuilder
+    Signature = [0x41, 0xb6, 0xba, 0x4e].freeze
+    OP_END = 0
+    OP_CREATE_DIRECTORY = 1
+    OP_CREATE_FILE = 2
+    OP_SETENV = 3
+    OP_SET_SCRIPT = 4
+
+    DEBUG_MODE          = 0x01
+    EXTRACT_TO_EXE_DIR  = 0x02
+    AUTO_CLEAN_INST_DIR = 0x04
+    CHDIR_BEFORE_SCRIPT = 0x08
+    DATA_COMPRESSED     = 0x10
+
+    base_dir = File.expand_path("../../share/ocran", File.dirname(__FILE__))
+    STUB_PATH = File.expand_path("stub.exe", base_dir)
+    STUBW_PATH = File.expand_path("stubw.exe", base_dir)
+    LZMA_PATH = File.expand_path("lzma.exe", base_dir)
+    EDICON_PATH = File.expand_path("edicon.exe", base_dir)
+
+    attr_reader :data_size
+
+    # chdir_before:
+    # When set to true, the working directory is changed to the application's
+    # deployment location at runtime.
+    #
+    # 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
+    # code using the enable_debug_mode method. This option is provided to transition to
+    # debug mode from the initialization point of the stub.
+    #
+    # debug_extract:
+    # When set to true, the runtime file is extracted to the directory where the executable resides,
+    # and the extracted files remain even after the application exits.
+    # When set to false, the runtime file is extracted to the system's temporary directory,
+    # and the extracted files are deleted after the application exits.
+    #
+    # gui_mode:
+    # When set to true, the stub does not display a console window at startup. Errors are shown in a dialog window.
+    # When set to false, the stub reports errors through the console window.
+    #
+    # icon_path:
+    # Specifies the path to the icon file to be embedded in the stub's resources.
+    #
+    def initialize(path, chdir_before: nil, debug_extract: nil, debug_mode: nil,
+                   enable_compression: nil, gui_mode: nil, icon_path: nil)
+      @dirs = FilePathSet.new
+      @files = FilePathSet.new
+      @data_size = 0
+
+      if icon_path && !File.exist?(icon_path)
+        raise "Icon file #{icon_path} not found"
+      end
+
+      stub = Tempfile.new("", File.dirname(path))
+      IO.copy_stream(gui_mode ? STUBW_PATH : STUB_PATH, stub)
+      stub.close
+
+      if icon_path
+        system(EDICON_PATH, stub.path, icon_path.to_s, exception: true)
+      end
+
+      File.open(stub, "ab") do |of|
+        @of = of
+        @opcode_offset = @of.size
+
+        write_header(debug_mode, debug_extract, chdir_before, enable_compression)
+
+        b = proc {
+          yield(self)
+          write_opcode(OP_END)
+        }
+
+        if enable_compression
+          compress(&b)
+        else
+          b.yield
+        end
+
+        write_footer
+      end
+
+      File.rename(stub, path)
+    end
+
+    def mkdir(target)
+      return unless @dirs.add?("/", target)
+
+      write_opcode(OP_CREATE_DIRECTORY)
+      write_path(target)
+    end
+
+    def cp(source, target)
+      unless File.exist?(source)
+        raise "The file does not exist (#{source})"
+      end
+
+      return unless @files.add?(source, target)
+
+      write_opcode(OP_CREATE_FILE)
+      write_path(target)
+      write_file(source)
+    end
+
+    # Specifies the final application script to be launched, which can be called
+    # from any position in the data stream. It cannot be specified more than once.
+    #
+    # You can omit setting OP_SET_SCRIPT without issues, in which case
+    # the stub terminates without launching anything after performing other
+    # runtime operations.
+    def exec(image, script, *argv)
+      if @script_set
+        raise "Script is already set"
+      end
+      @script_set = true
+
+      write_opcode(OP_SET_SCRIPT)
+      write_string_array(convert_to_native(image), convert_to_native(script), *argv)
+    end
+
+    def export(name, value)
+      write_opcode(OP_SETENV)
+      write_string(name.to_s)
+      write_string(value.to_s)
+    end
+
+    def compress
+      IO.popen([LZMA_PATH, "e", "-si", "-so"], "r+b") do |lzma|
+        _of, @of = @of, lzma
+        Thread.new { yield(self); lzma.close_write }
+        IO.copy_stream(lzma, _of)
+        @of = _of
+      end
+
+      # Calculate the position to write the LZMA decompressed size (64-bit unsigned integer)
+      # @opcode_offset: start position of the data section
+      # 1: size of the header byte
+      # 5: size of the LZMA header in bytes
+      File.binwrite(@of.path, [@data_size].pack("Q<"), @opcode_offset + 1 + 5)
+    end
+    private :compress
+
+    def write_header(debug_mode, debug_extract, chdir_before, compressed)
+      next_to_exe, delete_after = debug_extract, !debug_extract
+      @of << [0 |
+                (debug_mode ? DEBUG_MODE : 0) |
+                (next_to_exe ? EXTRACT_TO_EXE_DIR : 0) |
+                (delete_after ? AUTO_CLEAN_INST_DIR : 0) |
+                (chdir_before ? CHDIR_BEFORE_SCRIPT : 0) |
+                (compressed ? DATA_COMPRESSED : 0)
+      ].pack("C")
+    end
+    private :write_header
+
+    def write_opcode(op)
+      @of << [op].pack("C")
+      @data_size += 1
+    end
+    private :write_opcode
+
+    def write_size(i)
+      if i > 0xFFFF_FFFF
+        raise ArgumentError, "Size #{i} is too large: must be 32-bit unsigned integer (0 to 4294967295)"
+      end
+
+      @of << [i].pack("V")
+      @data_size += 4
+    end
+    private :write_size
+
+    def write_string(str)
+      len = str.bytesize + 1 # +1 to account for the null terminator
+
+      if len > 0xFFFF
+        raise ArgumentError, "String length #{len} is too large: must be less than or equal to 65535 bytes including null terminator"
+      end
+
+      @of << [len, str].pack("vZ*")
+      @data_size += 2 + len
+    end
+    private :write_string
+
+    def write_string_array(*str_array)
+      ary = str_array.map(&:to_s)
+      size = ary.sum(0) { |s| s.bytesize + 1 }
+      write_size(size)
+      ary.each_slice(1) { |a| @of << a.pack("Z*") }
+      @data_size += size
+    end
+    private :write_string_array
+
+    def write_file(src)
+      size = File.size(src)
+      write_size(size)
+      IO.copy_stream(src, @of)
+      @data_size += size
+    end
+    private :write_file
+
+    def write_path(path)
+      write_string(convert_to_native(path))
+    end
+    private :write_path
+
+    def write_footer
+      @of << ([@opcode_offset] + Signature).pack("VC*")
+    end
+    private :write_footer
+
+    def convert_to_native(path)
+      path.to_s.tr(File::SEPARATOR, "\\")
+    end
+    private :convert_to_native
+  end
+end

data/lib/ocran/version.rb

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

data/lib/ocran/windows_command_escaping.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ocran
+  module WindowsCommandEscaping
+    module_function
+
+    def escape_double_quotes(s)
+      s.to_s.gsub('"', '""')
+    end
+
+    def quote_and_escape(s)
+      "\"#{escape_double_quotes(s)}\""
+    end
+  end
+end

data/lib/ocran.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "ocran/version"
-
 module Ocran
+  autoload :VERSION, "ocran/version"
+
+  singleton_class.attr_accessor :option
 end

metadata

@@ -1,21 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: ocran
 version: !ruby/object:Gem::Version
-  version: 1.3.15
+  version: 1.3.17
 platform: ruby
 authors:
 - Andi Idogawa
 - Lars Christensen
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2023-11-30 00:00:00.000000000 Z
-dependencies: []
+date: 2025-05-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  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: "OCRAN (One-Click Ruby Application Next) builds Windows executables from
   Ruby source code. \n  The executable is a self-extracting, self-running executable
   that contains the Ruby interpreter, your source code and any additionally needed
   ruby libraries or DLL.\n  \n  This is a fork of OCRA that is compatible with ruby
-  version after 2.6. \n  Migration guide: make sure to write ocran instead of ocra
+  version after 3.0.\n  Migration guide: make sure to write ocran instead of ocra
   in your code. For instance: OCRAN_EXECUTABLE\n\n  usage: \n    ocra helloworld.rb\n
   \   helloworld.exe\n\n  See readme at https://github.com/largo/ocran\n  Report problems
   in the github issues. Contributions welcome.\n  This gem contains executables. We
@@ -27,11 +41,31 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- bin/ocran
+- CHANGELOG.txt
+- LICENSE.txt
+- README.md
+- exe/ocran
 - lib/ocran.rb
+- lib/ocran/build_constants.rb
+- lib/ocran/build_facade.rb
+- lib/ocran/build_helper.rb
+- lib/ocran/command_output.rb
+- lib/ocran/direction.rb
+- lib/ocran/empty_source
+- lib/ocran/file_path_set.rb
+- lib/ocran/gem_spec_queryable.rb
+- lib/ocran/host_config_helper.rb
+- lib/ocran/inno_setup_script_builder.rb
+- lib/ocran/launcher_batch_builder.rb
+- lib/ocran/library_detector.rb
+- lib/ocran/option.rb
+- lib/ocran/refine_pathname.rb
+- lib/ocran/runner.rb
+- lib/ocran/runtime_environment.rb
+- lib/ocran/stub_builder.rb
 - lib/ocran/version.rb
+- lib/ocran/windows_command_escaping.rb
 - share/ocran/edicon.exe
-- share/ocran/empty-msys-2.0.dll
 - share/ocran/lzma.exe
 - share/ocran/stub.exe
 - share/ocran/stubw.exe
@@ -50,14 +84,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: OCRAN (One-Click Ruby Application Next) builds Windows executables from Ruby