ocran 1.3.15 → 1.3.16

data/bin/ocran

@@ -1,1317 +1,5 @@
 #!/usr/bin/env ruby
-# -*- ruby -*-
 # encoding: UTF-8
 
-module Ocran
-  # Path handling class. Ruby's Pathname class is not used because it
-  # is case sensitive and doesn't handle paths with mixed path
-  # separators.
-  class Pathname
-    def Pathname.pwd
-      Pathname.new(Dir.pwd.encode("UTF-8"))
-    end
-
-    def Pathname.pathequal(a, b)
-      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 = "\\"
-    end
-    SEPARATOR_PAT = /[#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}]/ # }
-    ABSOLUTE_PAT = /\A([A-Z]:)?#{SEPARATOR_PAT}/i
-
-    def initialize(path)
-      @path = path.encode("UTF-8")
-    end
-
-    def to_native
-      @path.tr File::SEPARATOR, File::ALT_SEPARATOR
-    end
-
-    def to_posix
-      @path.tr File::ALT_SEPARATOR, File::SEPARATOR
-    end
-
-    # Compute the relative path from the 'src' path (directory) to 'tgt'
-    # (directory or file). Return the absolute path to 'tgt' if it can't
-    # be reached from 'src'.
-    def relative_path_from(other)
-      a = @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 b.first && Pathname.new(b.first).absolute?
-      b.size.times { a.unshift ".." }
-      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 = Pathname.new(other)
-      src_normalized = to_posix.downcase
-      tgt_normalized = other.to_posix.downcase
-      src_normalized =~ /^#{Regexp.escape tgt_normalized}#{SEPARATOR_PAT}/i
-    end
-
-    # Join two pathnames together. Returns the right-hand side if it
-    # is an absolute path. Otherwise, returns the full path of the
-    # left + right.
-    def /(other)
-      other = Pathname.new(other)
-      if other.absolute?
-        other
-      else
-        Pathname.new(File.join(@path, other.to_s))
-      end
-    end
-
-    def append_to_filename!(s)
-      @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
-        sub_ext(new_ext)
-      else
-        extname
-      end
-    end
-
-    def ext?(expected_ext)
-      Pathname.pathequal(extname, expected_ext)
-    end
-
-    def entries
-      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 = //)
-      entries.map do |pn|
-        if pn.directory?
-          if pn.basename =~ /^\.\.?$/
-            []
-          else
-            pn.find_all_files(re)
-          end
-        elsif pn.file?
-          if pn.basename =~ re
-            pn
-          else
-            []
-          end
-        end
-      end.flatten
-    end
-
-    def ==(other); to_posix.downcase == other.to_posix.downcase; end
-    alias === ==
-    alias eql? ==
-    def =~(o); @path =~ o; 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_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
-
-  # Type conversion for the Pathname class. Works with Pathname,
-  # String, NilClass and arrays of any of these.
-  def self.Pathname(obj)
-    case obj
-    when Pathname
-      obj
-    when Array
-      obj.map { |x| Pathname(x) }
-    when String
-      Pathname.new(obj)
-    when NilClass
-      nil
-    else
-      raise ArgumentError, obj
-    end
-  end
-
-  # Variables describing the host's build environment.
-  module Host
-    class << self
-      def exec_prefix
-        @exec_prefix ||= Ocran.Pathname(RbConfig::CONFIG["exec_prefix"])
-      end
-
-      def sitelibdir
-        @sitelibdir ||= Ocran.Pathname(RbConfig::CONFIG["sitelibdir"])
-      end
-
-      def bindir
-        @bindir ||= Ocran.Pathname(RbConfig::CONFIG["bindir"])
-      end
-
-      def libruby_so
-        @libruby_so ||= Ocran.Pathname(RbConfig::CONFIG["LIBRUBY_SO"])
-      end
-
-      def exeext
-        RbConfig::CONFIG["EXEEXT"] || ".exe"
-      end
-
-      def rubyw_exe
-        @rubyw_exe ||= (RbConfig::CONFIG["rubyw_install_name"] || "rubyw") + exeext
-      end
-
-      def ruby_exe
-        @ruby_exe ||= (RbConfig::CONFIG["ruby_install_name"] || "ruby") + exeext
-      end
-
-      def tempdir
-        @tempdir ||= Ocran.Pathname(ENV["TEMP"])
-      end
-    end
-  end
-
-  # Sorts and returns an array without duplicates. Works with complex
-  # objects (such as Pathname), in contrast to Array#uniq.
-  def self.sort_uniq(a)
-    a.sort.inject([]) { |r, e| r.last == e ? r : r << e }
-  end
-
-  VERSION = "1.3.15"
-
-  IGNORE_MODULE_NAMES = /\/(enumerator.so|rational.so|complex.so|fiber.so|thread.rb|ruby2_keywords.rb)$/
-
-  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})/
-
-  # Alias for the temporary directory where files are extracted.
-  TEMPDIR_ROOT = Pathname.new("|")
-  # Directory for source files in temporary directory.
-  SRCDIR = Pathname.new("src")
-  # Directory for Ruby binaries in temporary directory.
-  BINDIR = Pathname.new("bin")
-  # Directory for GEMHOME files in temporary directory.
-  GEMHOMEDIR = Pathname.new("gemhome")
-
-  IGNORE_MODULES = []
-
-  @options = {
-    :lzma_mode => true,
-    :extra_dlls => [],
-    :files => [],
-    :run_script => true,
-    :add_all_core => false,
-    :output_override => nil,
-    :load_autoload => true,
-    :chdir_first => false,
-    :force_windows => false,
-    :force_console => false,
-    :icon_filename => nil,
-    :rubyopt => nil,
-    :gemfile => nil,
-    :inno_script => nil,
-    :quiet => false,
-    :verbose => false,
-    :autodll => true,
-    :show_warnings => true,
-    :debug => false,
-    :debug_extract => false,
-    :arg => [],
-    :enc => true,
-    :gem => [],
-  }
-
-  @options.each_key { |opt| eval("def self.#{opt}; @options[:#{opt}]; end") }
-
-  class << self
-    attr_reader :lzmapath
-    attr_reader :ediconpath
-    attr_reader :stubimage
-    attr_reader :stubwimage
-  end
-
-  def Ocran.msg(s)
-    puts "=== #{s}" unless Ocran.quiet
-  end
-
-  def Ocran.verbose_msg(s)
-    puts s if Ocran.verbose and not Ocran.quiet
-  end
-
-  def Ocran.warn(s)
-    msg "WARNING: #{s}" if Ocran.show_warnings
-  end
-
-  def Ocran.fatal_error(s)
-    puts "ERROR: #{s}"
-    exit 1
-  end
-
-  def Ocran.save_environment
-    @load_path_before = $LOAD_PATH.dup
-    @pwd_before = Dir.pwd
-    @env_before = ENV.to_hash
-  end
-
-  def Ocran.restore_environment
-    ENV.clear.update(@env_before)
-    Dir.chdir @pwd_before
-  end
-
-  def Ocran.find_stubs
-    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)
-    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
-
-    while arg = argv.shift
-      case arg
-      when /\A--(no-)?lzma\z/
-        @options[:lzma_mode] = !$1
-      when /\A--no-dep-run\z/
-        @options[:run_script] = false
-      when /\A--add-all-core\z/
-        @options[:add_all_core] = true
-      when /\A--output\z/
-        path = argv.shift
-        @options[:output_override] = Pathname.new(path) if path
-      when /\A--dll\z/
-        path = argv.shift
-        @options[:extra_dlls] << path if path
-      when /\A--quiet\z/
-        @options[:quiet] = true
-      when /\A--verbose\z/
-        @options[:verbose] = true
-      when /\A--windows\z/
-        @options[:force_windows] = true
-      when /\A--console\z/
-        @options[:force_console] = true
-      when /\A--no-autoload\z/
-        @options[:load_autoload] = false
-      when /\A--chdir-first\z/
-        @options[:chdir_first] = true
-      when /\A--icon\z/
-        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/
-        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/
-        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/
-        puts "Ocran #{VERSION}"
-        exit 0
-      when /\A--no-warnings\z/
-        @options[:show_warnings] = false
-      when /\A--debug\z/
-        @options[:debug] = true
-      when /\A--debug-extract\z/
-        @options[:debug_extract] = true
-      when /\A--\z/
-        @options[:arg] = ARGV.dup
-        ARGV.clear
-      when /\A--(no-)?enc\z/
-        @options[:enc] = !$1
-      when /\A--(no-)?gem-(\w+)(?:=(.*))?$/
-        negate, group, list = $1, $2, $3
-        @options[:gem] << [negate, group.to_sym, list&.split(",")] if group
-      when /\A--help\z/, /\A--./
-        puts usage
-        exit 0
-      else
-        path = arg.dup
-
-        if !File.exist?(path) || Dir.empty?(path)
-          Ocran.fatal_error "#{path} not found!"
-        end
-
-        @options[:files] << path
-      end
-    end
-
-    if Ocran.debug_extract && Ocran.inno_script
-      Ocran.fatal_error "The --debug-extract option conflicts with use of Inno Setup"
-    end
-
-    if Ocran.lzma_mode && Ocran.inno_script
-      Ocran.fatal_error "LZMA compression must be disabled (--no-lzma) when using Inno Setup"
-    end
-
-    if !Ocran.chdir_first && Ocran.inno_script
-      Ocran.fatal_error "Chdir-first mode must be enabled (--chdir-first) when using Inno Setup"
-    end
-
-    if files.empty?
-      puts usage
-      exit 1
-    end
-
-    @options[:files].map! { |path|
-      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
-      Pathname.glob(path).map!(&:expand_path)
-    }.flatten!
-  end
-
-  def Ocran.init(argv)
-    save_environment
-    parseargs(argv)
-    find_stubs
-    IGNORE_MODULES.push(*ObjectSpace.each_object(Module).to_a)
-  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 Ocran.attempt_load_autoload
-    modules_checked = {}
-    IGNORE_MODULES.each { |m| modules_checked[m] = true }
-    loop do
-      modules_to_check = []
-      ObjectSpace.each_object(Module) do |mod|
-        modules_to_check << mod unless modules_checked.include?(mod)
-      end
-      break if modules_to_check.empty?
-      modules_to_check.each do |mod|
-        modules_checked[mod] = true
-        mod.constants.each do |const|
-          if mod.autoload?(const)
-            Ocran.msg "Attempting to trigger autoload of #{mod}::#{const}"
-            begin
-              mod.const_get(const)
-            rescue NameError
-              Ocran.warn "#{mod}::#{const} was defined autoloadable, but caused NameError"
-            rescue LoadError
-              Ocran.warn "#{mod}::#{const} was not loadable"
-            end
-          end
-        end
-      end
-    end
-  end
-
-  # Guess the load path (from 'paths') that was used to load
-  # 'path'. This is primarily relevant on Ruby 1.8 which stores
-  # "unqualified" paths in $LOADED_FEATURES.
-  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_path) }
-      # Guess the require'd feature
-      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.to_s.size }.first[0]
-      end
-    else
-      # Select the loadpaths that contain 'feature' and select the shortest
-      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_path }
-    src_prefix = src_files.inject(src_files.first.dirname) do |srcroot, path|
-      if path.subpath?(Host.exec_prefix)
-        srcroot
-      else
-        loop do
-          relpath = path.relative_path_from(srcroot)
-          if relpath.absolute?
-            Ocran.fatal_error "No common directory contains all specified files"
-          end
-          if relpath.to_s =~ /^\.\.\//
-            srcroot = srcroot.dirname
-          else
-            break
-          end
-        end
-        srcroot
-      end
-    end
-    src_files = src_files.map do |file|
-      if file.subpath?(src_prefix)
-        file.relative_path_from(src_prefix)
-      else
-        file
-      end
-    end
-    return src_prefix, src_files
-  end
-
-  # Searches for features that are loaded from gems, then produces a
-  # list of files included in those gems' manifests. Also returns a
-  # list of original features that are caused gems to be
-  # included. Ruby 1.8 provides Gem.loaded_specs to detect gems, but
-  # this is empty with Ruby 1.9. So instead, we look for any loaded
-  # file from a gem path.
-  def Ocran.find_gem_files(features)
-    features_from_gems = []
-    gems = {}
-
-    # If a Bundler Gemfile was provided, add all gems it specifies
-    if Ocran.gemfile
-      Ocran.msg "Scanning Gemfile"
-      # Load Rubygems and Bundler so we can scan the Gemfile
-      ["rubygems", "bundler"].each do |lib|
-        begin
-          require lib
-        rescue LoadError
-          Ocran.fatal_error "Couldn't scan Gemfile, unable to load #{lib}"
-        end
-      end
-
-      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"] ||= bundler_spec
-      end
-    end
-
-    if defined?(Gem)
-      # Include Gems that are loaded
-      Gem.loaded_specs.each { |gemname, spec| gems[gemname] ||= spec }
-      # Fall back to gem detection (loaded_specs are not population on
-      # all Ruby versions)
-      features.each do |feature|
-        # Detect load path unless absolute
-        if not feature.absolute?
-          feature = find_load_path(Pathname($:), feature)
-          next if feature.nil? # Could be enumerator.so
-        end
-        # Skip if found in known Gem dir
-        if gems.find { |gem, spec| feature.subpath?(spec.gem_dir) }
-          features_from_gems << feature
-          next
-        end
-        gempaths = Gem.path
-        gempaths.each do |gempath|
-          geminstallpath = Pathname(gempath) / "gems"
-          if feature.subpath?(geminstallpath)
-            gemlocalpath = feature.relative_path_from(geminstallpath)
-            fullgemname = gemlocalpath.to_s.split("/").first
-            gemspecpath = gempath / "specifications" / "#{fullgemname}.gemspec"
-            if spec = Gem::Specification.load(gemspecpath)
-              gems[spec.name] ||= spec
-              features_from_gems << feature
-            else
-              Ocran.warn "Failed to load gemspec for '#{fullgemname}'"
-            end
-          end
-        end
-      end
-
-      gem_files = []
-
-      gems.each do |gemname, spec|
-        if File.exist?(spec.spec_file) then
-          @gemspecs << Pathname(spec.spec_file)
-        else
-          spec_name = File.basename(spec.spec_file)
-          spec_path = File.dirname(spec.spec_file)
-          default_spec_file = spec_path + "/default/" + spec_name
-          if File.exist?(default_spec_file) then
-            @gemspecs << Pathname(default_spec_file)
-            Ocran.msg "Using default specification #{default_spec_file} for gem #{spec.full_name}"
-          end 
-        end
-
-        # Determine which set of files to include for this particular gem
-        include = [:loaded, :files]
-        Ocran.gem.each do |negate, option, list|
-          if list.nil? or 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
-              if negate
-                include.delete(:scripts)
-              else
-                include.push(:scripts)
-              end
-            when :files
-              if negate
-                include.delete(:files)
-              else
-                include.push(:files)
-              end
-            when :extras
-              if negate
-                include.delete(:extras)
-              else
-                include.push(:extras)
-              end
-            end
-          end
-        end
-
-        Ocran.msg "Detected gem #{spec.full_name} (#{include.join(", ")})"
-
-        gem_root = Pathname(spec.gem_dir)
-        gem_extension = (gem_root / ".." / ".." / "extensions").expand_path
-        if gem_extension.exist?
-          build_complete = gem_extension.find_all_files(/gem.build_complete/).select { |p| p.parent.to_s == spec.full_name }
-        else
-          build_complete = nil
-        end
-        gem_root_files = nil
-        files = []
-
-        unless gem_root.directory?
-          Ocran.warn "Gem #{spec.full_name} root folder was not found, skipping"
-          next
-        end
-
-        # Find the selected files
-        include.each do |set|
-          case set
-          when :spec
-            files << Pathname(spec.files)
-          when :loaded
-            files << features_from_gems.select { |feature| feature.subpath?(gem_root) }
-          when :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
-            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
-            files << gem_root_files.select { |path| path.relative_path_from(gem_root) =~ GEM_SCRIPT_RE }
-          end
-        end
-
-        files.flatten!
-        actual_files = files.select { |file| file.file? }
-
-        (files - actual_files).each do |missing_file|
-          Ocran.warn "#{missing_file} was not found"
-        end
-
-        total_size = actual_files.sum(0, &:size)
-        Ocran.msg "\t#{actual_files.size} files, #{total_size} bytes"
-
-        gem_files += actual_files
-      end
-      gem_files = sort_uniq(gem_files)
-    else
-      gem_files = []
-    end
-    features_from_gems -= gem_files
-    return gem_files, features_from_gems
-  end
-
-  def Ocran.build_exe
-    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
-
-    # If the script was run, then detect the features it used
-    if Ocran.run_script
-      # Attempt to autoload libraries before doing anything else.
-      attempt_load_autoload if Ocran.load_autoload
-    end
-
-    # Store the currently loaded files (before we require rbconfig for
-    # our own use).
-    features = $LOADED_FEATURES.map { |feature| Pathname(feature) }
-    
-    # Since https://github.com/rubygems/rubygems/commit/cad4cf16cf8fcc637d9da643ef97cf0be2ed63cb
-    # rubygems/core_ext/kernel_require.rb is evaled and thus missing in $LOADED_FEATURES, so we can't find it and need to add it manually
-    features.push(Pathname("rubygems/core_ext/kernel_require.rb"))
-
-    # Find gemspecs to include
-    if defined?(Gem)
-      @gemspecs = Gem.loaded_specs.map { |name, info| Pathname(info.loaded_from) }
-    else
-      @gemspecs = []
-    end
-
-    require "rbconfig"
-    instsitelibdir = Host.sitelibdir.relative_path_from(Host.exec_prefix)
-
-    load_path = []
-    src_load_path = []
-
-    # Find gems files and remove them from features
-    gem_files, features_from_gems = find_gem_files(features)
-    features -= features_from_gems
-
-    # Find the source root and adjust paths
-    src_prefix, src_files = find_src_root(Ocran.files)
-
-    # Include encoding support files
-    if Ocran.enc
-      all_load_paths.each do |path|
-        if path.subpath?(Host.exec_prefix)
-          encpath = path / "enc"
-          if encpath.exist?
-            encfiles = encpath.find_all_files(/\.so$/)
-            size = encfiles.sum(0, &:size)
-            Ocran.msg "Including #{encfiles.size} encoding support files (#{size} bytes, use --no-enc to exclude)"
-            features.push(*encfiles)
-          end
-        end
-      end
-    else
-      Ocran.msg "Not including encoding support files"
-    end
-
-    # Find features and decide where to put them in the temporary
-    # directory layout.
-    libs = []
-    features.each do |feature|
-      path = find_load_path(all_load_paths, feature)
-      if path.nil? || path.expand_path == Pathname.pwd
-        Ocran.files << feature
-      else
-        if feature.absolute?
-          feature = feature.relative_path_from(path.expand_path)
-        end
-        fullpath = feature.expand_path(path)
-
-        if fullpath.subpath?(Host.exec_prefix)
-          # Features found in the Ruby installation are put in the
-          # temporary Ruby installation.
-          libs << [fullpath, fullpath.relative_path_from(Host.exec_prefix)]
-        elsif defined?(Gem) and gemhome = Gem.path.find { |pth| fullpath.subpath?(pth) }
-          # Features found in any other Gem path (e.g. ~/.gems) is put
-          # in a special 'gemhome' folder.
-          targetpath = GEMHOMEDIR / fullpath.relative_path_from(Pathname(gemhome))
-          libs << [fullpath, targetpath]
-        elsif fullpath.subpath?(src_prefix) || path == working_directory
-          # Any feature found inside the src_prefix automatically gets
-          # added as a source file (to go in 'src').
-          Ocran.files << fullpath
-          # Add the load path unless it was added by the script while
-          # running (or we assume that the script can also set it up
-          # correctly when running from the resulting executable).
-          src_load_path << path unless @added_load_paths.include?(path)
-        elsif @added_load_paths.include?(path)
-          # Any feature that exist in a load path added by the script
-          # itself is added as a file to go into the 'src' (src_prefix
-          # will be adjusted below to point to the common parent).
-          Ocran.files << fullpath
-        else
-          # All other feature that can not be resolved go in the the
-          # Ruby sitelibdir. This is automatically in the load path
-          # when Ruby starts.
-          libs << [fullpath, instsitelibdir / feature]
-        end
-      end
-    end
-
-    # Recompute the src_prefix. Files may have been added implicitly
-    # while scanning through features.
-    src_prefix, src_files = find_src_root(Ocran.files)
-    Ocran.files.replace(src_files)
-
-    # Add the load path that are required with the correct path after
-    # src_prefix was adjusted.
-    load_path += src_load_path.map { |loadpath| TEMPDIR_ROOT / SRCDIR / loadpath.relative_path_from(src_prefix) }
-
-    # Decide where to put gem files, either the system gem folder, or
-    # GEMHOME.
-    gem_files.each do |gemfile|
-      if gemfile.subpath?(Host.exec_prefix)
-        libs << [gemfile, gemfile.relative_path_from(Host.exec_prefix)]
-      elsif defined?(Gem) and gemhome = Gem.path.find { |pth| gemfile.subpath?(pth) }
-        targetpath = GEMHOMEDIR / gemfile.relative_path_from(Pathname(gemhome))
-        libs << [gemfile, targetpath]
-      else
-        Ocran.fatal_error "Don't know where to put gemfile #{gemfile}"
-      end
-    end
-
-    # If requested, add all ruby standard libraries
-    if Ocran.add_all_core
-      Ocran.msg "Will include all ruby core libraries"
-      @load_path_before.each do |lp|
-        path = Pathname.new(lp)
-        next unless path.to_posix =~
-                    /\/(ruby\/(?:site_ruby\/|vendor_ruby\/)?[0-9.]+)\/?$/i
-        subdir = $1
-        Pathname.glob("#{lp}/**/*").each do |fpath|
-          next if fpath.directory?
-          tgt = "lib/#{subdir}/#{fpath.relative_path_from(path).to_posix}"
-          libs << [fpath, tgt]
-        end
-      end
-    end
-
-    # Detect additional DLLs
-    dlls = Ocran.autodll ? LibraryDetector.detect_dlls : []
-
-    # Detect external manifests
-    # 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.sub_ext(".exe")
-      executable.append_to_filename!("-debug") if Ocran.debug
-    end
-
-    windowed = (Ocran.files.first.ext?(".rbw") || Ocran.force_windows) && !Ocran.force_console
-
-    Ocran.msg "Building #{executable}"
-    target_script = nil
-    OcranBuilder.new(executable, windowed) do |sb|
-      # Add explicitly mentioned files
-      Ocran.msg "Adding user-supplied source files"
-      Ocran.files.each do |file|
-        file = src_prefix / file
-        if file.subpath?(Host.exec_prefix)
-          target = file.relative_path_from(Host.exec_prefix)
-        elsif file.subpath?(src_prefix)
-          target = SRCDIR / file.relative_path_from(src_prefix)
-        else
-          target = SRCDIR / file.basename
-        end
-
-        target_script ||= target
-
-        if file.directory?
-          sb.ensuremkdir(target)
-        else
-          begin
-            sb.createfile(file, target)
-          rescue Errno::ENOENT
-            raise unless file =~ IGNORE_MODULE_NAMES
-          end
-        end
-      end
-
-      # Add the ruby executable and DLL
-      if windowed
-        rubyexe = Host.rubyw_exe
-      else
-        rubyexe = Host.ruby_exe
-      end
-      Ocran.msg "Adding ruby executable #{rubyexe}"
-      sb.createfile(Host.bindir / rubyexe, BINDIR / rubyexe)
-      if Host.libruby_so
-        sb.createfile(Host.bindir / Host.libruby_so, BINDIR / Host.libruby_so)
-      end
-
-      # Add detected DLLs
-      dlls.each do |dll|
-        Ocran.msg "Adding detected DLL #{dll}"
-        if dll.subpath?(Host.exec_prefix)
-          target = dll.relative_path_from(Host.exec_prefix)
-        else
-          target = BINDIR / File.basename(dll)
-        end
-        sb.createfile(dll, target)
-      end
-
-      # Add external manifest files
-      manifests.each do |manifest|
-        Ocran.msg "Adding external manifest #{manifest}"
-        target = manifest.relative_path_from(Host.exec_prefix)
-        sb.createfile(manifest, target)
-      end
-
-      # Add extra DLLs specified on the command line
-      Ocran.extra_dlls.each do |dll|
-        Ocran.msg "Adding supplied DLL #{dll}"
-        sb.createfile(Host.bindir / dll, BINDIR / dll)
-      end
-
-      # Add gemspec files
-      @gemspecs = sort_uniq(@gemspecs)
-      @gemspecs.each do |gemspec|
-        if gemspec.subpath?(Host.exec_prefix)
-          path = gemspec.relative_path_from(Host.exec_prefix)
-          sb.createfile(gemspec, path)
-        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."
-        end
-      end
-
-      # Add loaded libraries (features, gems)
-      Ocran.msg "Adding library files"
-      libs.each do |path, target|
-        sb.createfile(path, target)
-      end
-
-      # 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
-      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"] || "")
-      sb.setenv("RUBYLIB", load_path.map { |path| path.to_native }.uniq.join(";"))
-
-      sb.setenv("GEM_PATH", (TEMPDIR_ROOT / GEMHOMEDIR).to_native)
-
-      # Add the opcode to launch the script
-      extra_arg = Ocran.arg.map { |arg| ' "' + arg.gsub("\"", "\\\"") + '"' }.join
-      installed_ruby_exe = TEMPDIR_ROOT / BINDIR / rubyexe
-      launch_script = (TEMPDIR_ROOT / target_script).to_native
-      sb.postcreateprocess(installed_ruby_exe,
-                           "#{rubyexe} \"#{launch_script}\"#{extra_arg}")
-    end
-
-    unless Ocran.inno_script
-      Ocran.msg "Finished building #{executable} (#{File.size(executable)} bytes)"
-    end
-  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/import"
-      require "fiddle/types"
-
-      extend Fiddle::Importer
-      dlload "kernel32.dll", "psapi.dll"
-
-      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
-
-    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
-        Ocran.Pathname(str[0, length])
-      end
-    end
-
-    def LibraryDetector.detect_dlls
-      loaded = loaded_dlls
-      exec_prefix = Host.exec_prefix
-      loaded.select { |path| path.subpath?(exec_prefix) && path.basename.ext?(".dll") && path.basename != Host.libruby_so }
-    end
-  end
-
-  # Utility class that produces the actual executable. Opcodes
-  # (createfile, mkdir etc) are added by invoking methods on an
-  # instance of OcranBuilder.
-  class OcranBuilder
-    Signature = [0x41, 0xb6, 0xba, 0x4e]
-    OP_END = 0
-    OP_CREATE_DIRECTORY = 1
-    OP_CREATE_FILE = 2
-    OP_CREATE_PROCESS = 3
-    OP_DECOMPRESS_LZMA = 4
-    OP_SETENV = 5
-    OP_POST_CREATE_PROCESS = 6
-    OP_ENABLE_DEBUG_MODE = 7
-    OP_CREATE_INST_DIRECTORY = 8
-
-    attr_reader :files
-
-    def initialize(path, windowed)
-      @paths = {}
-      @files = {}
-      File.open(path, "wb") do |ocranfile|
-        image = nil
-        if windowed
-          image = Ocran.stubwimage
-        else
-          image = Ocran.stubimage
-        end
-
-        unless image
-          Ocran.fatal_error "Stub image not available"
-        end
-        ocranfile.write(image)
-      end
-
-      if Ocran.icon_filename
-        system Ocran.ediconpath.to_s, path.to_s, Ocran.icon_filename.to_s
-      end
-
-      opcode_offset = File.size(path)
-
-      File.open(path, "ab") do |ocranfile|
-        tmpinpath = "tmpin"
-
-        if Ocran.lzma_mode
-          @of = File.open(tmpinpath, "wb")
-        else
-          @of = ocranfile
-        end
-
-        if Ocran.debug
-          Ocran.msg("Enabling debug mode in executable")
-          ocranfile.write([OP_ENABLE_DEBUG_MODE].pack("V"))
-        end
-
-        createinstdir Ocran.debug_extract, !Ocran.debug_extract, Ocran.chdir_first
-
-        yield(self)
-
-        @of.close if Ocran.lzma_mode
-
-        if Ocran.lzma_mode and not Ocran.inno_script
-          tmpoutpath = "tmpout"
-          begin
-            data_size = File.size(tmpinpath)
-            Ocran.msg "Compressing #{data_size} bytes"
-            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)
-          ensure
-            File.unlink(@of.path) if File.exist?(@of.path)
-            File.unlink(tmpoutpath) if File.exist?(tmpoutpath)
-          end
-        end
-
-        ocranfile.write([OP_END].pack("V"))
-        ocranfile.write([opcode_offset].pack("V")) # Pointer to start of opcodes
-        ocranfile.write(Signature.pack("C*"))
-      end
-
-      if Ocran.inno_script
-        begin
-          iss = File.read(Ocran.inno_script) + "\n\n"
-
-          iss << "[Dirs]\n"
-          @paths.each_key do |p|
-            iss << "Name: \"{app}/#{p}\"\n"
-          end
-          iss << "\n"
-
-          iss << "[Files]\n"
-          path_escaped = path.to_s.gsub('"', '""')
-          iss << "Source: \"#{path_escaped}\"; DestDir: \"{app}\"\n"
-          @files.each do |tgt, src|
-            src_escaped = src.to_s.gsub('"', '""')
-            target_dir_escaped = Pathname.new(tgt).dirname.to_s.gsub('"', '""')
-            iss << "Source: \"#{src_escaped}\"; DestDir: \"{app}/#{target_dir_escaped}\"\n" unless src_escaped =~ IGNORE_MODULE_NAMES
-          end
-          iss << "\n"
-
-          Ocran.verbose_msg "### INNOSETUP SCRIPT ###\n\n#{iss}\n\n"
-
-          f = File.open("ocrantemp.iss", "w")
-          f.write(iss)
-          f.close()
-
-          iscc_cmd = ["iscc"]
-          iscc_cmd << "/Q" unless Ocran.verbose
-          iscc_cmd << "ocrantemp.iss"
-          Ocran.msg "Running InnoSetup compiler ISCC"
-          result = system(*iscc_cmd)
-          if not result
-            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")
-            else raise RuntimeError.new("ISCC failed to run. Is the InnoSetup directory in your PATH?")
-            end
-          end
-        rescue Exception => e
-          Ocran.fatal_error("InnoSetup installer creation failed: #{e.message}")
-        ensure
-          File.unlink("ocrantemp.iss") if File.exist?("ocrantemp.iss")
-          File.unlink(path) if File.exist?(path)
-        end
-      end
-    end
-
-    def mkdir(path)
-      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*")
-      end
-    end
-
-    def ensuremkdir(tgt)
-      tgt = Ocran.Pathname(tgt)
-      return if tgt.to_s == "."
-      if not @paths[tgt.to_posix.downcase]
-        ensuremkdir(tgt.dirname)
-        mkdir(tgt)
-      end
-    end
-
-    def createinstdir(next_to_exe = false, delete_after = false, chdir_before = false)
-      unless Ocran.inno_script # Creation of installation directory will be handled by InnoSetup
-        @of << [OP_CREATE_INST_DIRECTORY, next_to_exe ? 1 : 0, delete_after ? 1 : 0, chdir_before ? 1 : 0].pack("VVVV")
-      end
-    end
-
-    def createfile(src, tgt)
-      return if @files[tgt]
-      @files[tgt] = src
-      src, tgt = Ocran.Pathname(src), Ocran.Pathname(tgt)
-      ensuremkdir(tgt.dirname)
-      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")
-        @of << str
-      end
-    end
-
-    def hasFile?(src)
-    end
-
-    def createprocess(image, cmdline)
-      Ocran.verbose_msg "l #{showtempdir image} #{showtempdir cmdline}"
-      @of << [OP_CREATE_PROCESS, image.to_native, cmdline].pack("VZ*Z*")
-    end
-
-    def postcreateprocess(image, cmdline)
-      Ocran.verbose_msg "p #{showtempdir image} #{showtempdir cmdline}"
-      @of << [OP_POST_CREATE_PROCESS, image.to_native, cmdline].pack("VZ*Z*")
-    end
-
-    def setenv(name, value)
-      Ocran.verbose_msg "e #{name} #{showtempdir value}"
-      @of << [OP_SETENV, name, value].pack("VZ*Z*")
-    end
-
-    def close
-      @of.close
-    end
-
-    def showtempdir(x)
-      x.to_s.gsub(TEMPDIR_ROOT.to_s, "<tempdir>")
-    end
-  end # class OcranBuilder
-end # module Ocran
-
-if File.basename(__FILE__) == File.basename($0)
-  Ocran.init(ARGV)
-  ARGV.replace(Ocran.arg)
-
-  if not Ocran.files.first.exist?
-    Ocran.fatal_error "#{Ocran.files[0]} was not found!"
-  end
-
-  at_exit do
-    if $!.nil? or $!.kind_of?(SystemExit)
-      Ocran.build_exe
-      exit 0
-    end
-  end
-
-  if Ocran.run_script
-    Ocran.msg "Loading script to check dependencies"
-    $0 = Ocran.files.first.to_s
-    load Ocran.files.first
-  end
-end
+load File.expand_path("../lib/ocran/runner.rb", __dir__)
+load Ocran::Runner.new.run