ocran 1.3.15 → 1.3.16

data/lib/ocran/gem_spec_queryable.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+require "rubygems"
+require "pathname"
+require_relative "refine_pathname"
+
+module Ocran
+  module GemSpecQueryable
+    using RefinePathname
+
+    GEM_SCRIPT_RE = /\.rbw?$/
+    GEM_EXTRA_RE = %r{(
+      # Auxiliary files in the root of the gem
+      ^(\.\/)?(History|Install|Manifest|README|CHANGES|Licen[sc]e|Contributors|ChangeLog|BSD|GPL).*$ |
+      # Installation files in the root of the gem
+      ^(\.\/)?(Rakefile|setup.rb|extconf.rb)$ |
+      # Documentation/test directories in the root of the gem
+      ^(\.\/)?(doc|ext|examples|test|tests|benchmarks|spec)\/ |
+      # Directories anywhere
+      (^|\/)(\.autotest|\.svn|\.cvs|\.git)(\/|$) |
+      # Unlikely extensions
+      \.(rdoc|c|cpp|c\+\+|cxx|h|hxx|hpp|obj|o|a)$
+    )}xi
+    GEM_NON_FILE_RE = /(#{GEM_EXTRA_RE}|#{GEM_SCRIPT_RE})/
+
+    class << self
+      # find_gem_path method searches for the path of the gem containing the
+      # specified path. The 'path' argument is a file or directory path.
+      # It checks each gem's installation path in Gem.path to see if the
+      # specified path is a subpath. Returns the gem's path if found, or
+      # nil if not found.
+      def find_gem_path(path)
+        return unless defined?(Gem)
+
+        Gem.path.find { |gem_path| Pathname(path).subpath?(gem_path) }
+      end
+
+      # find_spec_file method searches for the path of the gemspec file of
+      # the gem containing the specified path. The 'path' argument is a file
+      # or directory path. It searches within the "gems" directory in each
+      # directory listed in Gem.path to check if the specified path is a
+      # subpath. If the gemspec file exists, it returns its path; otherwise,
+      # it returns nil.
+      def find_spec_file(path)
+        return unless defined?(Gem)
+
+        feature = Pathname(path)
+        Gem.path.each do |gem_path|
+          gems_dir = File.join(gem_path, "gems")
+          next unless feature.subpath?(gems_dir)
+
+          full_name = feature.relative_path_from(gems_dir).each_filename.first
+          spec_path = File.join(gem_path, "specifications", "#{full_name}.gemspec")
+          return spec_path if File.exist?(spec_path)
+        end
+        nil
+      end
+
+      # find_spec method searches and returns a Gem::Specification object
+      # based on the specified path. Internally, it uses find_spec_file to
+      # obtain the path to the gemspec file, and if that file exists, it
+      # calls Gem::Specification.load to load the gem's specifications.
+      # Returns the loaded Gem::Specification object, or nil if the gemspec
+      # file does not exist.
+      def find_spec(path)
+        return unless defined?(Gem)
+
+        spec_file = find_spec_file(path)
+        spec_file && Gem::Specification.load(spec_file)
+      end
+
+      def scanning_gemfile(gemfile_path)
+        # Ensure the necessary libraries are loaded to scan the Gemfile.
+        # This is particularly useful in custom-built Ruby environments or
+        # where certain libraries might be excluded.
+        %w[rubygems bundler].each do |lib|
+          require lib
+        rescue LoadError
+          raise "Couldn't scan Gemfile, unable to load #{lib}"
+        end
+
+        ENV["BUNDLE_GEMFILE"] = gemfile_path.to_s
+        # Bundler.load.specs includes the spec for Bundler itself
+        Bundler.load.specs.to_a
+      end
+
+      # Fall back to gem detection
+      def detect_gems_from(features, verbose: false)
+        features.inject([]) do |gems, feature|
+          if gems.any? { |spec| feature.subpath?(spec.gem_dir) }
+            # Skip if found in known Gem dir
+          elsif (spec = GemSpecQueryable.find_spec(feature))
+            gems << spec
+          else
+            puts "Failed to load gemspec for #{feature}" if verbose
+          end
+
+          gems
+        end
+      end
+
+      def gem_inclusion_set(spec_name, gem_options)
+        include = [:loaded, :files]
+        gem_options.each do |negate, option, list|
+          next unless list.nil? || list.include?(spec_name)
+
+          case option
+          when :minimal
+            include = [:loaded]
+          when :guess
+            include = [:loaded, :files]
+          when :all
+            include = [:scripts, :files]
+          when :full
+            include = [:scripts, :files, :extras]
+          when :spec
+            include = [:spec]
+          when :scripts, :files, :extras
+            if negate
+              include.delete(option)
+            else
+              include.push(option)
+            end
+          else
+            raise "Invalid Gem content detection option: #{option}"
+          end
+        end
+        include.uniq!
+        include
+      end
+    end
+
+    def gem_root = Pathname(gem_dir)
+
+    # Find the selected files
+    def gem_root_files = gem_root.find.select(&:file?)
+
+    def script_files
+      gem_root_files.select { |path| path.extname =~ GEM_SCRIPT_RE }
+    end
+
+    def extra_files
+      gem_root_files.select { |path| path.relative_path_from(gem_root).to_posix =~ GEM_EXTRA_RE }
+    end
+
+    def resource_files
+      files = gem_root_files.select { |path| path.relative_path_from(gem_root).to_posix !~ GEM_NON_FILE_RE }
+      files << Pathname(gem_build_complete_path) if File.exist?(gem_build_complete_path)
+      files
+    end
+
+    def find_gem_files(file_sets, features_from_gems)
+      actual_files = file_sets.flat_map do |set|
+        case set
+        when :spec
+          files.map { |file| Pathname(file) }
+        when :loaded
+          features_from_gems.select { |feature| feature.subpath?(gem_dir) }
+        when :files
+          resource_files
+        when :extras
+          extra_files
+        when :scripts
+          script_files
+        else
+          raise "Invalid file set: #{set}. Please specify a valid file set (:spec, :loaded, :files, :extras, :scripts)."
+        end
+      end
+      actual_files.uniq
+      actual_files
+    end
+  end
+end

data/lib/ocran/host_config_helper.rb

@@ -0,0 +1,37 @@
+require "rbconfig"
+require "pathname"
+
+module Ocran
+  # Variables describing the host's build environment.
+  module HostConfigHelper
+    module_function
+
+    def exec_prefix
+      @exec_prefix ||= Pathname.new(RbConfig::CONFIG["exec_prefix"])
+    end
+
+    def sitelibdir
+      @sitelibdir ||= Pathname.new(RbConfig::CONFIG["sitelibdir"])
+    end
+
+    def bindir
+      @bindir ||= Pathname.new(RbConfig::CONFIG["bindir"])
+    end
+
+    def libruby_so
+      @libruby_so ||= Pathname.new(RbConfig::CONFIG["LIBRUBY_SO"])
+    end
+
+    def exe_extname
+      RbConfig::CONFIG["EXEEXT"] || ".exe"
+    end
+
+    def rubyw_exe
+      @rubyw_exe ||= (RbConfig::CONFIG["rubyw_install_name"] || "rubyw") + exe_extname
+    end
+
+    def ruby_exe
+      @ruby_exe ||= (RbConfig::CONFIG["ruby_install_name"] || "ruby") + exe_extname
+    end
+  end
+end

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