ocran 1.3.15 → 1.3.17

data/lib/ocran/inno_setup_script_builder.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+require "tempfile"
+require_relative "file_path_set"
+require_relative "windows_command_escaping"
+
+module Ocran
+  class InnoSetupScriptBuilder
+    ISCC_CMD = "ISCC"
+    ISCC_SUCCESS = 0
+    ISCC_INVALID_PARAMS = 1
+    ISCC_COMPILATION_FAILED = 2
+
+    extend WindowsCommandEscaping
+
+    class << self
+      def compile(iss_filename, quiet: false)
+        unless system("where #{quote_and_escape(ISCC_CMD)} >NUL 2>&1")
+          raise "ISCC command not found. Is the InnoSetup directory in your PATH?"
+        end
+
+        cmd_line = [ISCC_CMD]
+        cmd_line << "/Q" if quiet
+        cmd_line << iss_filename
+        system(*cmd_line)
+
+        case $?&.exitstatus
+        when ISCC_SUCCESS
+          # ISCC reported success
+        when ISCC_INVALID_PARAMS
+          raise "ISCC reports invalid command line parameters"
+        when ISCC_COMPILATION_FAILED
+          raise "ISCC reports that compilation failed"
+        else
+          raise "ISCC failed to run"
+        end
+      end
+    end
+
+    include WindowsCommandEscaping
+
+    def initialize(inno_setup_script)
+      # ISSC generates the installer files relative to the directory of the
+      # ISS file. Therefore, it is necessary to create Tempfiles in the
+      # working directory.
+      @build_file = Tempfile.new("", Dir.pwd)
+      if inno_setup_script
+        IO.copy_stream(inno_setup_script, @build_file)
+      end
+      @dirs = FilePathSet.new
+      @files = FilePathSet.new
+    end
+
+    def build
+      @build_file.tap do |f|
+        if @dirs.any?
+          f.puts
+          f.puts "[Dirs]"
+          @dirs.each { |_source, target| f.puts build_dir_item(target) }
+        end
+
+        if @files.any?
+          f.puts
+          f.puts "[Files]"
+          @files.each { |source, target| f.puts build_file_item(source, target) }
+        end
+      end.close
+      path
+    end
+
+    def path
+      @build_file.to_path
+    end
+
+    def compile(verbose: false)
+      InnoSetupScriptBuilder.compile(path, quiet: !verbose)
+    end
+
+    def mkdir(target)
+      @dirs.add?("/", target)
+    end
+
+    def cp(source, target)
+      unless File.exist?(source)
+        raise "The file does not exist (#{source})"
+      end
+
+      @files.add?(source, target)
+    end
+
+    def build_dir_item(target)
+      name = File.join("{app}", target)
+      "Name: #{quote_and_escape(name)};"
+    end
+    private :build_dir_item
+
+    def build_file_item(source, target)
+      dest_dir = File.join("{app}", File.dirname(target))
+      s = [
+        "Source: #{quote_and_escape(source)};",
+        "DestDir: #{quote_and_escape(dest_dir)};"
+      ]
+      src_name = File.basename(source)
+      dest_name = File.basename(target)
+      if src_name != dest_name
+        s << "DestName: #{quote_and_escape(dest_name)};"
+      end
+      s.join(" ")
+    end
+    private :build_file_item
+  end
+end

data/lib/ocran/launcher_batch_builder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require "tempfile"
+require_relative "windows_command_escaping"
+require_relative "build_constants"
+
+module Ocran
+  class LauncherBatchBuilder
+    include BuildConstants, WindowsCommandEscaping
+
+    # BATCH_FILE_DIR is a parameter expansion used in Windows batch files,
+    # representing the full path to the directory where the batch file resides.
+    # It allows for the use of pseudo-relative paths by referencing the
+    # batch file's own location without changing the working directory.
+    BATCH_FILE_DIR = "%~dp0"
+
+    # BATCH_FILE_PATH is a parameter expansion used in Windows batch files,
+    # representing the full path to the batch file itself, including the file name.
+    BATCH_FILE_PATH = "%~f0"
+
+    def initialize(chdir_before: nil, title: nil)
+      @build_file = Tempfile.new
+      @title = title
+      @chdir_before = chdir_before
+      @environments = {}
+    end
+
+    def build
+      @build_file.tap do |f|
+        f.puts "@echo off"
+        @environments.each { |name, val| f.puts build_set_command(name, val) }
+        f.puts build_set_command("OCRAN_EXECUTABLE", BATCH_FILE_PATH)
+        f.puts build_start_command(@title, @executable, @script, *@args, chdir_before: @chdir_before)
+        f
+      end.close
+      path
+    end
+
+    def path
+      @build_file.to_path
+    end
+
+    def export(name, value)
+      @environments[name] = value
+    end
+
+    def exec(executable, script, *args)
+      @executable, @script, @args = executable, script, args
+    end
+
+    def replace_inst_dir_placeholder(s)
+      s.to_s.gsub(/#{Regexp.escape(EXTRACT_ROOT.to_s)}[\/\\]/, BATCH_FILE_DIR)
+    end
+    private :replace_inst_dir_placeholder
+
+    def build_set_command(name, value)
+      "set \"#{name}=#{replace_inst_dir_placeholder(value)}\""
+    end
+    private :build_set_command
+
+    def build_start_command(title, executable, script, *args, chdir_before: nil)
+      cmd = ["start"]
+
+      # Title for Command Prompt window title bar
+      cmd << quote_and_escape(title)
+
+      # Use /d to set the startup directory for the process,
+      # which will be BATCH_FILE_DIR/SRCDIR. This path is where
+      # the script is located, establishing the working directory
+      # at process start.
+      if chdir_before
+        cmd << "/d #{quote_and_escape("#{BATCH_FILE_DIR}#{SRCDIR}")}"
+      end
+
+      cmd << quote_and_escape("#{BATCH_FILE_DIR}#{executable}")
+      cmd << quote_and_escape("#{BATCH_FILE_DIR}#{script}")
+      cmd += args.map { |arg| quote_and_escape(replace_inst_dir_placeholder(arg)) }
+
+      # Forward batch file arguments to the command with `%*`
+      cmd << "%*"
+
+      cmd.join(" ")
+    end
+    private :build_start_command
+  end
+end

data/lib/ocran/library_detector.rb

@@ -0,0 +1,61 @@
+require "fiddle/import"
+require "fiddle/types"
+
+module Ocran
+  module LibraryDetector
+    # Windows API functions for handling files may return long paths,
+    # with a maximum character limit of 32,767.
+    # "\\?\" prefix(4 characters) + long path(32762 characters) + NULL = 32767 characters
+    # https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
+    MAX_PATH = 32767
+
+    # The byte size of the buffer given as an argument to the EnumProcessModules function.
+    # This buffer is used to store the handles of the loaded modules.
+    # If the buffer size is smaller than the number of loaded modules,
+    # it will automatically increase the buffer size and call the EnumProcessModules function again.
+    # Increasing the initial buffer size can reduce the number of iterations required.
+    # https://learn.microsoft.com/en-us/windows/win32/psapi/enumerating-all-modules-for-a-process
+    DEFAULT_HMODULE_BUFFER_SIZE = 1024
+
+    extend Fiddle::Importer
+    dlload "kernel32.dll", "psapi.dll"
+
+    include Fiddle::Win32Types
+    # https://docs.microsoft.com/en-us/windows/win32/winprog/windows-data-types
+    typealias "HMODULE", "HINSTANCE"
+    typealias "LPDWORD", "PDWORD"
+    typealias "LPWSTR", "char*"
+
+    extern "BOOL EnumProcessModules(HANDLE, HMODULE*, DWORD, LPDWORD)"
+    extern "DWORD GetModuleFileNameW(HMODULE, LPWSTR, DWORD)"
+    extern "HANDLE GetCurrentProcess()"
+    extern "DWORD GetLastError()"
+
+    class << self
+      def loaded_dlls
+        dword = "L" # A DWORD is a 32-bit unsigned integer.
+        bytes_needed = [0].pack(dword)
+        bytes = DEFAULT_HMODULE_BUFFER_SIZE
+        process_handle = GetCurrentProcess()
+        handles = while true
+                    buffer = "\x00" * bytes
+                    if EnumProcessModules(process_handle, buffer, buffer.bytesize, bytes_needed) == 0
+                      raise "EnumProcessModules failed with error code #{GetLastError()}"
+                    end
+                    bytes = bytes_needed.unpack1(dword)
+                    if bytes <= buffer.bytesize
+                      break buffer.unpack("J#{bytes / Fiddle::SIZEOF_VOIDP}")
+                    end
+                  end
+        str = "\x00".encode("UTF-16LE") * MAX_PATH
+        handles.map do |handle|
+          length = GetModuleFileNameW(handle, str, str.bytesize)
+          if length == 0
+            raise "GetModuleFileNameW failed with error code #{GetLastError()}"
+          end
+          str[0, length].encode("UTF-8")
+        end
+      end
+    end
+  end
+end

data/lib/ocran/option.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+require "pathname"
+
+module Ocran
+  class Option
+    load File.expand_path("refine_pathname.rb", __dir__) unless defined? RefinePathname
+    using RefinePathname
+
+    def initialize
+      @options = {
+        :add_all_core? => false,
+        :add_all_encoding? => true,
+        :argv => [],
+        :auto_detect_dlls? => true,
+        :chdir_before? => false,
+        :enable_compression? => true,
+        :enable_debug_extract? => false,
+        :enable_debug_mode? => false,
+        :extra_dlls => [],
+        :force_console? => false,
+        :force_windows? => false,
+        :gem_options => [],
+        :gemfile => nil,
+        :icon_filename => nil,
+        :inno_setup_script => nil,
+        :load_autoload? => true,
+        :output_override => nil,
+        :quiet? => false,
+        :rubyopt => nil,
+        :run_script? => true,
+        :script => nil,
+        :source_files => [],
+        :verbose? => false,
+        :warning? => true,
+      }
+    end
+
+    def usage
+      <<EOF
+ocran [options] script.rb
+
+Ocran options:
+
+--help             Display this information.
+--quiet            Suppress output while building executable.
+--verbose          Show extra output while building executable.
+--version          Display version number and exit.
+
+Packaging options:
+
+--dll dllname      Include additional DLLs from the Ruby bindir.
+--add-all-core     Add all core ruby libraries to the executable.
+--gemfile <file>   Add all gems and dependencies listed in a Bundler Gemfile.
+--no-enc           Exclude encoding support files
+
+Gem content detection modes:
+
+--gem-minimal[=gem1,..]  Include only loaded scripts
+--gem-guess=[gem1,...]   Include loaded scripts & best guess (DEFAULT)
+--gem-all[=gem1,..]      Include all scripts & files
+--gem-full[=gem1,..]     Include EVERYTHING
+--gem-spec[=gem1,..]     Include files in gemspec (Does not work with Rubygems 1.7+)
+
+  minimal: loaded scripts
+  guess: loaded scripts and other files
+  all: loaded scripts, other scripts, other files (except extras)
+  full: Everything found in the gem directory
+
+--[no-]gem-scripts[=..]  Other script files than those loaded
+--[no-]gem-files[=..]    Other files (e.g. data files)
+--[no-]gem-extras[=..]   Extra files (README, etc.)
+
+  scripts: .rb/.rbw files
+  extras: C/C++ sources, object files, test, spec, README
+  files: all other files
+
+Auto-detection options:
+
+--no-dep-run       Don't run script.rb to check for dependencies.
+--no-autoload      Don't load/include script.rb's autoloads.
+--no-autodll       Disable detection of runtime DLL dependencies.
+
+Output options:
+
+--output <file>    Name the exe to generate. Defaults to ./<scriptname>.exe.
+--no-lzma          Disable LZMA compression of the executable.
+--innosetup <file> Use given Inno Setup script (.iss) to create an installer.
+
+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.
+--icon <ico>       Replace icon with a custom one.
+--rubyopt <str>    Set the RUBYOPT environment variable when running the executable
+--debug            Executable will be verbose.
+--debug-extract    Executable will unpack to local dir and not delete after.
+EOF
+    end
+
+    def parse(argv)
+      while (arg = argv.shift)
+        case arg
+        when /\A--(no-)?lzma\z/
+          @options[:enable_compression?] = !$1
+        when "--no-dep-run"
+          @options[:run_script?] = false
+        when "--add-all-core"
+          @options[:add_all_core?] = true
+        when "--output"
+          path = argv.shift
+          @options[:output_override] = Pathname.new(path).expand_path if path
+        when "--dll"
+          path = argv.shift
+          @options[:extra_dlls] << path if path
+        when "--quiet"
+          @options[:quiet?] = true
+        when "--verbose"
+          @options[:verbose?] = true
+        when "--windows"
+          @options[:force_windows?] = true
+        when "--console"
+          @options[:force_console?] = true
+        when "--no-autoload"
+          @options[:load_autoload?] = false
+        when "--chdir-first"
+          @options[:chdir_before?] = 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 "--gemfile"
+          path = argv.shift
+          raise "Gemfile #{path} not found" unless path && File.exist?(path)
+          @options[:gemfile] = Pathname.new(path).expand_path
+        when "--innosetup"
+          path = argv.shift
+          raise "Inno Script #{path} not found" unless path && File.exist?(path)
+          @options[:inno_setup_script] = Pathname.new(path).expand_path
+        when "--no-autodll"
+          @options[:auto_detect_dlls?] = false
+        when "--version"
+          require_relative "version"
+          puts "Ocran #{VERSION}"
+          raise SystemExit
+        when "--no-warnings"
+          @options[:warning?] = false
+        when "--debug"
+          @options[:enable_debug_mode?] = true
+        when "--debug-extract"
+          @options[:enable_debug_extract?] = true
+        when "--"
+          @options[:argv] = argv.dup
+          argv.clear
+          break
+        when /\A--(no-)?enc\z/
+          @options[:add_all_encoding?] = !$1
+        when /\A--(no-)?gem-(\w+)(?:=(.*))?$/
+          negate, group, list = $1, $2, $3
+          @options[:gem_options] << [negate, group.to_sym, list&.split(",")] if group
+        when "--help", /\A--./
+          puts usage
+          raise SystemExit
+        else
+          raise "#{arg} not found!" unless File.exist?(arg)
+
+          if File.directory?(arg)
+            raise "#{arg} is empty!" if Dir.empty?(arg)
+            # If a directory is passed, we want all files under that directory
+            @options[:source_files] += Pathname.new(arg).find.reject(&:directory?).map(&:expand_path)
+          else
+            @options[:source_files] << Pathname.new(arg).expand_path
+          end
+        end
+      end
+
+      raise "No script file specified" if source_files.empty?
+
+      @options[:script] = source_files.first
+
+      @options[:force_autoload?] = run_script? && load_autoload?
+
+      @options[:output_executable] =
+        if output_override
+          output_override
+        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
+          executable.basename.sub_ext(".exe").expand_path
+        end
+
+      @options[:use_inno_setup?] = !!inno_setup_script
+
+      @options[:verbose?] &&= !quiet?
+
+      @options[:windowed?] = (script.extname?(".rbw") || force_windows?) && !force_console?
+
+      if inno_setup_script
+        if enable_debug_extract?
+          raise "The --debug-extract option conflicts with use of Inno Setup"
+        end
+
+        if enable_compression?
+          raise "LZMA compression must be disabled (--no-lzma) when using Inno Setup"
+        end
+
+        unless chdir_before?
+          raise "Chdir-first mode must be enabled (--chdir-first) when using Inno Setup"
+        end
+      end
+    end
+
+    def add_all_core? = @options[__method__]
+
+    def add_all_encoding? = @options[__method__]
+
+    def argv = @options[__method__]
+
+    def auto_detect_dlls? = @options[__method__]
+
+    def chdir_before? = @options[__method__]
+
+    def enable_compression? = @options[__method__]
+
+    def enable_debug_extract? = @options[__method__]
+
+    def enable_debug_mode? = @options[__method__]
+
+    def extra_dlls = @options[__method__]
+
+    def force_autoload? = @options[__method__]
+
+    def force_console? = @options[__method__]
+
+    def force_windows? = @options[__method__]
+
+    def gem_options = @options[__method__]
+
+    def gemfile = @options[__method__]
+
+    def icon_filename = @options[__method__]
+
+    def inno_setup_script = @options[__method__]
+
+    def load_autoload? = @options[__method__]
+
+    def output_executable = @options[__method__]
+
+    def output_override = @options[__method__]
+
+    def quiet? = @options[__method__]
+
+    def rubyopt = @options[__method__]
+
+    def run_script? = @options[__method__]
+
+    def script = @options[__method__]
+
+    def source_files = @options[__method__]
+
+    def use_inno_setup? = @options[__method__]
+
+    def verbose? = @options[__method__]
+
+    def warning? = @options[__method__]
+
+    def windowed? = @options[__method__]
+  end
+end

data/lib/ocran/refine_pathname.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+require "pathname"
+
+module Ocran
+  # The Pathname class in Ruby is modified to handle mixed path separators and
+  # to be case-insensitive.
+  module RefinePathname
+    refine Pathname do
+      def normalize_file_separator(s)
+        if File::ALT_SEPARATOR
+          s.tr(File::ALT_SEPARATOR, File::SEPARATOR)
+        else
+          s
+        end
+      end
+      private :normalize_file_separator
+
+      # Compares two paths for equality based on the case sensitivity of the
+      # Ruby execution environment's file system.
+      # If the file system is case-insensitive, it performs a case-insensitive
+      # comparison. Otherwise, it performs a case-sensitive comparison.
+      def pathequal(a, b)
+        if File::FNM_SYSCASE.nonzero?
+          a.casecmp(b) == 0
+        else
+          a == b
+        end
+      end
+      private :pathequal
+
+      def to_posix
+        normalize_file_separator(to_s)
+      end
+
+      # Checks if two Pathname objects are equal, considering the file system's
+      # case sensitivity and path separators. Returns false if the other object is not
+      # an Pathname.
+      # This method enables the use of the `uniq` method on arrays of Pathname objects.
+      def eql?(other)
+        return false unless other.is_a?(Pathname)
+
+        a = normalize_file_separator(to_s)
+        b = normalize_file_separator(other.to_s)
+        pathequal(a, b)
+      end
+
+      alias == eql?
+      alias === eql?
+
+      # Calculates a normalized hash value for a pathname to ensure consistent
+      # hashing across different environments, particularly in Windows.
+      # This method first normalizes the path by:
+      # 1. Converting the file separator from the platform-specific separator
+      #    to the common POSIX separator ('/') if necessary.
+      # 2. Converting the path to lowercase if the filesystem is case-insensitive.
+      # The normalized path string is then hashed, providing a stable hash value
+      # that is consistent with the behavior of eql? method, thus maintaining
+      # the integrity of hash-based data structures like Hash or Set.
+      #
+      # @return [Integer] A hash integer based on the normalized path.
+      def hash
+        path = if File::FNM_SYSCASE.nonzero?
+                 to_s.downcase
+               else
+                 to_s
+               end
+        normalize_file_separator(path).hash
+      end
+
+      # Checks if the current path is a sub path of the specified base_directory.
+      # Both paths must be either absolute paths or relative paths; otherwise, this
+      # method returns false.
+      def subpath?(base_directory)
+        s = relative_path_from(base_directory).each_filename.first
+        s != '.' && s != ".."
+      rescue ArgumentError
+        false
+      end
+
+      # Appends the given suffix to the filename, preserving the file extension.
+      # If the filename has an extension, the suffix is inserted before the extension.
+      # If the filename does not have an extension, the suffix is appended to the end.
+      # This method handles both directory and file paths correctly.
+      #
+      # Examples:
+      #   pathname = Pathname("path.to/foo.tar.gz")
+      #   pathname.append_to_filename("_bar") # => #<Pathname:path.to/foo_bar.tar.gz>
+      #
+      #   pathname = Pathname("path.to/foo")
+      #   pathname.append_to_filename("_bar") # => #<Pathname:path.to/foo_bar>
+      #
+      def append_to_filename(suffix)
+        dirname + basename.sub(/(\.?[^.]+)?(\..*)?\z/, "\\1#{suffix}\\2")
+      end
+
+      # Checks if the file's extension matches the expected extension.
+      # The comparison is case-insensitive.
+      # Example usage: ocran_pathname.extname?(".exe")
+      def extname?(expected_ext)
+        extname.casecmp(expected_ext) == 0
+      end
+    end
+  end
+end