ocran 1.3.18 → 1.4.0

data/lib/ocran/refine_pathname.rb

@@ -1,104 +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
+# 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

@@ -1,105 +1,115 @@
-# 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
+# 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?
+        if Gem.win_platform?
+          direction.build_inno_setup_installer
+        else
+          raise "Inno Setup is only supported on Windows"
+        end
+      elsif @option.macosx_bundle
+        direction.build_macosx_bundle(@option.macosx_bundle)
+      elsif @option.output_dir
+        direction.build_output_dir(@option.output_dir)
+      elsif @option.output_zip
+        direction.build_zip(@option.output_zip)
+      else
+        direction.build_stab_exe
+      end
+    rescue RuntimeError => e
+      fatal_error e.message
+    end
+  end
+end

data/lib/ocran/runtime_environment.rb

@@ -1,46 +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
+# 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