neri 0.9.6 → 1.1.0

data/lib/neri/build.rb

@@ -2,12 +2,11 @@
 
 require "neri"
 
-module Neri
+module NeriBuild
   @data_files = []
 
   @options = {
     quiet:   false,
-    verbose: false,
 
     external_encoding: nil,
 
@@ -16,7 +15,7 @@ module Neri
     gems:     [],
     encoding: "*",
 
-    enable_gems:         false,
+    enable_gems:         true,
     enable_did_you_mean: false,
     chdir_first:         true,
     pause_last:          nil,
@@ -30,39 +29,22 @@ module Neri
     virtual_directory: nil,
 
     no_exe: false,
-    use_b2ec: false,
-    b2ec_path: "Bat_To_Exe_Converter",
-    b2ec: {
-      icon: File.expand_path("#{File.dirname(__FILE__)}/../../share/default.ico"),
-      invisible:        nil,
-      x64:              nil,
-      uac_admin:        nil,
-      fileversion:      nil,
-      productversion:   nil,
-      productname:      nil,
-      originalfilename: nil,
-      internalname:     nil,
-      description:      nil,
-      company:          nil,
-      trademarks:       nil,
-      copyright:        nil,
-      privatebuild:     nil,
-      specialbuild:     nil,
-      comments:         nil
-    },
-
-    use_upx:     false,
-    upx_path:    "upx",
-    upx_targets: ["bin/**/*.dll"],
-    upx_options: "",
-
-    zipfile:       nil,
-    sevenzip_path: "7z",
-
-    inno_script: nil,
-    iscc_path:   "iscc"
+    icon: File.expand_path("#{File.dirname(__FILE__)}/../../share/default.ico"),
+    invisible:        nil,
+    fileversion:      nil,
+    productversion:   nil,
+    productname:      nil,
+    originalfilename: nil,
+    internalname:     nil,
+    description:      nil,
+    company:          nil,
+    trademarks:       nil,
+    copyright:        nil,
+    privatebuild:     nil,
+    specialbuild:     nil,
+    comments:         nil
   }
-  @rubyopt = ENV["RUBYOPT"].to_s
+  @rubyopt = ENV["RUBYOPT"].to_s.encode(Encoding::UTF_8)
   @args = ""
   @encryption_key = nil
 
@@ -70,8 +52,33 @@ module Neri
   @use_dxruby_tiled = false
   @use_ayame        = false
 
+  @require_paths = {}
+
   class << self
-    attr_reader :options
+    def gemspec_path(file)
+      return nil unless file.match?(%r{/gems/\d+\.\d+\.\d+/gems/(.+?-[^/]+)/})
+
+      file.sub(%r{(/gems/\d+\.\d+\.\d+)/gems/(.+?-[^/]+)/.+\z}) do
+        "#{Regexp.last_match(1)}/specifications/#{Regexp.last_match(2)}.gemspec"
+      end
+    end
+
+    def gem_require_paths(file)
+      path = gemspec_path(file)
+      return nil unless path
+      return @require_paths[path] if @require_paths.key?(path)
+
+      @require_paths[path] = ["lib/"]
+      if File.exist?(path)
+        gemspec = File.binread(path)
+        if gemspec.match(/\.require_paths\s*=\s*\[([^\]]+)\]/)
+          @require_paths[path] = Regexp.last_match(1).scan(/['"]([^'"]+)['"]/).flatten.map do |p|
+            "#{p.delete_suffix('/')}/"
+          end
+        end
+      end
+      @require_paths[path]
+    end
 
     def relative_path(path, basedir = rubydir, prepath = "")
       basedir.concat(File::SEPARATOR) unless basedir.end_with?(File::SEPARATOR)
@@ -87,8 +94,8 @@ module Neri
     def rubyexe   ; RbConfig.ruby; end
     def scriptfile; @data_files.first; end
     def basename  ; File.basename(scriptfile, ".*"); end
-    def basepath  ; File.join(options[:output_dir], basename); end
-    def datafile  ; File.join(options[:output_dir], options[:system_dir], options[:datafile]); end
+    def basepath  ; File.join(@options[:output_dir], basename); end
+    def datafile  ; File.join(@options[:output_dir], @options[:system_dir], @options[:datafile]); end
 
     # --help
     def output_help
@@ -99,7 +106,6 @@ options:
   --help or -h
   --version or -v
   --quiet
-  --verbose
 
   --external-encoding <encoding>
 
@@ -110,8 +116,8 @@ options:
   --no-enc
   --encoding <enc1>,<enc2>,...
 
-  --enable-gems
-  --enable-did-you-mean
+  --enable-gems / --disable-gems
+  --enable-did-you-mean / --disable-did-you-mean
   --no-chdir
   --pause-last
   --no-pause-last
@@ -121,15 +127,12 @@ options:
   --system-dir <dirname>
   --datafile <filename>
   --encryption-key <key>
+  --virtual-directory <string>
 
-  --no-exe
-  --use-b2ec
-  --b2ec-path <bat_to_exe_converter_path>
+  --no-exe or --bat
   --icon <iconfile>
   --windows or --invisible
   --console or --visible
-  --x64
-  --uac-admin
   --fileversion <string>     # ex) 1,2,3,4
   --productversion <string>  # ex) 1,2,3,4
   --productname <string>
@@ -142,21 +145,6 @@ options:
   --privatebuild <string>
   --specialbuild <string>
   --comments <string>
-
-  --use-upx
-  --upx-path <upx path>
-  --upx_targets '<glob>'  # ex) 'bin/**/*.dll'
-  --upx-options <options>
-
-  --zipfile <filename>
-  --7zip-path <7-zip path>
-
-  --innosetup <inno_script>
-  --iscc-path <iscc path>
-
-  --create-recipe <recipefile>
-  --recipe <recipefile>
-  --virtual-directory <string>
       HELP_MESSAGE
     end
 
@@ -165,25 +153,9 @@ options:
       puts "Neri #{Neri::VERSION}"
     end
 
-    # --create-recipe
-    def create_recipe(file, hash = options, pre = "Neri.options")
-      hash.each_pair do |key, value|
-        case value
-        when Hash
-          create_recipe(file, value, pre + "[:#{key}]")
-        when Numeric, TrueClass, FalseClass
-          file.puts "#{pre}[:#{key}] = #{value}"
-        when NilClass
-          file.puts "#{pre}[:#{key}] = nil"
-        when String, Array
-          file.puts "#{pre}[:#{key}] = " + JSON.generate(value)
-        end
-      end
-    end
-
-    def check_options
-      nputs_v "Checking Neri options."
-      while arg = ARGV.shift
+    def load_options(argv)
+      until argv.empty?
+        arg = argv.shift
         case arg
         when "--help", "-h"
           output_help
@@ -192,112 +164,80 @@ options:
           output_version
           exit
         when "--quiet", "-q"
-          options[:quiet] = true
-        when "--verbose"
-          options[:verbose] = true
-        when "--external_encoding"
-          options[:external_encoding] = ARGV.shift
+          @options[:quiet] = true
+        when "--external-encoding"
+          @options[:external_encoding] = argv.shift
         when "--dll"
-          options[:dlls] += ARGV.shift.split(",").map(&:strip)
+          @options[:dlls] += argv.shift.split(",").map(&:strip)
         when "--lib"
-          options[:libs] += ARGV.shift.split(",").map(&:strip)
+          @options[:libs] += argv.shift.split(",").map(&:strip)
         when "--gem"
-          options[:gems] += ARGV.shift.split(",").map(&:strip)
+          @options[:gems] += argv.shift.split(",").map(&:strip)
         when "--no-enc"
-          options[:encoding] = nil
+          @options[:encoding] = nil
         when "--encoding"
-          options[:encoding] = ARGV.shift
+          @options[:encoding] = argv.shift
         when "--enable-gems"
-          options[:enable_gems] = true
+          @options[:enable_gems] = true
+        when "--disale-gems"
+          @options[:enable_gems] = false
         when "--enable-did-you-mean"
-          options[:enable_did_you_mean] = true
+          @options[:enable_did_you_mean] = true
+        when "--disale-did-you-mean"
+          @options[:enable_did_you_mean] = false
         when "--no-chdir"
-          options[:chdir_first] = false
+          @options[:chdir_first] = false
         when "--chdir-first" # deprecated
-          options[:chdir_first] = true
+          @options[:chdir_first] = true
         when "--pause-last"
-          options[:pause_last] = true
+          @options[:pause_last] = true
         when "--no-pause-last"
-          options[:pause_last] = false
+          @options[:pause_last] = false
         when "--pause-text"
-          options[:pause_text] = ARGV.shift.encode("utf-8")
-          options[:pause_last] = true
+          @options[:pause_text] = argv.shift
+          @options[:pause_last] = true
         when "--output-dir"
-          options[:output_dir] = ARGV.shift.encode("utf-8")
+          @options[:output_dir] = argv.shift
         when "--system-dir"
-          options[:system_dir] = ARGV.shift.encode("utf-8")
+          @options[:system_dir] = argv.shift
         when "--datafile"
-          options[:datafile] = ARGV.shift.encode("utf-8")
+          @options[:datafile] = argv.shift
         when "--encryption-key"
-          options[:encryption_key] = ARGV.shift.encode("utf-8")
-        when "--no-exe"
-          options[:no_exe] = true
-        when "--use-b2ec"
-          options[:use_b2ec] = true
-        when "--b2ec-path"
-          options[:b2ec_path] = ARGV.shift.encode("utf-8")
+          @options[:encryption_key] = argv.shift
+        when "--virtual-directory"
+          @options[:virtual_directory] = argv.shift
+        when "--no-exe", "--bat"
+          @options[:no_exe] = true
         when "--icon"
-          options[:b2ec][:icon] = ARGV.shift.encode("utf-8")
+          @options[:icon] = argv.shift
         when "--windows", "--invisible"
-          options[:b2ec][:invisible] = true
+          @options[:invisible] = true
         when "--console", "--visible"
-          options[:b2ec][:invisible] = false
-        when "--x64"
-          options[:b2ec][:x64] = true
-        when "--uac-admin"
-          options[:b2ec][:uac_admin] = true
+          @options[:invisible] = false
         when "--fileversion"
-          options[:b2ec][:fileversion] = ARGV.shift
+          @options[:fileversion] = argv.shift
         when "--productversion"
-          options[:b2ec][:productversion] = ARGV.shift
+          @options[:productversion] = argv.shift
         when "--productname"
-          options[:b2ec][:productname] = ARGV.shift.encode("utf-8")
+          @options[:productname] = argv.shift
         when "--originalfilename"
-          options[:b2ec][:originalfilename] = ARGV.shift.encode("utf-8")
+          @options[:originalfilename] = argv.shift
         when "--internalname"
-          options[:b2ec][:internalname] = ARGV.shift.encode("utf-8")
+          @options[:internalname] = argv.shift
         when "--description"
-          options[:b2ec][:description] = ARGV.shift.encode("utf-8")
+          @options[:description] = argv.shift
         when "--company"
-          options[:b2ec][:company] = ARGV.shift.encode("utf-8")
+          @options[:company] = argv.shift
         when "--trademarks"
-          options[:b2ec][:trademarks] = ARGV.shift.encode("utf-8")
+          @options[:trademarks] = argv.shift
         when "--copyright"
-          options[:b2ec][:copyright] = ARGV.shift.encode("utf-8")
+          @options[:copyright] = argv.shift
         when "--privatebuild"
-          options[:b2ec][:privatebuild] = ARGV.shift.encode("utf-8")
+          @options[:privatebuild] = argv.shift
         when "--specialbuild"
-          options[:b2ec][:specialbuild] = ARGV.shift.encode("utf-8")
+          @options[:specialbuild] = argv.shift
         when "--comments"
-          options[:b2ec][:comments] = ARGV.shift.encode("utf-8")
-        when "--use-upx"
-          options[:use_upx] = true
-        when "--upx-path"
-          options[:upx_path] = ARGV.shift.encode("utf-8")
-        when "--upx-targets"
-          options[:upx_targets] += ARGV.shift.split(",").map(&:strip)
-        when "--upx-options"
-          options[:upx_options] = ARGV.shift
-        when "--zipfile"
-          options[:zipfile] = "#{ARGV.shift.encode('utf-8').sub(/\.zip$/, '')}.zip"
-        when "--7zip-path"
-          options[:sevenzip_path] = ARGV.shift.encode("utf-8")
-        when "--innosetup"
-          options[:inno_script] = ARGV.shift.encode("utf-8")
-        when "--iscc-path"
-          options[:iscc_path] = ARGV.shift.encode("utf-8")
-        when "--create-recipe"
-          require "json"
-          filename = ARGV.shift.encode("utf-8")
-          nputs "Creating recipe_file '#{filename}'."
-          File.open(filename, "w:utf-8") { |file| create_recipe(file) }
-          exit
-        when "--recipe"
-          filename = ARGV.shift.encode("utf-8")
-          nputs_v "Loading recipe_file '#{filename}'."
-          load File.expand_path(filename)
-        when "--virtual-directory"
-          options[:virtual_directory] = ARGV.shift.encode("utf-8")
+          @options[:comments] = argv.shift
         when "--"
           break
         when /^(--.+)/
@@ -305,26 +245,88 @@ options:
           output_help
           exit
         else
-          @data_files.push(arg.encode("utf-8"))
+          if File.exist?(arg)
+            @data_files.push(arg)
+          else
+            error "File '#{arg}' not found!"
+            exit
+          end
         end
       end
 
+      @args += argv.map { |a| %( "#{a}") }.join("")
+    end
+
+    def load_options_from_file(file)
+      fullpath = File.expand_path(file)
+      return unless File.exist?(fullpath)
+
+      argv = File.read(fullpath, encoding: Encoding::UTF_8).lines.flat_map do |line|
+        line.strip.split(" ", 2)
+      end
+      load_options(argv)
+    end
+
+    def check_options
+      load_options_from_file("~/neri.config")
+      load_options_from_file("./neri.config")
+      tmp_data_files = @data_files
+      @data_files = []
+      load_options(ARGV.map { |arg| arg.encode(Encoding::UTF_8) })
+      until ARGV.empty?
+        break if ARGV.shift == "--"
+      end
+      @data_files += tmp_data_files
       if @data_files.empty?
         error "No Script File!"
         output_help
         exit
       end
 
-      @args = ARGV.map { |a| %( "#{a}") }.join("")
       @options[:external_encoding] ||= Encoding.default_external.name
-      unless options[:enable_gems] || @rubyopt.index("--disable-gems")
+      unless @options[:enable_gems] || @rubyopt.index("--disable-gems")
         @rubyopt += " --disable-gems"
       end
-      unless options[:enable_did_you_mean] || @rubyopt.index("--disable-did_you_mean")
+      unless @options[:enable_did_you_mean] || @rubyopt.index("--disable-did_you_mean")
         @rubyopt += " --disable-did_you_mean"
       end
-      if @data_files.size > 1 || options[:encryption_key]
-        options[:datafile] ||= "#{basename}.dat"
+      @rubyopt.sub!(%r{-r\S+/bundler/setup}, "")
+      if @data_files.size > 1 || @options[:encryption_key]
+        @options[:datafile] ||= "#{basename}.dat"
+      end
+    end
+
+    def run_script
+      nputs "Running script '#{scriptfile}' to check dependencies."
+      begin
+        load File.expand_path(scriptfile)
+      rescue SystemExit, Interrupt
+      end
+      nputs "Script '#{scriptfile}' end."
+
+      if defined? DXRuby
+        require "neri/dxruby"
+        @use_dxruby = true
+      end
+      if defined? DXRuby::Tiled
+        require "neri/dxruby_tiled"
+        @use_dxruby_tiled = true
+      end
+      if defined? Ayame
+        require "neri/ayame"
+        @use_ayame = true
+      end
+
+      if @options[:invisible].nil?
+        if File.extname(scriptfile) == ".rbw" ||
+           defined?(DXRuby) ||
+           defined?(Gosu) ||
+           defined?(LibUI)
+          @options[:invisible] = true
+        end
+      end
+      if @options[:pause_last].nil? && !@options[:invisible]
+        @options[:pause_last] = true
       end
     end
 
@@ -336,18 +338,17 @@ options:
     def dll_dependencies
       require "fiddle/import"
 
-      pointer_type = Fiddle::SIZEOF_VOIDP == Fiddle::SIZEOF_LONG_LONG ? 'q*' : 'l!*'
       psapi    = Fiddle.dlopen("psapi.dll")
       kernel32 = Fiddle.dlopen("kernel32.dll")
       enumprocessmodules = Fiddle::Function.new(
         psapi["EnumProcessModules"],
-        [Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP],
+        [Fiddle::TYPE_UINTPTR_T, Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP],
         Fiddle::TYPE_LONG,
         Fiddle::Importer.const_get(:CALL_TYPE_TO_ABI)[:stdcall]
       )
       getmodulefilename = Fiddle::Function.new(
         kernel32["GetModuleFileNameW"],
-        [Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG],
+        [Fiddle::TYPE_UINTPTR_T, Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG],
         Fiddle::TYPE_LONG,
         Fiddle::Importer.const_get(:CALL_TYPE_TO_ABI)[:stdcall]
       )
@@ -357,7 +358,7 @@ options:
         Fiddle::TYPE_LONG,
         Fiddle::Importer.const_get(:CALL_TYPE_TO_ABI)[:stdcall]
       )
-      
+
       bytes_needed = 4 * 32
       module_handle_buffer = nil
       process_handle = getcurrentprocess.call
@@ -365,28 +366,24 @@ options:
         module_handle_buffer = "\x00" * bytes_needed
         bytes_needed_buffer = [0].pack("I")
         enumprocessmodules.call(
-          [process_handle].pack("I").unpack1("i"),
-          [module_handle_buffer].pack("p").unpack1(pointer_type),
-          [module_handle_buffer.size].pack("I").unpack1("i"),
-          [bytes_needed_buffer].pack("p").unpack1(pointer_type)
+          process_handle,
+          module_handle_buffer,
+          module_handle_buffer.size,
+          bytes_needed_buffer
         )
         bytes_needed = bytes_needed_buffer.unpack1("I")
         break if bytes_needed <= module_handle_buffer.size
       end
-      
+
       handles = module_handle_buffer.unpack("I*")
       dependencies = handles.select { |handle| handle > 0 }.map do |handle|
         str = "\x00\x00" * 256
-        modulefilename_length = getmodulefilename.call(
-          [handle].pack("I").unpack1("i"),
-          [str].pack("p").unpack1(pointer_type),
-          [str.size].pack("I").unpack1("i")
-        )
+        modulefilename_length = getmodulefilename.call(handle, str, str.size)
         str[0, modulefilename_length * 2].force_encoding("UTF-16LE").encode("UTF-8")
       end
 
       dependencies.map! { |dep| dep.sub(/^\\\\\?\\/, "") }
-      dependencies.map! { |dep| dep.tr(File::ALT_SEPARATOR, File::SEPARATOR) } if File::ALT_SEPARATOR
+      dependencies.map! { |dep| dep.tr("\\", "/") }
       dependencies.delete(rubyexe)
 
       dependencies.uniq
@@ -400,7 +397,8 @@ options:
 
     def additional_dlls_dependencies
       dependencies = []
-      options[:dlls].each do |dll|
+      @options[:dlls].push("*.dll") if RbConfig::CONFIG["arch"].include?("x64")
+      @options[:dlls].each do |dll|
         dependencies += Dir.glob(File.join(bindir, "**", dll))
         dependencies += Dir.glob(File.join(bindir, "**", "#{dll}.*"))
       end
@@ -409,7 +407,7 @@ options:
 
     def additional_libs_dependencies
       dependencies = []
-      options[:libs].each do |lib|
+      @options[:libs].each do |lib|
         $LOAD_PATH.each do |path|
           dependencies += Dir.glob(File.join(path, lib))
           dependencies += Dir.glob(File.join(path, "#{lib}.*"))
@@ -420,10 +418,9 @@ options:
     end
 
     def additional_gems_dependencies
-      require "rubygems"
       dependencies = []
       rubygems_dir = File.join(Gem.dir, "gems")
-      options[:gems].each do |gem|
+      @options[:gems].each do |gem|
         gem.sub!(/:(.+)/, "")
         targets = Regexp.last_match(1).to_s.split("|")
         targets.push("lib/**/*")
@@ -439,12 +436,12 @@ options:
     end
 
     def encoding_dependencies
-      return [] unless options[:encoding]
+      return [] unless @options[:encoding]
 
       dependencies = []
       enc_dir = Dir.glob(File.join(RbConfig::CONFIG["archdir"] || RbConfig::TOPDIR, "**", "enc")).first
 
-      options[:encoding].split(",").map(&:strip).each do |enc|
+      @options[:encoding].split(",").map(&:strip).each do |enc|
         case enc
         when "ja"
           %w[windows_31j.so japanese_sjis.so encdb.so].each do |enc_name|
@@ -459,35 +456,41 @@ options:
       dependencies.uniq
     end
 
-    def check_dependencies
-      nputs "Running script '#{scriptfile}' to check dependencies."
-      begin
-        load File.expand_path(scriptfile)
-      rescue SystemExit, Interrupt
+    def select_dependencies(dependencies)
+      dependencies.select! do |dependency|
+        dependency.start_with?(rubydir)
       end
-      nputs "Script '#{scriptfile}' end."
 
-      if defined? DXRuby
-        require "neri/dxruby"
-        @use_dxruby = true
-      end
-      if defined? DXRuby::Tiled
-        require "neri/dxruby_tiled"
-        @use_dxruby_tiled = true
-      end
-      if defined? Ayame
-        require "neri/ayame"
-        @use_ayame = true
+      @data_files.each do |file|
+        dependencies.delete(File.expand_path(file))
       end
 
-      if options[:b2ec][:invisible].nil? &&
-         (File.extname(scriptfile) == ".rbw" || @use_dxruby)
-        options[:b2ec][:invisible] = true
+      unless @options[:enable_gems]
+        dependencies.delete_if do |dependency|
+          File.basename(dependency) == "rubygems.rb" ||
+            dependency.split(File::SEPARATOR).index("rubygems")
+        end
       end
-      if options[:pause_last].nil? && !options[:b2ec][:invisible]
-        options[:pause_last] = true
+      unless @options[:enable_did_you_mean]
+        dependencies.delete_if do |dependency|
+          File.basename(dependency) == "did_you_mean.rb" ||
+            dependency.split(File::SEPARATOR).index("did_you_mean")
+        end
       end
 
+      dependencies.uniq
+    end
+
+    def gemspec_dependencies(dependencies)
+      default_gemspec_dir = Gem.default_specifications_dir.encode(Encoding::UTF_8)
+      gemspecs = Dir.glob("#{default_gemspec_dir}/**/*")
+      gemspecs += dependencies.map { |depend| gemspec_path(depend) }
+      gemspecs.compact.uniq
+    end
+
+    def check_dependencies
+      run_script
+
       require "rbconfig"
       dependencies = []
       dependencies += rb_dependencies
@@ -498,70 +501,50 @@ options:
       dependencies += additional_gems_dependencies
       dependencies += encoding_dependencies
       dependencies = select_dependencies(dependencies)
+      dependencies += gemspec_dependencies(dependencies) if @options[:enable_gems]
+      if dependencies.find { |dep| dep.end_with?("/net/https.rb") }
+        dependencies.push("#{rubydir}ssl/cert.pem")
+      end
 
       size = dependencies.map { |d| File.size(d) }.inject(&:+)
       nputs "#{dependencies.size} files, #{size} bytes dependencies."
-      if options[:verbose]
-        dependencies.each do |dependency|
-          nputs_v "  - #{dependency}"
-        end
-      end
 
       dependencies
     end
 
-    def select_dependencies(dependencies)
-      dependencies.select! do |dependency|
-        dependency.start_with?(rubydir)
-      end
-
-      @data_files.each do |file|
-        dependencies.delete(File.expand_path(file))
-      end
-
-      unless options[:enable_gems]
-        dependencies.delete_if do |dependency|
-          File.basename(dependency) == "rubygems.rb" ||
-            dependency.split(File::SEPARATOR).index("rubygems")
-        end
-      end
-      unless options[:enable_did_you_mean]
-        dependencies.delete_if do |dependency|
-          File.basename(dependency) == "did_you_mean.rb" ||
-            dependency.split(File::SEPARATOR).index("did_you_mean")
-        end
-      end
-
-      dependencies.uniq
-    end
-
     def copy_files(dependencies)
       nputs "Copying dependencies."
       require "fileutils"
       src_dir  = rubydir
-      desc_dir = File.join(options[:output_dir], options[:system_dir], "")
+      desc_dir = File.join(@options[:output_dir], @options[:system_dir], "")
 
       system_files = dependencies.map do |file|
         [file, file.sub(src_dir, desc_dir)]
       end
-      unless options[:enable_gems]
-        system_files.each do |_src, desc|
-          desc.sub!(%r{/gems(/\d+\.\d+\.\d+/)gems/(.+?)-[^/]+/lib/}, "/vendor_ruby\\1")
+      unless @options[:enable_gems]
+        system_files.each do |src, desc|
+          paths = gem_require_paths(src)
+          next unless paths
+
+          desc.sub!(%r{/gems/(\d+\.\d+\.\d+)/gems/.+?-[^/]+/(.+)\z}) do
+            version, file = Regexp.last_match(1), Regexp.last_match(2)
+            paths.each do |path|
+              file = file.sub(path, "#{version}/") if file.start_with?(path)
+            end
+            "/vendor_ruby/#{file}"
+          end
         end
       end
 
       system_files.each do |src, desc|
         FileUtils.makedirs(File.dirname(desc))
-        if File.file?(src)
-          FileUtils.copy(src, desc)
-          nputs_v "  #{src}\n  -> #{desc}"
-        end
+        FileUtils.copy(src, desc) if File.file?(src)
       end
-      FileUtils.copy(scriptfile, desc_dir) unless options[:datafile]
+      FileUtils.copy(scriptfile, desc_dir) unless @options[:datafile]
     end
 
     def create_datafile
-      return unless options[:datafile]
+      return unless @options[:datafile]
 
       nputs "Creating datafile '#{datafile}'."
       data_files = @data_files.select { |file| File.file? file }
@@ -570,21 +553,22 @@ options:
       end
       data_files.uniq! { |file| File.expand_path(file) }
 
-      unless options[:virtual_directory]
+      unless @options[:virtual_directory]
         dir_pwd = Dir.pwd.encode(Encoding::UTF_8)
         virtual_directories = Pathname.new(dir_pwd).ascend.to_a.map(&:to_s)
         data_files.each do |file|
           fullpath = File.expand_path(file)
           next if fullpath.start_with?(rubydir) || Pathname.new(file).absolute?
+
           virtual_directories.shift until fullpath.start_with?(virtual_directories.first)
         end
-        options[:virtual_directory] = relative_path(dir_pwd, virtual_directories.first, "/_neri_virtual_directory_/")
-        nputs "virtual_directory: #{options[:virtual_directory]}"
+        @options[:virtual_directory] = relative_path(dir_pwd, virtual_directories.first, "/_neri_virtual_directory_/")
+        nputs "virtual_directory: #{@options[:virtual_directory]}"
       end
 
-      if options[:encryption_key]
+      if @options[:encryption_key]
         require "digest/sha2"
-        @encryption_key = Digest::SHA2.hexdigest(options[:encryption_key])
+        @encryption_key = Digest::SHA2.hexdigest(@options[:encryption_key])
       end
       Neri.key = @encryption_key || "0" * 64
       File.open(datafile, "wb") do |f|
@@ -592,19 +576,18 @@ options:
         file_informations = data_files.map do |file|
           fullpath = File.expand_path(file)
           filename = if fullpath.start_with?(rubydir)
-                       relative_path(fullpath, rubydir, "#{options[:system_dir]}#{File::SEPARATOR}")
+                       relative_path(fullpath, rubydir, "#{@options[:system_dir]}#{File::SEPARATOR}")
                      else
                        file
                      end
           filedata = [filename, File.size(file), pos].join("\t")
-          nputs_v "  - #{filename}:#{File.size(file)} bytes"
           pos += File.size(file)
-          pos += BLOCK_LENGTH - pos % BLOCK_LENGTH unless pos % BLOCK_LENGTH == 0
+          pos += Neri::BLOCK_LENGTH - pos % Neri::BLOCK_LENGTH unless pos % Neri::BLOCK_LENGTH == 0
           filedata
         end
         files_str = file_informations.join("\n").encode(Encoding::UTF_8)
 
-        f.write(format("%#{BLOCK_LENGTH}d", files_str.bytesize))
+        f.write(format("%#{Neri::BLOCK_LENGTH}d", files_str.bytesize))
         f.write(xor(files_str))
         data_files.each do |file|
           f.write(xor(File.binread(file)))
@@ -616,26 +599,26 @@ options:
       nputs "Creating batch_file '#{basepath}.bat'."
 
       pause_command = ""
-      if options[:pause_last]
+      if @options[:pause_last]
         pause_command += "echo.\n"
-        if options[:pause_text]
-          pause_command += "echo #{options[:pause_text]}\n" +
-                           "pause > nul"
-        else
-          pause_command += "pause"
-        end
+        pause_command +=
+          if @options[:pause_text]
+            "echo #{@options[:pause_text]}\npause > nul"
+          else
+            "pause"
+          end
       end
-      chdir = options[:chdir_first] ? 'cd /d "%~dp0"' : ""
+      chdir = @options[:chdir_first] ? 'cd /d "%~dp0"' : ""
 
-      File.open("#{basepath}.bat", "w:#{options[:external_encoding]}") do |f|
+      File.open("#{basepath}.bat", "w:#{@options[:external_encoding]}") do |f|
         f.puts <<-BATCH
 @echo off
 setlocal
-set PATH=%~dp0#{options[:system_dir]}\\#{relative_path(bindir)};%PATH%
+set PATH=%~dp0#{@options[:system_dir]}\\#{relative_path(bindir)};%PATH%
 set NERI_EXECUTABLE=%~0
 #{chdir}
 if %~x0 == .exe ( shift )
-#{ruby_command(options[:chdir_first] ? '' : '%~dp0')} %1 %2 %3 %4 %5 %6 %7 %8 %9
+#{ruby_command(@options[:chdir_first] ? '' : '%~dp0')} %1 %2 %3 %4 %5 %6 %7 %8 %9
 #{pause_command}
 endlocal
         BATCH
@@ -653,9 +636,9 @@ endlocal
       c_file   = to_winpath("#{basepath}_tmp.c" )
       o_file   = to_winpath("#{basepath}_tmp.o" )
       rc_file  = to_winpath("#{basepath}_tmp.rc")
-      system_dir = escape_cstr(to_winpath(File.join(options[:system_dir], "")))
+      system_dir = escape_cstr(to_winpath(File.join(@options[:system_dir], "")))
       nputs "Creating exe_file '#{exe_file}'."
-      File.open(c_file, "w:#{options[:external_encoding]}") do |f|
+      File.open(c_file, "w:#{@options[:external_encoding]}") do |f|
         f.puts <<-CFILE
 #include <stdio.h>
 #include <stdlib.h>
@@ -684,9 +667,9 @@ int main(int argc, char *argv[])
     putenv(paths);
     snprintf(paths, sizeof(paths), "PATH=%s%s#{system_dir}bin;%s", drive, dir, getenv("PATH"));
     putenv(paths);
-    #{options[:chdir_first] ? 'snprintf(paths, sizeof(paths), "%s%s", drive, dir);chdir(paths);' : ''}
-    snprintf(runruby, sizeof(runruby), "#{escape_cstr(ruby_command(options[:chdir_first] ? '' : '%s%s'))} %s %s %s %s %s %s %s %s %s",
-        #{options[:chdir_first] ? '' : 'drive, dir,'}
+    #{@options[:chdir_first] ? 'snprintf(paths, sizeof(paths), "%s%s", drive, dir);chdir(paths);' : ''}
+    snprintf(runruby, sizeof(runruby), "#{escape_cstr(ruby_command(@options[:chdir_first] ? '' : '%s%s'))} %s %s %s %s %s %s %s %s %s",
+        #{@options[:chdir_first] ? '' : 'drive, dir,'}
         argc > 1 ? argv[1] : "",
         argc > 2 ? argv[2] : "",
         argc > 3 ? argv[3] : "",
@@ -698,15 +681,15 @@ int main(int argc, char *argv[])
         argc > 9 ? argv[9] : ""
         );
         CFILE
-        if options[:b2ec][:invisible]
+        if @options[:invisible]
           f.puts %[    CreateProcess(NULL, runruby, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, NULL, &si, &pi);]
         else
           f.puts %[    system(runruby);]
         end
-        if options[:pause_last]
+        if @options[:pause_last]
           f.puts %[    system("echo.");]
-          if options[:pause_text]
-            f.puts %[    system("echo #{escape_cstr(options[:pause_text])}");]
+          if @options[:pause_text]
+            f.puts %[    system("echo #{escape_cstr(@options[:pause_text])}");]
             f.puts %[    system("pause >nul");]
           else
             f.puts %[    system("pause");]
@@ -715,31 +698,31 @@ int main(int argc, char *argv[])
         f.puts "    return 0;\n}"
       end
 
-      File.open(rc_file, "w:#{options[:external_encoding]}") do |f|
+      File.open(rc_file, "w:#{@options[:external_encoding]}") do |f|
         f.puts <<-RCFILE
 #include <winver.h>
 
 1 VERSIONINFO
-#{options[:b2ec][:fileversion   ] ? "FILEVERSION     #{escape_cstr(options[:b2ec][:fileversion   ])}" : ""}
-#{options[:b2ec][:productversion] ? "PRODUCTVERSION  #{escape_cstr(options[:b2ec][:productversion])}" : ""}
+#{@options[:fileversion   ] ? "FILEVERSION     #{escape_cstr(@options[:fileversion   ])}" : ''}
+#{@options[:productversion] ? "PRODUCTVERSION  #{escape_cstr(@options[:productversion])}" : ''}
 FILETYPE        VFT_APP
 BEGIN
     BLOCK "StringFileInfo"
     BEGIN
         BLOCK "000004b0"
         BEGIN
-            #{options[:b2ec][:fileversion     ] ? 'VALUE "FileVersion",      "' + escape_cstr(options[:b2ec][:fileversion     ]) + '\0"' : ''}
-            #{options[:b2ec][:productversion  ] ? 'VALUE "ProductVersion",   "' + escape_cstr(options[:b2ec][:productversion  ]) + '\0"' : ''}
-            #{options[:b2ec][:productname     ] ? 'VALUE "ProductName",      "' + escape_cstr(options[:b2ec][:productname     ]) + '\0"' : ''}
-            #{options[:b2ec][:originalfilename] ? 'VALUE "OriginalFileName", "' + escape_cstr(options[:b2ec][:originalfilename]) + '\0"' : ''}
-            #{options[:b2ec][:internalname    ] ? 'VALUE "InternalName",     "' + escape_cstr(options[:b2ec][:internalname    ]) + '\0"' : ''}
-            #{options[:b2ec][:description     ] ? 'VALUE "FileDescription",  "' + escape_cstr(options[:b2ec][:description     ]) + '\0"' : ''}
-            #{options[:b2ec][:company         ] ? 'VALUE "CompanyName",      "' + escape_cstr(options[:b2ec][:company         ]) + '\0"' : ''}
-            #{options[:b2ec][:trademarks      ] ? 'VALUE "LegalTrademarks",  "' + escape_cstr(options[:b2ec][:trademarks      ]) + '\0"' : ''}
-            #{options[:b2ec][:copyright       ] ? 'VALUE "LegalCopyright",   "' + escape_cstr(options[:b2ec][:copyright       ]) + '\0"' : ''}
-            #{options[:b2ec][:privatebuild    ] ? 'VALUE "PrivateBuild",     "' + escape_cstr(options[:b2ec][:privatebuild    ]) + '\0"' : ''}
-            #{options[:b2ec][:specialbuild    ] ? 'VALUE "SpecialBuild",     "' + escape_cstr(options[:b2ec][:specialbuild    ]) + '\0"' : ''}
-            #{options[:b2ec][:comments        ] ? 'VALUE "Comments",         "' + escape_cstr(options[:b2ec][:comments        ]) + '\0"' : ''}
+            #{@options[:fileversion     ] ? 'VALUE "FileVersion",      "' + escape_cstr(@options[:fileversion     ]) + '\0"' : ''}
+            #{@options[:productversion  ] ? 'VALUE "ProductVersion",   "' + escape_cstr(@options[:productversion  ]) + '\0"' : ''}
+            #{@options[:productname     ] ? 'VALUE "ProductName",      "' + escape_cstr(@options[:productname     ]) + '\0"' : ''}
+            #{@options[:originalfilename] ? 'VALUE "OriginalFileName", "' + escape_cstr(@options[:originalfilename]) + '\0"' : ''}
+            #{@options[:internalname    ] ? 'VALUE "InternalName",     "' + escape_cstr(@options[:internalname    ]) + '\0"' : ''}
+            #{@options[:description     ] ? 'VALUE "FileDescription",  "' + escape_cstr(@options[:description     ]) + '\0"' : ''}
+            #{@options[:company         ] ? 'VALUE "CompanyName",      "' + escape_cstr(@options[:company         ]) + '\0"' : ''}
+            #{@options[:trademarks      ] ? 'VALUE "LegalTrademarks",  "' + escape_cstr(@options[:trademarks      ]) + '\0"' : ''}
+            #{@options[:copyright       ] ? 'VALUE "LegalCopyright",   "' + escape_cstr(@options[:copyright       ]) + '\0"' : ''}
+            #{@options[:privatebuild    ] ? 'VALUE "PrivateBuild",     "' + escape_cstr(@options[:privatebuild    ]) + '\0"' : ''}
+            #{@options[:specialbuild    ] ? 'VALUE "SpecialBuild",     "' + escape_cstr(@options[:specialbuild    ]) + '\0"' : ''}
+            #{@options[:comments        ] ? 'VALUE "Comments",         "' + escape_cstr(@options[:comments        ]) + '\0"' : ''}
         END
     END
 
@@ -749,23 +732,23 @@ BEGIN
     END
 END
 
-2 ICON "#{escape_cstr(options[:b2ec][:icon])}"
+2 ICON "#{escape_cstr(@options[:icon])}"
         RCFILE
       end
       nsystem(%(windres -o "#{o_file}" "#{rc_file}"))
-      nsystem(%(gcc#{options[:b2ec][:invisible] ? ' -mwindows' : ''} -o "#{exe_file}" "#{c_file}" "#{o_file}"))
+      nsystem(%(gcc#{@options[:invisible] ? ' -mwindows' : ''} -o "#{exe_file}" "#{c_file}" "#{o_file}"))
       nsystem(%(strip "#{exe_file}"))
       File.delete(c_file, rc_file, o_file)
     end
 
     def ruby_command(path)
-      system_dir = "#{path}#{File.join(options[:system_dir], '')}"
+      system_dir = "#{path}#{File.join(@options[:system_dir], '')}"
       ruby_code = ""
       ruby_code = "Neri.key='#{@encryption_key}';" if @encryption_key
-      if options[:datafile]
-        ruby_code += "Neri.datafile='#{system_dir}' + #{unpack_filename(options[:datafile])};"
-        if options[:virtual_directory]
-          ruby_code += "Neri.virtual_directory=#{unpack_filename(options[:virtual_directory])};"
+      if @options[:datafile]
+        ruby_code += "Neri.datafile='#{system_dir}' + #{unpack_filename(@options[:datafile])};"
+        if @options[:virtual_directory]
+          ruby_code += "Neri.virtual_directory=#{unpack_filename(@options[:virtual_directory])};"
         end
         ruby_code += "load #{unpack_filename(File.basename(scriptfile))}"
       else
@@ -781,141 +764,23 @@ END
       %(#{ruby}#{r} #{@rubyopt} -e "# coding:utf-8" -e "#{ruby_code}" #{@args})
     end
 
-    def bat_to_exe_converter
-      create_batfile
-      begin
-        `#{options[:b2ec_path]} /help`
-      rescue
-        error "Bat To Exe Converter not found !"
-        return
-      end
-
-      batch_file = "#{basepath}.bat"
-      exe_file   = "#{basepath}.exe"
-      nputs "Creating exe_file '#{exe_file}' with Bat To Exe Converter."
-      File.delete(exe_file) if File.exist?(exe_file)
-      if options[:b2ec][:x64].nil? && RbConfig::CONFIG["target"].to_s.index("64")
-        options[:b2ec][:x64] = true
-      end
-      args = %( /bat "#{batch_file}" /exe "#{exe_file}")
-      args += options[:b2ec].map { |key, value|
-        case value
-        when String then %( /#{key.to_s.tr('_', '-')} "#{value}")
-        when true   then %( /#{key.to_s.tr('_', '-')})
-        else;            %()
-        end
-      }.join("")
-
-      error "Failed to create exe_file !" unless nsystem "#{options[:b2ec_path]}#{args}"
-    end
-
-    def upx
-      unless system("#{options[:upx_path]} --version >nul 2>&1")
-        error "UPX not found !"
-        return
-      end
-
-      nputs "Compressing with UPX."
-      options[:upx_targets].each do |target|
-        Dir.glob(File.join(options[:output_dir], options[:system_dir], target)).each do |target_path|
-          command = %("#{options[:upx_path]}" #{options[:upx_options]} "#{target_path}")
-          nsystem command
-        end
-      end
-    end
-
-    def create_zipfile
-      unless system("#{options[:sevenzip_path]} >nul 2>&1")
-        error "7-Zip not found !"
-        return
-      end
-
-      nputs "Creating zip_file '#{options[:zipfile]}'."
-      File.delete(options[:zipfile]) if File.exist?(options[:zipfile])
-      files = []
-      if options[:output_dir] == "./"
-        files.push(options[:system_dir])
-        files.push(File.exist?("#{basepath}.exe") ? "#{basepath}.exe" : "#{basepath}.bat")
-      else
-        files.push(options[:output_dir])
-      end
-      command = %("#{options[:sevenzip_path]}" a "#{options[:zipfile]}" "#{files.join('" "')}")
-      nsystem command
-    end
-
-    def inno_setup
-      unless system("#{options[:iscc_path]} /? >nul 2>&1")
-        error("Inno Setup not found !")
-        return
-      end
-
-      filename = options[:inno_script]
-      nputs "Creating Installer '#{filename}'."
-      script = "[Setup]\n"
-      if File.exist?(filename)
-        script = File.read(filename, encoding: Encoding::UTF_8)
-        filename = "#{File.basename(filename, '.*')}_tmp#{File.extname(filename)}"
-      end
-
-      version = options[:b2ec][:productversion] || options[:b2ec][:fileversion]
-      if !script.match(/^AppName=/) && options[:b2ec][:productname]
-        script.sub!(/^(\[Setup\])(\s+)/i) { "#{$1}\nAppName=#{options[:b2ec][:productname]}#{$2}" }
-      end
-      if !script.match(/^AppVersion=/) && version
-        script.sub!(/^(\[Setup\])(\s+)/i) { "#{$1}\nAppVersion=#{version}#{$2}" }
-      end
-      if !script.match(/^AppVerName=/) && options[:b2ec][:productname] && version
-        script.sub!(/^(\[Setup\])(\s+)/i) { "#{$1}\nAppVerName=#{options[:b2ec][:productname]} #{version}#{$2}" }
-      end
-      if !script.match(/^AppPublisher=/) && options[:b2ec][:company]
-        script.sub!(/^(\[Setup\])(\s+)/i) { "#{$1}\nAppPublisher=#{options[:b2ec][:company]}#{$2}" }
-      end
-      if !script.match(/^AppCopyright=/) && options[:b2ec][:copyright]
-        script.sub!(/^(\[Setup\])(\s+)/i) { "#{$1}\nAppCopyright=#{options[:b2ec][:copyright]}#{$2}" }
-      end
-
-      script += "\n[Files]\n" unless script.match(/^\[Files\]/)
-      dir = File.expand_path(options[:output_dir])
-      files_str = ""
-      Dir.glob(File.join(dir, "**", "*")).each do |file|
-        next unless File.file? file
-
-        dist_dir = to_winpath(File::SEPARATOR + File.dirname(relative_path(file, dir)))
-        dist_dir = "" if dist_dir == "\\."
-        files_str += "\nSource: \"#{to_winpath(file)}\"; DistDir: \"{app}#{dist_dir}"
-        files_str += "; Flags: isreadme" if File.basename(file).match(/^readme/i)
-      end
-      script.sub!(/^(\[Files\])(\s*)/i) { "#{$1}#{files_str}#{$2}" }
-
-      File.write(filename, script)
-      command = %(#{options[:iscc_path]} "#{filename}")
-      nsystem command
-    end
-
     def run
       check_options
       dependencies = check_dependencies
       copy_files(dependencies)
       create_datafile
-      if options[:no_exe]
-        create_batfile
-      else
-        options[:use_b2ec] ? bat_to_exe_converter : create_exefile
-      end
-      upx             if options[:use_upx]
-      create_zipfile  if options[:zipfile]
-      inno_setup      if options[:inno_script]
+      @options[:no_exe] ? create_batfile : create_exefile
       nputs "Neri Finished."
     end
 
     private
 
-    def nputs(str)
-      puts "=== #{str}" unless options[:quiet]
+    def xor(str)
+      Neri.__send__(:xor, str)
     end
 
-    def nputs_v(str)
-      puts str if options[:verbose]
+    def nputs(str)
+      puts "=== #{str}" unless @options[:quiet]
     end
 
     def error(str)
@@ -931,9 +796,8 @@ END
     end
 
     def nsystem(str)
-      nputs_v(str)
-      command = str.encode(options[:external_encoding])
-      system(command + (options[:quiet] ? " >nul 2>&1" : ""))
+      command = str.encode(@options[:external_encoding])
+      system(command + (@options[:quiet] ? " >nul 2>&1" : ""))
     end
   end
 end