aibika 1.3.12

data/lib/aibika/aibika_builder.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Aibika
+  # Utility class that produces the actual executable. Opcodes
+  # (createfile, mkdir etc) are added by invoking methods on an
+  # instance of AibikaBuilder.
+  class AibikaBuilder
+    Signature = [0x41, 0xb6, 0xba, 0x4e].freeze
+    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
+
+    def initialize(path, windowed)
+      @paths = {}
+      @files = {}
+      File.open(path, 'wb') do |aibikafile|
+        image = if windowed
+                  Aibika.stubwimage
+                else
+                  Aibika.stubimage
+                end
+
+        Aibika.fatal_error 'Stub image not available' unless image
+        aibikafile.write(image)
+      end
+
+      system Aibika.ediconpath, path, Aibika.icon_filename if Aibika.icon_filename
+
+      opcode_offset = File.size(path)
+
+      File.open(path, 'ab') do |aibikafile|
+        tmpinpath = 'tmpin'
+
+        @of = if Aibika.lzma_mode
+                File.open(tmpinpath, 'wb')
+              else
+                aibikafile
+              end
+
+        if Aibika.debug
+          Aibika.msg('Enabling debug mode in executable')
+          aibikafile.write([OP_ENABLE_DEBUG_MODE].pack('V'))
+        end
+
+        createinstdir Aibika.debug_extract, !Aibika.debug_extract, Aibika.chdir_first
+
+        yield(self)
+
+        @of.close if Aibika.lzma_mode
+
+        if Aibika.lzma_mode && !Aibika.inno_script
+          tmpoutpath = 'tmpout'
+          begin
+            data_size = File.size(tmpinpath)
+            Aibika.msg "Compressing #{data_size} bytes"
+            system(Aibika.lzmapath, 'e', tmpinpath, tmpoutpath) or raise
+            compressed_data_size = File.size?(tmpoutpath)
+            aibikafile.write([OP_DECOMPRESS_LZMA, compressed_data_size].pack('VV'))
+            IO.copy_stream(tmpoutpath, aibikafile)
+          ensure
+            File.unlink(@of.path) if File.exist?(@of.path)
+            File.unlink(tmpoutpath) if File.exist?(tmpoutpath)
+          end
+        end
+
+        aibikafile.write([OP_END].pack('V'))
+        aibikafile.write([opcode_offset].pack('V')) # Pointer to start of opcodes
+        aibikafile.write(Signature.pack('C*'))
+      end
+
+      return unless Aibika.inno_script
+
+      begin
+        iss = "#{File.read(Aibika.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('"', '""')
+          unless src_escaped =~ IGNORE_MODULE_NAMES
+            iss << "Source: \"#{src_escaped}\"; DestDir: \"{app}/#{target_dir_escaped}\"\n"
+          end
+        end
+        iss << "\n"
+
+        Aibika.verbose_msg "### INNOSETUP SCRIPT ###\n\n#{iss}\n\n"
+
+        f = File.open('aibikatemp.iss', 'w')
+        f.write(iss)
+        f.close
+
+        iscc_cmd = ['iscc']
+        iscc_cmd << '/Q' unless Aibika.verbose
+        iscc_cmd << 'aibikatemp.iss'
+        Aibika.msg 'Running InnoSetup compiler ISCC'
+        result = system(*iscc_cmd)
+        unless result
+          case $CHILD_STATUS
+          when 0 then raise 'ISCC reported success, but system reported error?'
+          when 1 then raise 'ISCC reports invalid command line parameters'
+          when 2 then raise 'ISCC reports that compilation failed'
+          else raise 'ISCC failed to run. Is the InnoSetup directory in your PATH?'
+          end
+        end
+      rescue Exception => e
+        Aibika.fatal_error("InnoSetup installer creation failed: #{e.message}")
+      ensure
+        File.unlink('aibikatemp.iss') if File.exist?('aibikatemp.iss')
+        File.unlink(path) if File.exist?(path)
+      end
+    end
+
+    def mkdir(path)
+      return if @paths[path.path.downcase]
+
+      @paths[path.path.downcase] = true
+      Aibika.verbose_msg "m #{showtempdir path}"
+      return if Aibika.inno_script # The directory will be created by InnoSetup with a [Dirs] statement
+
+      @of << [OP_CREATE_DIRECTORY, path.to_native].pack('VZ*')
+    end
+
+    def ensuremkdir(tgt)
+      tgt = Aibika.Pathname(tgt)
+      return if tgt.path == '.'
+
+      return if @paths[tgt.to_posix.downcase]
+
+      ensuremkdir(tgt.dirname)
+      mkdir(tgt)
+    end
+
+    def createinstdir(next_to_exe = false, delete_after = false, chdir_before = false)
+      return if Aibika.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
+
+    def createfile(src, tgt)
+      return if @files[tgt]
+
+      @files[tgt] = src
+      src = Aibika.Pathname(src)
+      tgt = Aibika.Pathname(tgt)
+      ensuremkdir(tgt.dirname)
+      str = File.open(src, 'rb', &:read)
+      Aibika.verbose_msg "a #{showtempdir tgt}"
+      return if Aibika.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
+
+    def createprocess(image, cmdline)
+      Aibika.verbose_msg "l #{showtempdir image} #{showtempdir cmdline}"
+      @of << [OP_CREATE_PROCESS, image.to_native, cmdline].pack('VZ*Z*')
+    end
+
+    def postcreateprocess(image, cmdline)
+      Aibika.verbose_msg "p #{showtempdir image} #{showtempdir cmdline}"
+      @of << [OP_POST_CREATE_PROCESS, image.to_native, cmdline].pack('VZ*Z*')
+    end
+
+    def setenv(name, value)
+      Aibika.verbose_msg "e #{name} #{showtempdir value}"
+      @of << [OP_SETENV, name, value].pack('VZ*Z*')
+    end
+
+    def close
+      @of.close
+    end
+
+    def showtempdir(tdir)
+      tdir.to_s.gsub(TEMPDIR_ROOT, '<tempdir>')
+    end
+  end
+end

data/lib/aibika/cli.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+# Aibika front-end
+module Aibika
+  def self.parseargs(argv)
+    usage = <<~USG
+      aibika [options] script.rb
+
+      Aibika 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
+      --allow-self       Include self (aibika gem) if detected or specified
+          This option is required only if aibika gem is deployed as a part
+          of broader bundled your solution
+
+      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.
+      --debug            Executable will be verbose.
+      --debug-extract    Executable will unpack to local dir and not delete after.
+    USG
+
+    while (arg = argv.shift)
+      case arg
+      when /\A--(no-)?lzma\z/
+        @options[:lzma_mode] = !::Regexp.last_match(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/
+        @options[:output_override] = Pathname(argv.shift)
+      when /\A--dll\z/
+        @options[:extra_dlls] << argv.shift
+      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/
+        @options[:icon_filename] = Pathname(argv.shift)
+        Aibika.fatal_error "Icon file #{icon_filename} not found.\n" unless icon_filename.exist?
+      when /\A--gemfile\z/
+        @options[:gemfile] = Pathname(argv.shift)
+        Aibika.fatal_error "Gemfile #{gemfile} not found.\n" unless gemfile.exist?
+      when /\A--innosetup\z/
+        @options[:inno_script] = Pathname(argv.shift)
+        Aibika.fatal_error "Inno Script #{inno_script} not found.\n" unless inno_script.exist?
+      when /\A--no-autodll\z/
+        @options[:autodll] = false
+      when /\A--version\z/
+        puts "Aibika #{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] = !::Regexp.last_match(1)
+      when /\A--(no-)?gem-(\w+)(?:=(.*))?$/
+        negate = ::Regexp.last_match(1)
+        group = ::Regexp.last_match(2)
+        list = ::Regexp.last_match(3)
+        @options[:gem] ||= []
+        @options[:gem] << [negate, group.to_sym, list && list.split(',')]
+      when /\A--help\z/, /\A--./
+        puts usage
+        exit 0
+      else
+        @options[:files] << if __FILE__.respond_to?(:encoding)
+                              arg.dup.force_encoding(__FILE__.encoding)
+                            else
+                              arg
+                            end
+      end
+    end
+
+    if Aibika.debug_extract && Aibika.inno_script
+      Aibika.fatal_error 'The --debug-extract option conflicts with use of Inno Setup'
+    end
+
+    if Aibika.lzma_mode && Aibika.inno_script
+      Aibika.fatal_error 'LZMA compression must be disabled (--no-lzma) when using Inno Setup'
+    end
+
+    if !Aibika.chdir_first && Aibika.inno_script
+      Aibika.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! do |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
+      files = Dir[path]
+      Aibika.fatal_error "#{path} not found!" if files.empty?
+      files.map { |pth| Pathname(pth).expand }
+    end.flatten!
+  end
+
+  def self.msg(msg)
+    puts "=== #{msg}" unless Aibika.quiet
+  end
+
+  def self.verbose_msg(msg)
+    puts msg if Aibika.verbose && !Aibika.quiet
+  end
+
+  def self.warn(msg)
+    msg "WARNING: #{msg}" if Aibika.show_warnings
+  end
+
+  def self.fatal_error(msg)
+    puts "ERROR: #{msg}"
+    exit 1
+  end
+end

data/lib/aibika/host.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Aibika
+  # Variables describing the host's build environment.
+  module Host
+    class << self
+      def exec_prefix
+        @exec_prefix ||= Aibika.Pathname(RbConfig::CONFIG['exec_prefix'])
+      end
+
+      def sitelibdir
+        @sitelibdir ||= Aibika.Pathname(RbConfig::CONFIG['sitelibdir'])
+      end
+
+      def bindir
+        @bindir ||= Aibika.Pathname(RbConfig::CONFIG['bindir'])
+      end
+
+      def libruby_so
+        @libruby_so ||= Aibika.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 ||= Aibika.Pathname(ENV['TEMP'])
+      end
+    end
+  end
+end

data/lib/aibika/library_detector.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Aibika
+  module LibraryDetector
+    def self.init_fiddle
+      require 'fiddle'
+      require 'fiddle/types'
+      module_eval do
+        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
+    end
+
+    def self.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
+        f_single = 'Q'
+        f_array  = 'Q*'
+      else
+        f_single = 'I'
+        f_array = 'I*'
+      end
+
+      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)
+        enumprocessmodules.call(process_handle, module_handle_buffer, module_handle_buffer.size,
+                                bytes_needed_buffer)
+        bytes_needed = bytes_needed_buffer.unpack1(f_single)
+        break if bytes_needed <= module_handle_buffer.size
+      end
+
+      handles = module_handle_buffer.unpack(f_array)
+      handles.select(&:positive?).map do |handle|
+        str = "\x00\x00" * 256
+        modulefilename_length = getmodulefilename.call(handle, str, str.size)
+        unless modulefilename_length.positive?
+          errorcode = getlasterror.call
+          Aibika.fatal_error "LibraryDetector: GetModuleFileNameW failed with error code 0x#{errorcode.to_s(16)}"
+        end
+        modulefilename = str[0, modulefilename_length * 2].force_encoding('UTF-16LE').encode('UTF-8')
+        Aibika.Pathname(modulefilename)
+      end
+    end
+
+    def self.detect_dlls
+      loaded = loaded_dlls
+      exec_prefix = Host.exec_prefix
+      loaded.select do |path|
+        path.subpath?(exec_prefix) && path.basename.ext?('.dll') && path.basename != Host.libruby_so
+      end
+    end
+  end
+end

data/lib/aibika/pathname.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Aibika
+  # 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 self.pwd
+      Pathname.new(Dir.pwd.encode('UTF-8'))
+    end
+
+    def self.pathequal(path_a, path_b)
+      path_a.downcase == path_b.downcase
+    end
+
+    attr_reader :path
+
+    File::ALT_SEPARATOR = '\\' if File::ALT_SEPARATOR.nil?
+    SEPARATOR_PAT = /[#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}]/.freeze # }
+    ABSOLUTE_PAT = /\A([A-Z]:)?#{SEPARATOR_PAT}/i.freeze
+
+    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.path.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?
+
+      b.size.times { a.unshift '..' }
+      Pathname.new(a.join('/'))
+    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 = Aibika.Pathname(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 = Aibika.Pathname(other)
+      if other.absolute?
+        other
+      else
+        Aibika.Pathname("#{@path}/#{other.path}")
+      end
+    end
+
+    def append_to_filename!(append)
+      @path.sub!(/(\.[^.]*?|)$/) { append.to_s + ::Regexp.last_match(1) }
+    end
+
+    def ext(new_ext = nil)
+      if new_ext
+        Pathname.new(@path.sub(/(\.[^.]*?)?$/) { new_ext })
+      else
+        File.extname(@path)
+      end
+    end
+
+    def ext?(expected_ext)
+      Pathname.pathequal(ext, expected_ext)
+    end
+
+    def entries
+      Dir.entries(@path).map { |e| self / e.encode('UTF-8') }
+    end
+
+    # Recursively find all files which match a specified regular
+    # expression.
+    def find_all_files(reg)
+      entries.map do |pn|
+        if pn.directory?
+          if pn.basename =~ /^\.\.?$/
+            []
+          else
+            pn.find_all_files(reg)
+          end
+        elsif pn.file?
+          if pn.basename =~ reg
+            pn
+          else
+            []
+          end
+        end
+      end.flatten
+    end
+
+    def ==(other)
+      to_posix.downcase == other.to_posix.downcase
+    end
+
+    def =~(other)
+      @path =~ other
+    end
+
+    def <=>(other)
+      @path.casecmp(other.path)
+    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 && Aibika.Pathname(dir)))
+    end
+
+    def size
+      File.size(@path)
+    end
+
+    alias to_s to_posix
+    alias to_str to_posix
+  end
+end

data/lib/aibika/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Aibika
+  VERSION = '1.3.12'
+end