ocran 1.3.14 → 1.3.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 449194532d3384d90405c64c563178872353c0174ac273f6d139b5af97b74098
-  data.tar.gz: fd72ceea04583f1023000765017a70f12d87b517f847119b722d1af2810028ea
+  metadata.gz: a782f6a9d0c148e6270aa19573c86e5f6518e9511bcfda3aec59de84a1291e41
+  data.tar.gz: 4eff772bc2997a4a99d08ea925c9e9d2eb0e8a1da48c687588dbf7c46d3d3453
 SHA512:
-  metadata.gz: e3f49d0fddb65df9b88ce81b21aecd8c27350afc8018c2899629830058e7f6e35fe03431d6448cd4a5343b2967d512d376a712a87939ffa847ce7913836188fb
-  data.tar.gz: f83fbb8cf6768d4f32e220a83ecb1f77468c27b4735f7a14f4a3fe3680e50587ad79ac0ba5c9c4912498ea9171bfd5c6aeb041b7f49bf5908d5b522dd1ea0051
+  metadata.gz: 3f94bc970689b64b199584baa2ee27f5f371ba6220b3fd736ef24314ab49644eb21932ba2e9397add861bfc609da6b5e4d0be5e45a6804a8bcf64057a1c51978
+  data.tar.gz: b881a6a9f0832490a5875360531e367b0f6efb008b2c8f94c54815fb63885f5350a19c40800f13da70fe714607ee774fd2a4e598373318d2b15a2b4b6fb9fc75

data/bin/ocran

@@ -15,6 +15,16 @@ module Ocran
       a.downcase == b.downcase
     end
 
+    def Pathname.glob(pattern, flags = 0)
+      if block_given?
+        Dir.glob(pattern, flags) { |s| yield Pathname.new(s) }
+      else
+        ary = Dir.glob(pattern, flags)
+        ary.map! { |s| Pathname.new(s) }
+        ary
+      end
+    end
+
     attr_reader :path
     if File::ALT_SEPARATOR.nil?
       File::ALT_SEPARATOR = "\\"
@@ -23,7 +33,7 @@ module Ocran
     ABSOLUTE_PAT = /\A([A-Z]:)?#{SEPARATOR_PAT}/i
 
     def initialize(path)
-      @path = path && path.encode("UTF-8")
+      @path = path.encode("UTF-8")
     end
 
     def to_native
@@ -39,20 +49,20 @@ module Ocran
     # be reached from 'src'.
     def relative_path_from(other)
       a = @path.split(SEPARATOR_PAT)
-      b = other.path.split(SEPARATOR_PAT)
+      b = other.to_s.split(SEPARATOR_PAT)
       while a.first && b.first && Pathname.pathequal(a.first, b.first)
         a.shift
         b.shift
       end
-      return other if Pathname.new(b.first).absolute?
+      return other if b.first && Pathname.new(b.first).absolute?
       b.size.times { a.unshift ".." }
-      return Pathname.new(a.join("/"))
+      Pathname.new(File.join(*a))
     end
 
     # Determines if 'src' is contained in 'tgt' (i.e. it is a subpath of
     # 'tgt'). Both must be absolute paths and not contain '..'
     def subpath?(other)
-      other = Ocran.Pathname(other)
+      other = Pathname.new(other)
       src_normalized = to_posix.downcase
       tgt_normalized = other.to_posix.downcase
       src_normalized =~ /^#{Regexp.escape tgt_normalized}#{SEPARATOR_PAT}/i
@@ -62,37 +72,49 @@ module Ocran
     # is an absolute path. Otherwise, returns the full path of the
     # left + right.
     def /(other)
-      other = Ocran.Pathname(other)
+      other = Pathname.new(other)
       if other.absolute?
         other
       else
-        Ocran.Pathname(@path + "/" + other.path)
+        Pathname.new(File.join(@path, other.to_s))
       end
     end
 
     def append_to_filename!(s)
-      @path.sub!(/(\.[^.]*?|)$/) { s.to_s + $1 }
+      @path = sub(/(\.[^.]*?|)$/) { s.to_s + $1 }
+    end
+
+    def sub(*a, &b)
+      Pathname.new(@path.sub(*a, &b))
+    end
+
+    def sub_ext(new_ext)
+      sub(/(\.[^.]*?)?$/, new_ext)
+    end
+
+    def extname
+      File.extname(@path)
     end
 
     def ext(new_ext = nil)
       if new_ext
-        Pathname.new(@path.sub(/(\.[^.]*?)?$/) { new_ext })
+        sub_ext(new_ext)
       else
-        File.extname(@path)
+        extname
       end
     end
 
     def ext?(expected_ext)
-      Pathname.pathequal(ext, expected_ext)
+      Pathname.pathequal(extname, expected_ext)
     end
 
     def entries
-      Dir.entries(@path).map { |e| self / e.encode("UTF-8") }
+      Dir.entries(@path, encoding: "UTF-8").map { |e| self / e }
     end
 
     # Recursively find all files which match a specified regular
     # expression.
-    def find_all_files(re)
+    def find_all_files(re = //)
       entries.map do |pn|
         if pn.directory?
           if pn.basename =~ /^\.\.?$/
@@ -111,18 +133,35 @@ module Ocran
     end
 
     def ==(other); to_posix.downcase == other.to_posix.downcase; end
+    alias === ==
+    alias eql? ==
     def =~(o); @path =~ o; end
-    def <=>(other); @path.casecmp(other.path); end
+    def <=>(other); @path.casecmp(other.to_s); end
     def exist?; File.exist?(@path); end
     def file?; File.file?(@path); end
     def directory?; File.directory?(@path); end
     def absolute?; @path =~ ABSOLUTE_PAT; end
     def dirname; Pathname.new(File.dirname(@path)); end
     def basename; Pathname.new(File.basename(@path)); end
-    def expand(dir = nil); Pathname.new(File.expand_path(@path, dir && Ocran.Pathname(dir))); end
+
+    def expand_path(dir = ".")
+      Pathname.new(File.expand_path(@path, dir))
+    end
+
+    def expand(dir = nil); dir ? expand_path(dir) : expand_path; end
     def size; File.size(@path); end
     def encode(e); to_posix.encode(e); end # called when creating an installer with innosetup 
 
+    def binread(*args)
+      File.binread(@path, *args)
+    end
+
+    def parent
+      Pathname.new(File.basename(File.dirname(@path)))
+    end
+
+    alias to_path to_posix
+
     alias to_s to_posix
     alias to_str to_posix
   end
@@ -187,7 +226,7 @@ module Ocran
     a.sort.inject([]) { |r, e| r.last == e ? r : r << e }
   end
 
-  VERSION = "1.3.14"
+  VERSION = "1.3.15"
 
   IGNORE_MODULE_NAMES = /\/(enumerator.so|rational.so|complex.so|fiber.so|thread.rb|ruby2_keywords.rb)$/
 
@@ -202,7 +241,7 @@ module Ocran
     # Directories anywhere
     (^|\/)(\.autotest|\.svn|\.cvs|\.git)(\/|$) |
     # Unlikely extensions
-    \.(rdoc|c|cpp|c\+\+|cxx|h|hxx|hpp|obj|o|a)$/
+    \.(rdoc|c|cpp|c\+\+|cxx|h|hxx|hpp|obj|o|a)$
   )}xi
 
   GEM_NON_FILE_RE = /(#{GEM_EXTRA_RE}|#{GEM_SCRIPT_RE})/
@@ -270,40 +309,23 @@ module Ocran
     exit 1
   end
 
-  # Returns a binary blob store embedded in the current Ruby script.
-  def Ocran.get_next_embedded_image
-    DATA.read(DATA.readline.to_i).unpack("m")[0]
-  end
-
   def Ocran.save_environment
     @load_path_before = $LOAD_PATH.dup
     @pwd_before = Dir.pwd
-    @env_before = {}; ENV.each { |key, value| @env_before[key] = value }
+    @env_before = ENV.to_hash
   end
 
   def Ocran.restore_environment
-    @env_before.each { |key, value| ENV[key] = value }
-    ENV.each_key { |key| ENV.delete(key) unless @env_before.has_key?(key) }
+    ENV.clear.update(@env_before)
     Dir.chdir @pwd_before
   end
 
   def Ocran.find_stubs
-    if defined?(DATA)
-      @stubimage = get_next_embedded_image
-      @stubwimage = get_next_embedded_image
-      lzmaimage = get_next_embedded_image
-      @lzmapath = Host.tempdir / "lzma.exe"
-      File.open(@lzmapath, "wb") { |file| file << lzmaimage }
-      ediconimage = get_next_embedded_image
-      @ediconpath = Host.tempdir / "edicon.exe"
-      File.open(@ediconpath, "wb") { |file| file << ediconimage }
-    else
-      ocranpath = Pathname(File.dirname(__FILE__))
-      @stubimage = File.open(ocranpath / "../share/ocran/stub.exe", "rb") { |file| file.read }
-      @stubwimage = File.open(ocranpath / "../share/ocran/stubw.exe", "rb") { |file| file.read }
-      @lzmapath = (ocranpath / "../share/ocran/lzma.exe").expand
-      @ediconpath = (ocranpath / "../share/ocran/edicon.exe").expand
-    end
+    ocranpath = Pathname(File.dirname(__FILE__))
+    @stubimage = (ocranpath / "../share/ocran/stub.exe").binread
+    @stubwimage = (ocranpath / "../share/ocran/stubw.exe").binread
+    @lzmapath = (ocranpath / "../share/ocran/lzma.exe").expand_path
+    @ediconpath = (ocranpath / "../share/ocran/edicon.exe").expand_path
   end
 
   def Ocran.parseargs(argv)
@@ -377,9 +399,11 @@ EOF
       when /\A--add-all-core\z/
         @options[:add_all_core] = true
       when /\A--output\z/
-        @options[:output_override] = Pathname(argv.shift)
+        path = argv.shift
+        @options[:output_override] = Pathname.new(path) if path
       when /\A--dll\z/
-        @options[:extra_dlls] << argv.shift
+        path = argv.shift
+        @options[:extra_dlls] << path if path
       when /\A--quiet\z/
         @options[:quiet] = true
       when /\A--verbose\z/
@@ -393,16 +417,19 @@ EOF
       when /\A--chdir-first\z/
         @options[:chdir_first] = true
       when /\A--icon\z/
-        @options[:icon_filename] = Pathname(argv.shift)
-        Ocran.fatal_error "Icon file #{icon_filename} not found.\n" unless icon_filename.exist?
+        path = argv.shift
+        Ocran.fatal_error "Icon file #{path} not found.\n" unless path && File.exist?(path)
+        @options[:icon_filename] = Pathname.new(path)
       when /\A--rubyopt\z/
         @options[:rubyopt] = argv.shift
       when /\A--gemfile\z/
-        @options[:gemfile] = Pathname(argv.shift)
-        Ocran.fatal_error "Gemfile #{gemfile} not found.\n" unless gemfile.exist?
+        path = argv.shift
+        Ocran.fatal_error "Gemfile #{path} not found.\n" unless path && File.exist?(path)
+        @options[:gemfile] = Pathname.new(path)
       when /\A--innosetup\z/
-        @options[:inno_script] = Pathname(argv.shift)
-        Ocran.fatal_error "Inno Script #{inno_script} not found.\n" unless inno_script.exist?
+        path = argv.shift
+        Ocran.fatal_error "Inno Script #{path} not found.\n" unless path && File.exist?(path)
+        @options[:inno_script] = Pathname.new(path)
       when /\A--no-autodll\z/
         @options[:autodll] = false
       when /\A--version\z/
@@ -421,17 +448,18 @@ EOF
         @options[:enc] = !$1
       when /\A--(no-)?gem-(\w+)(?:=(.*))?$/
         negate, group, list = $1, $2, $3
-        @options[:gem] ||= []
-        @options[:gem] << [negate, group.to_sym, list && list.split(",")]
+        @options[:gem] << [negate, group.to_sym, list&.split(",")] if group
       when /\A--help\z/, /\A--./
         puts usage
         exit 0
       else
-        if __FILE__.respond_to?(:encoding)
-          @options[:files] << arg.dup.force_encoding(__FILE__.encoding)
-        else
-          @options[:files] << arg
+        path = arg.dup
+
+        if !File.exist?(path) || Dir.empty?(path)
+          Ocran.fatal_error "#{path} not found!"
         end
+
+        @options[:files] << path
       end
     end
 
@@ -453,14 +481,12 @@ EOF
     end
 
     @options[:files].map! { |path|
-      path = path.encode("UTF-8").tr('\\', "/")
+      path = path.encode("UTF-8").tr("\\", "/")
       if File.directory?(path)
         # If a directory is passed, we want all files under that directory
         path = "#{path}/**/*"
       end
-      files = Dir[path]
-      Ocran.fatal_error "#{path} not found!" if files.empty?
-      files.map { |path| Pathname(path).expand }
+      Pathname.glob(path).map!(&:expand_path)
     }.flatten!
   end
 
@@ -486,8 +512,6 @@ EOF
       modules_to_check.each do |mod|
         modules_checked[mod] = true
         mod.constants.each do |const|
-          # Module::Config causes warning on Ruby 1.9.3 - prevent autoloading
-          next if Module === mod && const == :Config
           if mod.autoload?(const)
             Ocran.msg "Attempting to trigger autoload of #{mod}::#{const}"
             begin
@@ -509,26 +533,26 @@ EOF
   def Ocran.find_load_path(loadpaths, feature)
     if feature.absolute?
       # Choose those loadpaths which contain the feature
-      candidate_loadpaths = loadpaths.select { |loadpath| feature.subpath?(loadpath.expand) }
+      candidate_loadpaths = loadpaths.select { |loadpath| feature.subpath?(loadpath.expand_path) }
       # Guess the require'd feature
-      feature_pairs = candidate_loadpaths.map { |loadpath| [loadpath, feature.relative_path_from(loadpath.expand)] }
+      feature_pairs = candidate_loadpaths.map { |loadpath| [loadpath, feature.relative_path_from(loadpath.expand_path)] }
       # Select the shortest possible require-path (longest load-path)
       if feature_pairs.empty?
         nil
       else
-        feature_pairs.sort_by { |loadpath, feature| feature.path.size }.first[0]
+        feature_pairs.sort_by { |loadpath, feature| feature.to_s.size }.first[0]
       end
     else
       # Select the loadpaths that contain 'feature' and select the shortest
-      candidates = loadpaths.select { |loadpath| feature.expand(loadpath).exist? }
-      candidates.sort_by { |loadpath| loadpath.path.size }.last
+      candidates = loadpaths.select { |loadpath| feature.expand_path(loadpath).exist? }
+      candidates.sort_by { |loadpath| loadpath.to_s.size }.last
     end
   end
 
   # Find the root of all files specified on the command line and use
   # it as the "src" of the output.
   def Ocran.find_src_root(files)
-    src_files = files.map { |file| file.expand }
+    src_files = files.map { |file| file.expand_path }
     src_prefix = src_files.inject(src_files.first.dirname) do |srcroot, path|
       if path.subpath?(Host.exec_prefix)
         srcroot
@@ -579,18 +603,19 @@ EOF
         end
       end
 
-      ENV["BUNDLE_GEMFILE"] = Ocran.gemfile
+      ENV["BUNDLE_GEMFILE"] = Ocran.gemfile.to_s
       Bundler.load.specs.each do |spec|
         Ocran.verbose_msg "From Gemfile, adding gem #{spec.full_name}"
         gems[spec.name] ||= spec
       end
 
+      # This code is implemented for compatibility with older Bundler versions (< v1.16.0.pre.1).
       unless gems.any? { |name, spec| name == "bundler" }
         # Bundler itself wasn't added for some reason, let's put it in directly
         Ocran.verbose_msg "From Gemfile, forcing inclusion of bundler gem itself"
         bundler_spec = Gem.loaded_specs["bundler"]
         bundler_spec or Ocran.fatal_error "Unable to locate bundler gem"
-        gems["bundler"] ||= spec
+        gems["bundler"] ||= bundler_spec
       end
     end
 
@@ -610,12 +635,12 @@ EOF
           features_from_gems << feature
           next
         end
-        gempaths = Pathname(Gem.path)
+        gempaths = Gem.path
         gempaths.each do |gempath|
           geminstallpath = Pathname(gempath) / "gems"
           if feature.subpath?(geminstallpath)
             gemlocalpath = feature.relative_path_from(geminstallpath)
-            fullgemname = gemlocalpath.path.split("/").first
+            fullgemname = gemlocalpath.to_s.split("/").first
             gemspecpath = gempath / "specifications" / "#{fullgemname}.gemspec"
             if spec = Gem::Specification.load(gemspecpath)
               gems[spec.name] ||= spec
@@ -682,9 +707,9 @@ EOF
         Ocran.msg "Detected gem #{spec.full_name} (#{include.join(", ")})"
 
         gem_root = Pathname(spec.gem_dir)
-        gem_extension = (gem_root / ".." / ".." / "extensions").expand
+        gem_extension = (gem_root / ".." / ".." / "extensions").expand_path
         if gem_extension.exist?
-          build_complete = gem_extension.find_all_files(/gem.build_complete/).select { |p| p.dirname.basename.to_s == spec.full_name }
+          build_complete = gem_extension.find_all_files(/gem.build_complete/).select { |p| p.parent.to_s == spec.full_name }
         else
           build_complete = nil
         end
@@ -704,14 +729,14 @@ EOF
           when :loaded
             files << features_from_gems.select { |feature| feature.subpath?(gem_root) }
           when :files
-            gem_root_files ||= gem_root.find_all_files(//)
+            gem_root_files ||= gem_root.find_all_files
             files << gem_root_files.select { |path| path.relative_path_from(gem_root) !~ GEM_NON_FILE_RE }
             files << build_complete if build_complete
           when :extras
-            gem_root_files ||= gem_root.find_all_files(//)
+            gem_root_files ||= gem_root.find_all_files
             files << gem_root_files.select { |path| path.relative_path_from(gem_root) =~ GEM_EXTRA_RE }
           when :scripts
-            gem_root_files ||= gem_root.find_all_files(//)
+            gem_root_files ||= gem_root.find_all_files
             files << gem_root_files.select { |path| path.relative_path_from(gem_root) =~ GEM_SCRIPT_RE }
           end
         end
@@ -723,7 +748,7 @@ EOF
           Ocran.warn "#{missing_file} was not found"
         end
 
-        total_size = actual_files.inject(0) { |size, path| size + path.size }
+        total_size = actual_files.sum(0, &:size)
         Ocran.msg "\t#{actual_files.size} files, #{total_size} bytes"
 
         gem_files += actual_files
@@ -737,9 +762,9 @@ EOF
   end
 
   def Ocran.build_exe
-    all_load_paths = $LOAD_PATH.map { |loadpath| Pathname(loadpath).expand }
-    @added_load_paths = ($LOAD_PATH - @load_path_before).map { |loadpath| Pathname(loadpath).expand }
-    working_directory = Pathname.pwd.expand
+    all_load_paths = $LOAD_PATH.map { |loadpath| Pathname(loadpath).expand_path }
+    @added_load_paths = ($LOAD_PATH - @load_path_before).map { |loadpath| Pathname(loadpath).expand_path }
+    working_directory = Pathname.pwd
 
     restore_environment
 
@@ -784,7 +809,7 @@ EOF
           encpath = path / "enc"
           if encpath.exist?
             encfiles = encpath.find_all_files(/\.so$/)
-            size = encfiles.inject(0) { |sum, pn| sum + pn.size }
+            size = encfiles.sum(0, &:size)
             Ocran.msg "Including #{encfiles.size} encoding support files (#{size} bytes, use --no-enc to exclude)"
             features.push(*encfiles)
           end
@@ -799,13 +824,13 @@ EOF
     libs = []
     features.each do |feature|
       path = find_load_path(all_load_paths, feature)
-      if path.nil? || path.expand == Pathname.pwd
+      if path.nil? || path.expand_path == Pathname.pwd
         Ocran.files << feature
       else
         if feature.absolute?
-          feature = feature.relative_path_from(path.expand)
+          feature = feature.relative_path_from(path.expand_path)
         end
-        fullpath = feature.expand(path)
+        fullpath = feature.expand_path(path)
 
         if fullpath.subpath?(Host.exec_prefix)
           # Features found in the Ruby installation are put in the
@@ -868,11 +893,10 @@ EOF
         next unless path.to_posix =~
                     /\/(ruby\/(?:site_ruby\/|vendor_ruby\/)?[0-9.]+)\/?$/i
         subdir = $1
-        Dir["#{lp}/**/*"].each do |f|
-          fpath = Pathname.new(f)
+        Pathname.glob("#{lp}/**/*").each do |fpath|
           next if fpath.directory?
           tgt = "lib/#{subdir}/#{fpath.relative_path_from(path).to_posix}"
-          libs << [f, tgt]
+          libs << [fpath, tgt]
         end
       end
     end
@@ -881,13 +905,19 @@ EOF
     dlls = Ocran.autodll ? LibraryDetector.detect_dlls : []
 
     # Detect external manifests
-    manifests = Host.exec_prefix.find_all_files(/\.manifest$/)
+    # For RubyInstaller environments supporting Ruby 2.4 and above,
+    # a manifest file is required.
+    if (manifest = Host.exec_prefix / "bin/ruby_builtin_dlls/ruby_builtin_dlls.manifest").exist?
+      manifests = [manifest]
+    else
+      manifests = []
+    end
 
     executable = nil
     if Ocran.output_override
       executable = Ocran.output_override
     else
-      executable = Ocran.files.first.basename.ext(".exe")
+      executable = Ocran.files.first.basename.sub_ext(".exe")
       executable.append_to_filename!("-debug") if Ocran.debug
     end
 
@@ -963,8 +993,8 @@ EOF
         if gemspec.subpath?(Host.exec_prefix)
           path = gemspec.relative_path_from(Host.exec_prefix)
           sb.createfile(gemspec, path)
-        elsif defined?(Gem) and gemhome = Pathname(Gem.path.find { |pth| gemspec.subpath?(pth) })
-          path = GEMHOMEDIR / gemspec.relative_path_from(gemhome)
+        elsif defined?(Gem) and gemhome = Gem.path.find { |pth| gemspec.subpath?(pth) }
+          path = GEMHOMEDIR / gemspec.relative_path_from(Pathname(gemhome))
           sb.createfile(gemspec, path)
         else
           Ocran.fatal_error "Gem spec #{gemspec} does not exist in the Ruby installation. Don't know where to put it."
@@ -979,8 +1009,9 @@ EOF
 
       # Workaround: RubyInstaller cannot find the msys folder if ../msys64/usr/bin/msys-2.0.dll is not present (since RubyInstaller-2.4.1 rubyinstaller 2 issue 23)
       # Add an empty file to /msys64/usr/bin/msys-2.0.dll if the dll was not required otherwise
-      require 'tempfile'
-      sb.createfile((Tempfile.new("msys-2.0.dll")).path.to_s, 'msys64/usr/bin/msys-2.0.dll') unless sb.files.keys.any? { |entry| entry.to_s.include?("msys-2.0.dll") }
+      unless sb.files.keys.any? { |entry| entry.to_s.include?("msys-2.0.dll") }
+        sb.createfile(Pathname(File.dirname(__FILE__)) / "../share/ocran/empty-msys-2.0.dll".to_s, 'msys64/usr/bin/msys-2.0.dll')
+      end
 
       # Set environment variable
       sb.setenv("RUBYOPT", Ocran.rubyopt || ENV["RUBYOPT"] || "")
@@ -1002,71 +1033,64 @@ EOF
   end
 
   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
+
     def LibraryDetector.init_fiddle
-      require "fiddle"
+      require "fiddle/import"
       require "fiddle/types"
-      module_eval {
-        extend Fiddle::Importer
-        dlload "psapi.dll"
-        include Fiddle::Win32Types
-        extern "BOOL EnumProcessModules(HANDLE, HMODULE*, DWORD, DWORD*)"
-        extend Fiddle::Importer
-        dlload "kernel32.dll"
-        include Fiddle::Win32Types
-
-# https://docs.microsoft.com/en-us/windows/win32/winprog/windows-data-types
-# typedef PVOID HANDLE
-# typedef HINSTANCE HMODULE;
-
-        typealias "HMODULE", "voidp"
-        typealias "HANDLE", "voidp"
-        typealias "LPWSTR", "char*"
-
-        extern "DWORD GetModuleFileNameW(HMODULE, LPWSTR, DWORD)"
-        extern "HANDLE GetCurrentProcess(void)"
-        extern "DWORD GetLastError(void)"
-      }
-    end
 
-    def LibraryDetector.loaded_dlls
-      require "fiddle"
-      psapi = Fiddle.dlopen("psapi")
-      enumprocessmodules = Fiddle::Function.new(psapi["EnumProcessModules"], [Fiddle::TYPE_UINTPTR_T, Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP], Fiddle::TYPE_LONG)
-      kernel32 = Fiddle.dlopen("kernel32")
-      getcurrentprocess = Fiddle::Function.new(kernel32["GetCurrentProcess"], [], Fiddle::TYPE_LONG)
-      getmodulefilename = Fiddle::Function.new(kernel32["GetModuleFileNameW"], [Fiddle::TYPE_UINTPTR_T, Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG], Fiddle::TYPE_LONG)
-      getlasterror = Fiddle::Function.new(kernel32["GetLastError"], [], Fiddle::TYPE_LONG)
-
-# Different packing/unpacking for 64/32 bits systems      
-      if Fiddle::SIZEOF_VOIDP == 8 then
-        f_single = "Q"
-        f_array  = "Q*"
-      else
-        f_single = "I"
-        f_array = "I*"
-      end
+      extend Fiddle::Importer
+      dlload "kernel32.dll", "psapi.dll"
 
-      bytes_needed = Fiddle::SIZEOF_VOIDP * 32
-      module_handle_buffer = nil
-      process_handle = getcurrentprocess.call()
-      loop do
-        module_handle_buffer = "\x00" * bytes_needed
-        bytes_needed_buffer = [0].pack(f_single)
-        r = enumprocessmodules.call(process_handle, module_handle_buffer, module_handle_buffer.size, bytes_needed_buffer)
-        bytes_needed = bytes_needed_buffer.unpack(f_single)[0]
-        break if bytes_needed <= module_handle_buffer.size
-      end
+      include Fiddle::Win32Types
+      # https://docs.microsoft.com/en-us/windows/win32/winprog/windows-data-types
+      typealias "HINSTANCE", "HANDLE" # for Ruby2.6 only
+      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()"
+    end
 
-      handles = module_handle_buffer.unpack(f_array)
-      handles.select { |handle| handle > 0 }.map do |handle|
-        str = "\x00\x00" * 256
-        modulefilename_length = getmodulefilename.call(handle, str, str.size)
-        unless modulefilename_length > 0
-          errorcode = getlasterror.call()
-          Ocran.fatal_error "LibraryDetector: GetModuleFileNameW failed with error code 0x" + errorcode.to_s(16)
+    def LibraryDetector.loaded_dlls
+      init_fiddle
+
+      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
+                    Ocran.fatal_error "LibraryDetector: EnumProcessModules failed with error code %#010x" % 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
+          Ocran.fatal_error "LibraryDetector: GetModuleFileNameW failed with error code %#010x" % GetLastError()
         end
-        modulefilename = str[0, modulefilename_length * 2].force_encoding("UTF-16LE").encode("UTF-8")
-        Ocran.Pathname(modulefilename)
+        Ocran.Pathname(str[0, length])
       end
     end
 
@@ -1112,7 +1136,7 @@ EOF
       end
 
       if Ocran.icon_filename
-        system Ocran.ediconpath, path, Ocran.icon_filename
+        system Ocran.ediconpath.to_s, path.to_s, Ocran.icon_filename.to_s
       end
 
       opcode_offset = File.size(path)
@@ -1142,7 +1166,7 @@ EOF
           begin
             data_size = File.size(tmpinpath)
             Ocran.msg "Compressing #{data_size} bytes"
-            system(Ocran.lzmapath, "e", tmpinpath, tmpoutpath) or fail
+            system(Ocran.lzmapath.to_s, "e", tmpinpath, tmpoutpath) or fail
             compressed_data_size = File.size?(tmpoutpath)
             ocranfile.write([OP_DECOMPRESS_LZMA, compressed_data_size].pack("VV"))
             IO.copy_stream(tmpoutpath, ocranfile)
@@ -1189,7 +1213,7 @@ EOF
           Ocran.msg "Running InnoSetup compiler ISCC"
           result = system(*iscc_cmd)
           if not result
-            case $?
+            case $?.exitstatus
             when 0 then raise RuntimeError.new("ISCC reported success, but system reported error?")
             when 1 then raise RuntimeError.new("ISCC reports invalid command line parameters")
             when 2 then raise RuntimeError.new("ISCC reports that compilation failed")
@@ -1206,8 +1230,8 @@ EOF
     end
 
     def mkdir(path)
-      return if @paths[path.path.downcase]
-      @paths[path.path.downcase] = true
+      return if @paths[path.to_s.downcase]
+      @paths[path.to_posix.downcase] = true
       Ocran.verbose_msg "m #{showtempdir path}"
       unless Ocran.inno_script # The directory will be created by InnoSetup with a [Dirs] statement
         @of << [OP_CREATE_DIRECTORY, path.to_native].pack("VZ*")
@@ -1216,7 +1240,7 @@ EOF
 
     def ensuremkdir(tgt)
       tgt = Ocran.Pathname(tgt)
-      return if tgt.path == "."
+      return if tgt.to_s == "."
       if not @paths[tgt.to_posix.downcase]
         ensuremkdir(tgt.dirname)
         mkdir(tgt)
@@ -1234,7 +1258,7 @@ EOF
       @files[tgt] = src
       src, tgt = Ocran.Pathname(src), Ocran.Pathname(tgt)
       ensuremkdir(tgt.dirname)
-      str = File.open(src, "rb") { |file| file.read }
+      str = src.binread
       Ocran.verbose_msg "a #{showtempdir tgt}"
       unless Ocran.inno_script # InnoSetup will install the file with a [Files] statement
         @of << [OP_CREATE_FILE, tgt.to_native, str.size].pack("VZ*V")
@@ -1265,7 +1289,7 @@ EOF
     end
 
     def showtempdir(x)
-      x.to_s.gsub(TEMPDIR_ROOT, "<tempdir>")
+      x.to_s.gsub(TEMPDIR_ROOT.to_s, "<tempdir>")
     end
   end # class OcranBuilder
 end # module Ocran
@@ -1287,7 +1311,7 @@ if File.basename(__FILE__) == File.basename($0)
 
   if Ocran.run_script
     Ocran.msg "Loading script to check dependencies"
-    $0 = Ocran.files.first
+    $0 = Ocran.files.first.to_s
     load Ocran.files.first
   end
 end

data/lib/ocran/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ocran
-    VERSION = "1.3.14"
-  end
+  VERSION = "1.3.15"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ocran
 version: !ruby/object:Gem::Version
-  version: 1.3.14
+  version: 1.3.15
 platform: ruby
 authors:
 - Andi Idogawa
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-08 00:00:00.000000000 Z
+date: 2023-11-30 00:00:00.000000000 Z
 dependencies: []
 description: "OCRAN (One-Click Ruby Application Next) builds Windows executables from
   Ruby source code. \n  The executable is a self-extracting, self-running executable
@@ -31,6 +31,7 @@ files:
 - lib/ocran.rb
 - lib/ocran/version.rb
 - share/ocran/edicon.exe
+- share/ocran/empty-msys-2.0.dll
 - share/ocran/lzma.exe
 - share/ocran/stub.exe
 - share/ocran/stubw.exe
@@ -49,7 +50,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="