ocran 1.4.0-x86_64-linux

data/lib/ocran/build_helper.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require "pathname"
+require_relative "refine_pathname"
+require_relative "command_output"
+require_relative "build_constants"
+
+module Ocran
+  module BuildHelper
+    using RefinePathname
+
+    include BuildConstants, CommandOutput
+
+    EMPTY_SOURCE = File.expand_path("empty_source", __dir__).freeze
+
+    def mkdir(target)
+      verbose "mkdir #{target}"
+      super
+    end
+
+    def cp(source, target)
+      verbose "cp #{source} #{target}"
+      super
+    end
+
+    def exec(image, script, *argv)
+      args = argv.map { |s| replace_placeholder(s) }.join(" ")
+      verbose "exec #{image} #{script} #{args}"
+      super
+    end
+
+    def export(name, value)
+      verbose "export #{name}=#{replace_placeholder(value)}"
+      super
+    end
+
+    def replace_placeholder(s)
+      s.to_s.gsub(EXTRACT_ROOT.to_s, "<tempdir>")
+    end
+    private :replace_placeholder
+
+    def copy_to_bin(source, target)
+      cp(source, BINDIR / target)
+    end
+
+    def symlink_in_bin(target, link_name)
+      verbose "symlink #{BINDIR / link_name} -> #{target}"
+      symlink(BINDIR / link_name, target.to_s)
+    end
+
+    def copy_to_gem(source, target)
+      cp(source, GEMDIR / target)
+    end
+
+    def copy_to_lib(source, target)
+      cp(source, LIBDIR / target)
+    end
+
+    def duplicate_to_exec_prefix(source)
+      cp(source, Pathname(source).relative_path_from(HostConfigHelper.exec_prefix))
+    end
+
+    def duplicate_to_gem_home(source, gem_path)
+      copy_to_gem(source, Pathname(source).relative_path_from(gem_path))
+    end
+
+    def resolve_source_path(source, root_prefix)
+      source = Pathname(source)
+
+      if source.subpath?(HostConfigHelper.exec_prefix)
+        source.relative_path_from(HostConfigHelper.exec_prefix)
+      elsif source.subpath?(root_prefix)
+        SRCDIR / source.relative_path_from(root_prefix)
+      else
+        SRCDIR / source.basename
+      end
+    end
+
+    # Sets an environment variable with a joined path value.
+    # This method processes an array of path strings or Pathname objects, accepts
+    # absolute paths as is, and appends a placeholder to relative paths to convert
+    # them into absolute paths. The converted paths are then joined into a single
+    # string using the system's path separator.
+    #
+    # @param name [String] the name of the environment variable to set.
+    # @param paths [Array<String, Pathname>] an array of path arguments which can
+    #        be either absolute or relative.
+    #
+    # Example:
+    #   set_env_path("RUBYLIB", "lib", "ext", "vendor/lib")
+    #   # This sets RUBYLIB to a string such as "C:/ProjectRoot/lib;C:/ProjectRoot/ext;C:/ProjectRoot/vendor/lib"
+    #   # assuming each path is correctly converted to an absolute path through a placeholder.
+    #
+    def set_env_path(name, *paths)
+      value = paths.map { |path|
+        if File.absolute_path?(path)
+          path
+        else
+          File.join(EXTRACT_ROOT, path)
+        end
+      }.join(File::PATH_SEPARATOR)
+
+      export(name, value)
+    end
+
+    def touch(target)
+      verbose "touch #{target}"
+      cp(EMPTY_SOURCE, target)
+    end
+  end
+end

data/lib/ocran/command_output.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+load File.expand_path("../ocran.rb", __dir__)
+
+module Ocran
+  module CommandOutput
+    def say(s)
+      puts "=== #{s}" unless Ocran.option&.quiet?
+    end
+
+    def verbose(s)
+      puts s if Ocran.option&.verbose?
+    end
+
+    def warning(s)
+      STDERR.puts "WARNING: #{s}" if Ocran.option&.warning?
+    end
+
+    def error(s)
+      STDERR.puts "ERROR: #{s}"
+    end
+  end
+end

data/lib/ocran/dir_builder.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+require "pathname"
+require "fileutils"
+require_relative "build_constants"
+
+module Ocran
+  # Builder that outputs all files to a plain directory instead of a self-extracting
+  # executable.  A launch script (`.sh` on POSIX, `.bat` on Windows) is written at
+  # the root of the directory so the packaged app can be started directly.
+  class DirBuilder
+    include BuildConstants
+
+    WINDOWS = Gem.win_platform?
+
+    attr_reader :data_size
+
+    def initialize(path)
+      @path = Pathname(path)
+      @path.mkpath
+      @env = {}
+      @exec_args = nil
+      @symlinks = []
+      @data_size = 0
+
+      yield(self) if block_given?
+
+      finalize
+    end
+
+    def mkdir(target)
+      (@path / target).mkpath
+    end
+
+    def cp(source, target)
+      dest = @path / target
+      dest.dirname.mkpath
+      src = source.to_s
+      FileUtils.cp(src, dest.to_s)
+      @data_size += File.size(src)
+    end
+
+    def symlink(link_path, target)
+      @symlinks << [link_path.to_s, target.to_s]
+    end
+
+    def export(name, value)
+      @env[name.to_s] = value.to_s
+    end
+
+    def exec(image, script, *argv)
+      raise "Script is already set" if @exec_args
+      @exec_args = [image.to_s, script.to_s, argv.map(&:to_s)]
+    end
+
+    # Create a zip archive from a source directory.
+    # Uses the `zip` command on POSIX and PowerShell on Windows.
+    def self.create_zip(zip_path, source_dir)
+      zip_path = File.expand_path(zip_path.to_s)
+      if Gem.win_platform?
+        system("powershell", "-NoProfile", "-Command",
+               "Compress-Archive -Path '#{source_dir}\\*' -DestinationPath '#{zip_path}'",
+               exception: true)
+      else
+        Dir.chdir(source_dir) do
+          system("zip", "-r", zip_path, ".", exception: true)
+        end
+      end
+    end
+
+    private
+
+    def finalize
+      unless WINDOWS
+        @symlinks.each do |link_path, target|
+          dest = @path / link_path
+          dest.dirname.mkpath
+          File.symlink(target, dest) unless dest.exist?
+        end
+      end
+
+      write_launch_script
+    end
+
+    # Replace the EXTRACT_ROOT placeholder ("|") in a value string with
+    # the runtime directory variable.
+    def replace_root(value, root_var)
+      value.gsub("#{EXTRACT_ROOT}/", "#{root_var}/")
+    end
+
+    def script_basename
+      @exec_args ? Pathname(@exec_args[1]).basename.sub_ext("").to_s : "run"
+    end
+
+    def write_launch_script
+      WINDOWS ? write_batch_script : write_shell_script
+    end
+
+    def write_shell_script
+      script_path = @path / "#{script_basename}.sh"
+
+      lines = [
+        "#!/bin/sh",
+        'SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"',
+      ]
+
+      @env.each do |name, value|
+        replaced = replace_root(value, "$SCRIPT_DIR")
+        lines << "export #{name}=\"#{replaced}\""
+      end
+
+      if @exec_args
+        image, script, argv = @exec_args
+        image_r = replace_root(image, "$SCRIPT_DIR")
+        script_r = replace_root(script, "$SCRIPT_DIR")
+
+        # Prepend SCRIPT_DIR to relative paths
+        image_r = "$SCRIPT_DIR/#{image_r}" unless image_r.start_with?("/", "$SCRIPT_DIR")
+        script_r = "$SCRIPT_DIR/#{script_r}" unless script_r.start_with?("/", "$SCRIPT_DIR")
+
+        args = argv.map { |a| "\"#{replace_root(a, "$SCRIPT_DIR")}\"" }.join(" ")
+        exec_line = "exec \"#{image_r}\" \"#{script_r}\""
+        exec_line += " #{args}" unless args.empty?
+        exec_line += ' "$@"'
+        lines << exec_line
+      end
+
+      File.write(script_path, lines.join("\n") + "\n")
+      File.chmod(0755, script_path)
+    end
+
+    def write_batch_script
+      script_path = @path / "#{script_basename}.bat"
+
+      lines = [
+        "@echo off",
+        "set SCRIPT_DIR=%~dp0",
+      ]
+
+      @env.each do |name, value|
+        replaced = replace_root(value, "%SCRIPT_DIR%").tr("/", "\\")
+        lines << "set #{name}=#{replaced}"
+      end
+
+      if @exec_args
+        image, script, argv = @exec_args
+        image_r = replace_root(image, "%SCRIPT_DIR%").tr("/", "\\")
+        script_r = replace_root(script, "%SCRIPT_DIR%").tr("/", "\\")
+
+        image_r = "%SCRIPT_DIR%#{image_r}" unless image_r.include?("%SCRIPT_DIR%") || File.absolute_path?(image_r)
+        script_r = "%SCRIPT_DIR%#{script_r}" unless script_r.include?("%SCRIPT_DIR%") || File.absolute_path?(script_r)
+
+        args = argv.map { |a| replace_root(a, "%SCRIPT_DIR%") }.join(" ")
+        exec_line = "\"#{image_r}\" \"#{script_r}\""
+        exec_line += " #{args}" unless args.empty?
+        exec_line += " %*"
+        lines << exec_line
+      end
+
+      File.write(script_path, lines.join("\r\n") + "\r\n")
+    end
+  end
+end