ocran 1.3.15 → 1.3.16

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

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