neri 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b8b9f832233b4284f8fae7b0169f6d8e9f2bb2b309c9886cd93cdc8d84a73d4
-  data.tar.gz: 3465c27fe19e8efbbd24aaf259eeb72cc5caa70c9c616c8b2e4df0a1e6736de7
+  metadata.gz: c9c11506aa1729506a8f2386ea1a37e45c6ef5f72cec65e3677931ef6f18910f
+  data.tar.gz: fb4307dd5e026985659ab652e27436759bd60531f1b9044ab6ca82f6d28eab22
 SHA512:
-  metadata.gz: 00a248fb2575ecc167c6131adcfa309852abc7daf5b25e870ce8c39fc89e826d8130990de79ecc5b1548307778aa37656cfd8a4342fa890ee5d524665dd2bae4
-  data.tar.gz: d4235f7b16f22018c093202f512952f1ad2464b03454e3f31fe83e4ec4b7213a638d52d176b4aecf6b145cc4cfac2c94dfe68ed3c1eb6ade0a30209c3a9c95f7
+  metadata.gz: b2d6307c498084b7327d96fb041304b6df4f2aca8756a81f90d6065b1a5b966eef64056d76ca6917267bd75f531ec1bead1e987195fc7379276d0de3233af7aa
+  data.tar.gz: b2002fe10dc92c4c87ddf7e961d77c5bddda93f0b9782b41e87e2b4ae5cc969b11123217b98f4d91d75a25c64db934a3db8eab6ed39be6072f3c046214923811

data/lib/neri/ayame.rb

@@ -5,12 +5,9 @@ require "ayame" unless defined? Ayame
 module Neri
   module Ayame
     def new(filename)
-      if Neri.exist_in_datafile?(filename)
-        ayame = load_from_memory(Neri.file_read(filename))
-        return ayame
-      else
-        return super
-      end
+      return super unless Neri.exist_in_datafile?(filename)
+
+      load_from_memory(Neri.file_read(filename))
     end
   end
 end

data/lib/neri/build.rb

@@ -1,39 +1,38 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
 
 require "neri"
 
 module Neri
   @data_files = []
-  
+
   @options = {
     quiet:   false,
     verbose: false,
-    
+
     external_encoding: nil,
-    
+
     dlls:     [],
     libs:     [],
     gems:     [],
     encoding: "*",
-    
+
     enable_gems:         false,
     enable_did_you_mean: false,
     chdir_first:         false,
     pause_last:          nil,
     pause_text:          nil,
-    
+
     output_dir: "./",
     system_dir: "system",
-    
+
     datafile:       nil,
     encryption_key: nil,
-    
+
     no_exe: false,
     use_b2ec: false,
     b2ec_path: "Bat_To_Exe_Converter",
     b2ec: {
-      icon: "#{File.expand_path(File.dirname(__FILE__) + '/../../share/default.ico')}",
+      icon: File.expand_path("#{File.dirname(__FILE__)}/../../share/default.ico"),
       invisible:        nil,
       x64:              nil,
       uac_admin:        nil,
@@ -50,50 +49,49 @@ module Neri
       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",
+    iscc_path:   "iscc"
   }
   @rubyopt = ENV["RUBYOPT"].to_s
   @args = ""
   @encryption_key = nil
-  
+
   @use_dxruby       = false
   @use_dxruby_tiled = false
   @use_ayame        = false
-  
+
   class << self
-    
     attr_reader :options
-    
-    def relative_path(path, basedir=rubydir, prepath = "")
+
+    def relative_path(path, basedir = rubydir, prepath = "")
       basedir.concat(File::SEPARATOR) unless basedir.end_with?(File::SEPARATOR)
-      return path.start_with?(basedir) ? path.sub(basedir, prepath) : path
+      path.start_with?(basedir) ? path.sub(basedir, prepath) : path
     end
-    
+
     def to_winpath(path)
-      return File::ALT_SEPARATOR ? path.tr(File::SEPARATOR, File::ALT_SEPARATOR) : path
+      File::ALT_SEPARATOR ? path.tr(File::SEPARATOR, File::ALT_SEPARATOR) : path
     end
-    
-    def bindir(    ); RbConfig::CONFIG["bindir"] || File.join(rubydir, "bin"); end
-    def rubydir(   ); File.join(RbConfig::TOPDIR, ""); end
-    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 bindir    ; RbConfig::CONFIG["bindir"] || File.join(rubydir, "bin"); end
+    def rubydir   ; File.join(RbConfig::TOPDIR, ""); end
+    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
+
     # --help
     def output_help
-      puts <<-EOF
+      puts <<-HELP_MESSAGE
 usage: neri [options] script.rb (other_files...) -- script_arguments
 
 options:
@@ -101,28 +99,28 @@ options:
   --version or -v
   --quiet
   --verbose
-  
+
   --external-encoding <encoding>
-  
+
   --dll <dll1>,<dll2>,...
   --lib <lib1>,<lib2>,...
   --gem <gem1>,<gem2>,...
-  
+
   --no-enc
   --encoding <enc1>,<enc2>,...
-  
+
   --enable-gems
   --enable-did-you-mean
   --chdir-first
   --pause-last
   --no-pause-last
   --pause-text <text>
-  
+
   --output-dir <dirname>
   --system-dir <dirname>
   --datafile <filename>
   --encryption-key <key>
-  
+
   --no-exe
   --use-b2ec
   --b2ec-path <bat_to_exe_converter_path>
@@ -143,28 +141,28 @@ 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>
-      EOF
+      HELP_MESSAGE
     end
-    
+
     # --version
     def output_version
       puts "Neri #{Neri::VERSION}"
     end
-    
+
     # --create-recipe
     def create_recipe(file, hash = options, pre = "Neri.options")
       hash.each_pair do |key, value|
@@ -180,8 +178,7 @@ options:
         end
       end
     end
-    
-    
+
     def check_options
       nputs_v "Checking Neri options."
       while arg = ARGV.shift
@@ -194,7 +191,7 @@ options:
           exit
         when "--quiet", "-q"
           options[:quiet] = true
-        when "--verbose", "-v"
+        when "--verbose"
           options[:verbose] = true
         when "--external_encoding"
           options[:external_encoding] = ARGV.shift
@@ -278,7 +275,7 @@ options:
         when "--upx-options"
           options[:upx_options] = ARGV.shift
         when "--zipfile"
-          options[:zipfile] = ARGV.shift.encode("utf-8").sub(/\.zip$/, "") + ".zip"
+          options[:zipfile] = "#{ARGV.shift.encode('utf-8').sub(/\.zip$/, '')}.zip"
         when "--7zip-path"
           options[:sevenzip_path] = ARGV.shift.encode("utf-8")
         when "--innosetup"
@@ -289,7 +286,7 @@ options:
           require "json"
           filename = ARGV.shift.encode("utf-8")
           nputs "Creating recipe_file '#{filename}'."
-          open(filename, "w:utf-8"){ |file| create_recipe(file) }
+          File.open(filename, "w:utf-8") { |file| create_recipe(file) }
           exit
         when "--recipe"
           filename = ARGV.shift.encode("utf-8")
@@ -305,116 +302,115 @@ options:
           @data_files.push(arg.encode("utf-8"))
         end
       end
-      
+
       if @data_files.empty?
         error "No Script File!"
         output_help
         exit
       end
-      
-      @args = ARGV.map{ |arg| %[ "#{arg}"] }.join("")
-      @options[:external_encoding] ||= Encoding::default_external.name
-      unless options[:enable_gems]
-        @rubyopt += " --disable-gems" unless @rubyopt.index("--disable-gems")
+
+      @args = ARGV.map { |a| %( "#{a}") }.join("")
+      @options[:external_encoding] ||= Encoding.default_external.name
+      unless options[:enable_gems] || @rubyopt.index("--disable-gems")
+        @rubyopt += " --disable-gems"
       end
-      unless options[:enable_did_you_mean]
-        @rubyopt += " --disable-did_you_mean" unless @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"
+        options[:datafile] ||= "#{basename}.dat"
       end
     end
-    
-    
+
     # check dependencies
-    def rb_dependencies()
-      return $LOADED_FEATURES.uniq
+    def rb_dependencies
+      $LOADED_FEATURES.uniq
     end
-    
-    def dll_dependencies()
+
+    def dll_dependencies
       require "Win32API"
-      
+
       enumprocessmodules = Win32API.new("psapi"   , "EnumProcessModules", ["L","P","L","P"], "L")
       getmodulefilename  = Win32API.new("kernel32", "GetModuleFileNameW", ["L","P","L"], "L")
       getcurrentprocess  = Win32API.new("kernel32", "GetCurrentProcess" , [], "L")
-      
+
       bytes_needed = 4 * 32
       module_handle_buffer = nil
-      process_handle = getcurrentprocess.call()
+      process_handle = getcurrentprocess.call
       loop do
         module_handle_buffer = "\x00" * bytes_needed
         bytes_needed_buffer = [0].pack("I")
-        r = enumprocessmodules.call(process_handle, module_handle_buffer, module_handle_buffer.size, bytes_needed_buffer)
-        bytes_needed = bytes_needed_buffer.unpack("I")[0]
+        enumprocessmodules.call(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, str, str.size)
-        modulefilename = str[0, modulefilename_length * 2].force_encoding("UTF-16LE").encode("UTF-8")
-      end
-      
-      dependencies.map!{|dep| dep.sub(/^\\\\\?\\/, "")}
-      if File::ALT_SEPARATOR
-        dependencies.map!{|dep| dep.tr(File::ALT_SEPARATOR, File::SEPARATOR)}
+        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.delete(rubyexe)
-      
-      return dependencies.uniq
+
+      dependencies.uniq
     end
-    
-    def ruby_dependencies()
+
+    def ruby_dependencies
       dependencies = Dir.glob(File.join(bindir, "**", "*.manifest"))
       dependencies.push(rubyexe)
-      return dependencies.uniq
+      dependencies.uniq
     end
-    
-    def additional_dlls_dependencies()
+
+    def additional_dlls_dependencies
       dependencies = []
       options[:dlls].each do |dll|
         dependencies += Dir.glob(File.join(bindir, "**", dll))
-        dependencies += Dir.glob(File.join(bindir, "**", dll + ".*"))
+        dependencies += Dir.glob(File.join(bindir, "**", "#{dll}.*"))
       end
-      return dependencies.uniq
+      dependencies.uniq
     end
-    
-    def additional_libs_dependencies()
+
+    def additional_libs_dependencies
       dependencies = []
       options[:libs].each do |lib|
         $LOAD_PATH.each do |path|
           dependencies += Dir.glob(File.join(path, lib))
-          dependencies += Dir.glob(File.join(path, lib + ".*"))
+          dependencies += Dir.glob(File.join(path, "#{lib}.*"))
           dependencies += Dir.glob(File.join(path, lib, "**", "*"))
         end
       end
-      return dependencies.uniq
+      dependencies.uniq
     end
-    
-    def additional_gems_dependencies()
+
+    def additional_gems_dependencies
       require "rubygems"
       dependencies = []
       rubygems_dir = File.join(Gem.dir, "gems")
       options[:gems].each do |gem|
-        gem.sub!(/\:(.+)/, "")
-        targets = $1.to_s.split("|")
+        gem.sub!(/:(.+)/, "")
+        targets = Regexp.last_match(1).to_s.split("|")
         targets.push("lib/**/*")
         gem += "-*" unless gem.match("-")
-        gemdir = Dir.glob(File.join(rubygems_dir, gem)).sort.last
+        gemdir = Dir.glob(File.join(rubygems_dir, gem)).max
         next unless gemdir
+
         targets.each do |target|
           dependencies += Dir.glob(File.join(gemdir, target))
         end
       end
-      return dependencies.uniq
+      dependencies.uniq
     end
-    
-    def encoding_dependencies()
+
+    def encoding_dependencies
       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|
         case enc
         when "ja"
@@ -423,21 +419,21 @@ options:
           end
         else
           dependencies += Dir.glob(File.join(enc_dir, "**", enc))
-          dependencies += Dir.glob(File.join(enc_dir, "**", enc + ".*"))
+          dependencies += Dir.glob(File.join(enc_dir, "**", "#{enc}.*"))
         end
       end
-      
-      return dependencies.uniq
+
+      dependencies.uniq
     end
-    
-    def check_dependencies()
+
+    def check_dependencies
       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
@@ -450,15 +446,15 @@ options:
         require "neri/ayame"
         @use_ayame = true
       end
-      
-      if options[:b2ec][:invisible] == nil &&
+
+      if options[:b2ec][:invisible].nil? &&
          (File.extname(scriptfile) == ".rbw" || @use_dxruby)
         options[:b2ec][:invisible] = true
       end
-      if options[:pause_last] == nil
-        options[:pause_last] = true unless options[:b2ec][:invisible]
+      if options[:pause_last].nil? && !options[:b2ec][:invisible]
+        options[:pause_last] = true
       end
-      
+
       require "rbconfig"
       dependencies = []
       dependencies += rb_dependencies
@@ -469,59 +465,58 @@ options:
       dependencies += additional_gems_dependencies
       dependencies += encoding_dependencies
       dependencies = select_dependencies(dependencies)
-      
-      size = dependencies.map{|d| File.size(d)}.inject(&:+)
+
+      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
-      
-      return dependencies
+
+      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")
+            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")
+            dependency.split(File::SEPARATOR).index("did_you_mean")
         end
       end
-      
-      return dependencies.uniq
+
+      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], "")
-      
+
       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!(/\/gems(\/\d+\.\d+\.\d+\/)gems\/(.+?)\-[^\/]+\/lib\//, "/vendor_ruby\\1")
+        system_files.each do |_src, desc|
+          desc.sub!(%r{/gems(/\d+\.\d+\.\d+/)gems/(.+?)-[^/]+/lib/}, "/vendor_ruby\\1")
         end
       end
-      
+
       system_files.each do |src, desc|
         FileUtils.makedirs(File.dirname(desc))
         if File.file?(src)
@@ -531,49 +526,47 @@ options:
       end
       FileUtils.copy(scriptfile, desc_dir) unless options[:datafile]
     end
-    
-    
-    def create_datafile()
-      if @data_files.size > 1 || options[:encryption_key]
-        options[:datafile] ||= basename + ".dat"
-      end
+
+    def create_datafile
       return unless options[:datafile]
-      
+
       nputs "Creating datafile '#{datafile}'."
       data_files = @data_files.select { |file| File.file? file }
       @data_files.select { |file| File.directory? file }.each do |dir|
-        data_files += Dir.glob(dir + "/**/*").select { |file| File.file? file }
+        data_files += Dir.glob("#{dir}/**/*").select { |file| File.file? file }
       end
       if options[:encryption_key]
         require "digest/sha2"
         @encryption_key = Digest::SHA2.hexdigest(options[:encryption_key])
       end
       Neri.key = @encryption_key || "0" * 64
-      open(datafile, "wb") do |f|
+      File.open(datafile, "wb") do |f|
         pos = 0
-        files_str = data_files.map{|file|
-          filename = File.expand_path(file)
-          filename = relative_path(filename, rubydir, "*neri*" + File::SEPARATOR)
-          filename = relative_path(filename, Dir.pwd)
+        files_str = data_files.map { |file|
+          fullpath = File.expand_path(file)
+          filename = if fullpath.start_with?(rubydir)
+                       relative_path(fullpath, rubydir, "*neri*#{File::SEPARATOR}")
+                     else
+                       file
+                     end
           filedata = [filename, File.size(file), pos]
           pos += File.size(file)
           pos += BLOCK_LENGTH - pos % BLOCK_LENGTH unless pos % BLOCK_LENGTH == 0
           nputs_v "  - #{filename}:#{File.size(file)} bytes"
           filedata.join("\t")
         }.join("\n").encode(Encoding::UTF_8)
-        
-        f.write(sprintf("%#{BLOCK_LENGTH}d", files_str.bytesize))
+
+        f.write(format("%#{BLOCK_LENGTH}d", files_str.bytesize))
         f.write(xor(files_str))
         data_files.each do |file|
           f.write(xor(File.binread(file)))
         end
       end
     end
-    
-    
-    def create_batfile()
+
+    def create_batfile
       nputs "Creating batch_file '#{basepath}.bat'."
-      
+
       pause_command = ""
       if options[:pause_last]
         pause_command += "echo.\n"
@@ -585,37 +578,37 @@ options:
         end
       end
       chdir = options[:chdir_first] ? 'cd /d "%~dp0"' : ""
-      
-      open(basepath + ".bat", "w:#{options[:external_encoding]}") do |f|
-        f.puts <<-EOF
+
+      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 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
-        EOF
+        BATCH
       end
     end
-    
-    def create_exefile()
+
+    def create_exefile
       unless system("gcc --version >nul 2>&1 && windres --version >nul 2>&1")
         error "gcc or windres not found !"
         create_batfile
         return
       end
-      
-      exe_file = to_winpath(basepath + ".exe"   )
-      c_file   = to_winpath(basepath + "_tmp.c" )
-      o_file   = to_winpath(basepath + "_tmp.o" )
-      rc_file  = to_winpath(basepath + "_tmp.rc")
+
+      exe_file = to_winpath("#{basepath}.exe"   )
+      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], "")))
       nputs "Creating exe_file '#{exe_file}'."
-      open(c_file, "w:#{options[:external_encoding]}") do |f|
-        f.puts <<-EOF
+      File.open(c_file, "w:#{options[:external_encoding]}") do |f|
+        f.puts <<-CFILE
 #include <stdio.h>
 #include <stdlib.h>
 #include <windows.h>
@@ -623,17 +616,17 @@ endlocal
 
 int main(int argc, char *argv[])
 {
-    char exepath[_MAX_PATH  *  2 + 1], 
+    char exepath[_MAX_PATH  *  2 + 1],
          drive  [_MAX_DRIVE      + 1],
          dir    [_MAX_DIR   *  2 + 1],
          fname  [_MAX_FNAME *  2 + 1],
          ext    [_MAX_EXT   *  2 + 1],
          paths  [_MAX_PATH  * 32 + 1],
          runruby[_MAX_PATH  * 32 + 1];
-    PROCESS_INFORMATION pi; 
+    PROCESS_INFORMATION pi;
     STARTUPINFO si;
     ZeroMemory(&si, sizeof(STARTUPINFO));
-    
+
     if(GetModuleFileName(NULL, exepath, MAX_PATH * 2) != 0){
         _splitpath_s(exepath, drive, _MAX_DRIVE, dir, _MAX_DIR * 2, fname, _MAX_FNAME * 2, ext, _MAX_EXT * 2);
     } else {
@@ -644,8 +637,8 @@ int main(int argc, char *argv[])
     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,"}
+    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] : "",
@@ -656,7 +649,7 @@ int main(int argc, char *argv[])
         argc > 8 ? argv[8] : "",
         argc > 9 ? argv[9] : ""
         );
-        EOF
+        CFILE
         if options[:b2ec][:invisible]
           f.puts %[    CreateProcess(NULL, runruby, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, NULL, &si, &pi);]
         else
@@ -673,14 +666,14 @@ int main(int argc, char *argv[])
         end
         f.puts "    return 0;\n}"
       end
-      
-      open(rc_file, "w:#{options[:external_encoding]}") do |f|
-        f.puts <<-EOF
+
+      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[:b2ec][:fileversion   ] ? "FILEVERSION     #{escape_cstr(options[:b2ec][:fileversion   ])}" : ""}
+#{options[:b2ec][:productversion] ? "PRODUCTVERSION  #{escape_cstr(options[:b2ec][:productversion])}" : ""}
 FILETYPE        VFT_APP
 BEGIN
     BLOCK "StringFileInfo"
@@ -709,16 +702,16 @@ BEGIN
 END
 
 2 ICON "#{escape_cstr(options[:b2ec][:icon])}"
-        EOF
+        RCFILE
       end
-      nsystem(%[windres -o "#{o_file}" "#{rc_file}"])
-      nsystem(%[gcc#{options[:b2ec][:invisible] ? " -mwindows" : ""} -o "#{exe_file}" "#{c_file}" "#{o_file}"])
-      nsystem(%[strip "#{exe_file}"])
+      nsystem(%(windres -o "#{o_file}" "#{rc_file}"))
+      nsystem(%(gcc#{options[:b2ec][: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]
@@ -727,18 +720,17 @@ END
       else
         ruby_code += "load File.expand_path('#{system_dir}' + #{unpack_filename(scriptfile)})"
       end
-      
+
       r  = " -rneri"
       r += " -rneri/dxruby"       if @use_dxruby
       r += " -rneri/dxruby_tiled" if @use_dxruby_tiled
       r += " -rneri/ayame"        if @use_ayame
-      
+
       ruby = to_winpath(relative_path(rubyexe, bindir))
-      return %[#{ruby}#{r} #{@rubyopt} -e "# coding:utf-8" -e "#{ruby_code}" #{@args}]
+      %(#{ruby}#{r} #{@rubyopt} -e "# coding:utf-8" -e "#{ruby_code}" #{@args})
     end
-    
-    
-    def bat_to_exe_converter()
+
+    def bat_to_exe_converter
       create_batfile
       begin
         `#{options[:b2ec_path]} /help`
@@ -746,36 +738,32 @@ END
         error "Bat To Exe Converter not found !"
         return
       end
-      
-      batch_file = basepath + ".bat"
-      exe_file   = basepath + ".exe"
+
+      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
-        options[:b2ec][:x64] = true if RbConfig::CONFIG["target"].to_s.index("64")
+      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|
+      args = %( /bat "#{batch_file}" /exe "#{exe_file}")
+      args += options[:b2ec].map { |key, value|
         case value
-        when String; %[ /#{key.to_s.tr("_", "-")} "#{value}"]
-        when true;   %[ /#{key.to_s.tr("_", "-")}]
-        else;        %[]
+        when String then %( /#{key.to_s.tr('_', '-')} "#{value}")
+        when true   then %( /#{key.to_s.tr('_', '-')})
+        else;            %()
         end
       }.join("")
-      
-      
-      unless nsystem "#{options[:b2ec_path]}#{args}"
-        error "Failed to create exe_file !"
-      end
+
+      error "Failed to create exe_file !" unless nsystem "#{options[:b2ec_path]}#{args}"
     end
-    
-    
-    def upx()
+
+    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|
@@ -784,78 +772,76 @@ END
         end
       end
     end
-    
-    
-    def create_zipfile()
+
+    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")
+        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()
+
+    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)
+        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}" }
+        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}" }
+        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}" }
+        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}" }
+        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}" }
+        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}" }
-      
+      script.sub!(/^(\[Files\])(\s*)/i) { "#{$1}#{files_str}#{$2}" }
+
       File.write(filename, script)
       command = %(#{options[:iscc_path]} "#{filename}")
       nsystem command
     end
-    
-    
-    def run()
+
+    def run
       check_options
       dependencies = check_dependencies
       copy_files(dependencies)
@@ -870,34 +856,33 @@ END
       inno_setup      if options[:inno_script]
       nputs "Neri Finished."
     end
-    
 
     private
-    
+
     def nputs(str)
       puts "=== #{str}" unless options[:quiet]
     end
-    
+
     def nputs_v(str)
       puts str if options[:verbose]
     end
-    
+
     def error(str)
       puts "\e[31m#{str}\e[0m"
     end
-    
+
     def unpack_filename(filename)
-      "[" + filename.unpack("U*").map { |u| u.to_s }.join(",") + "].pack('U*')"
+      "[#{filename.unpack('U*').map(&:to_s).join(',')}].pack('U*')"
     end
-    
+
     def escape_cstr(str)
-      str.gsub("\\"){ "\\\\" }.gsub('"'){ '\\"' }.gsub("'"){ "\\'" }
+      str.gsub("\\") { "\\\\" }.gsub('"') { '\\"' }.gsub("'") { "\\'" }
     end
-    
+
     def nsystem(str)
       nputs_v(str)
       command = str.encode(options[:external_encoding])
-      return system(command + (options[:quiet] ? " >nul 2>&1" : ""))
+      system(command + (options[:quiet] ? " >nul 2>&1" : ""))
     end
   end
 end

data/lib/neri/dxruby.rb

@@ -4,38 +4,28 @@ require "dxruby" unless defined? DXRuby
 
 module Neri
   module DXRubyImage
-    def load(path, x=nil, y=nil, width=nil, height=nil)
-      if Neri.exist_in_datafile?(path)
-        image = load_from_file_in_memory(Neri.file_read(path))
-        image = image.slice(x, y, width, height) if x && y && width && height
-        return image
-      else
-        return super
-      end
+    def load(path, x = nil, y = nil, width = nil, height = nil)
+      return super unless Neri.exist_in_datafile?(path)
+
+      image = load_from_file_in_memory(Neri.file_read(path))
+      image = image.slice(x, y, width, height) if x && y && width && height
+      image
     end
-    
-    def load_tiles(path, xcount, ycount, share_switch=true)
-      if Neri.exist_in_datafile?(path) && !share_switch
-        image = load_from_file_in_memory(Neri.file_read(path))
-        return image.slice_tiles(xcount, ycount)
-      else
-        return super
-      end
+
+    def load_tiles(path, xcount, ycount, share_switch = true)
+      return super unless Neri.exist_in_datafile?(path) && !share_switch
+
+      image = load_from_file_in_memory(Neri.file_read(path))
+      image.slice_tiles(xcount, ycount)
     end
   end
-  
+
   module DXRubySound
     def new(path)
-      if Neri.exist_in_datafile?(path)
-        case File.extname(path)
-        when ".mid"
-          return load_from_memory(Neri.file_read(path), DXRuby::TYPE_MIDI)
-        else
-          return load_from_memory(Neri.file_read(path), DXRuby::TYPE_WAV)
-        end
-      else
-        return super
-      end
+      return super unless Neri.exist_in_datafile?(path)
+
+      load_from_memory(Neri.file_read(path),
+                       File.extname(path) == ".mid" ? DXRuby::TYPE_MIDI : DXRuby::TYPE_WAV)
     end
   end
 end
@@ -46,7 +36,7 @@ module DXRuby
       prepend Neri::DXRubyImage
     end
   end
-  
+
   class Sound
     class << self
       prepend Neri::DXRubySound

data/lib/neri/dxruby_tiled.rb

@@ -5,7 +5,7 @@ require "dxruby_tiled" unless defined? DXRuby::Tiled
 module DXRuby
   module Tiled
     module_function
-    
+
     def read_file(file, encoding = Encoding::UTF_8)
       Neri.file_read(file, encoding)
     end

data/lib/neri/runtime.rb

@@ -1,7 +1,7 @@
 require "neri/version"
 
-alias :_neri_orig_require :require
-alias :_neri_orig_load    :load
+alias _neri_orig_require require
+alias _neri_orig_load    load
 
 def require(feature)
   Neri.require(feature)
@@ -16,12 +16,14 @@ module Neri
   @datafile = nil
   @system_dir = nil
   @files = {}
+  @fullpath_files = nil
+  @current_directory = nil
   @xor = nil
-  
+
   class << self
     def datafile=(datafile)
-      @datafile = datafile
-      @system_dir = File.dirname(File.expand_path(datafile)) + File::SEPARATOR
+      @datafile = datafile.encode(Encoding::UTF_8)
+      @system_dir = File.dirname(File.expand_path(@datafile)) + File::SEPARATOR
       files_length = File.binread(@datafile, BLOCK_LENGTH).to_i
       files_str = read(files_length, BLOCK_LENGTH)
       pos = files_length + BLOCK_LENGTH
@@ -31,116 +33,116 @@ module Neri
         filename, length, offset = line.split("\t")
         @files[filename] = [length.to_i, offset.to_i + pos]
       end
+      @current_directory = nil
     end
-    
+
     def key=(key)
-      @xor = key.scan(/../).map{|a| a.to_i(16)}.pack("c*")
+      @xor = key.scan(/../).map { |a| a.to_i(16) }.pack("c*")
     end
-    
+
     def require(feature)
+      feature = feature.encode(Encoding::UTF_8)
       filepath = nil
-      (feature.match?(/\A([a-z]:|\\|\/|\.)/i) ? [""] : load_path).each do |path|
+      (feature.start_with?(/[a-z]:/i, "\\", "/", ".") ? [""] : load_path).each do |path|
         ["", ".rb"].each do |ext|
-          next unless exist_in_datafile?(path + feature + ext)
-          filepath = adjust_path(path + feature + ext)
+          tmp_path = path + feature + ext
+          filepath ||= tmp_path if exist_in_datafile?(tmp_path)
         end
       end
-      
-      if filepath
-        return false if $LOADED_FEATURES.index(filepath)
-        code = load_code(filepath)
-        eval(code, TOPLEVEL_BINDING, filepath)
-        $LOADED_FEATURES.push(filepath)
-        return true
-      else
-        return _neri_orig_require(feature)
-      end
+
+      return _neri_orig_require(feature) unless filepath
+      return false if $LOADED_FEATURES.index(filepath)
+
+      code = load_code(filepath)
+      eval(code, TOPLEVEL_BINDING, filepath)
+      $LOADED_FEATURES.push(filepath)
+      true
     end
-    
+
     def load(file, priv = false)
+      file = file.encode(Encoding::UTF_8)
       filepath = nil
-      (load_path + [""]).each do |path|
-        filepath = path + file if exist_in_datafile?(path + file)
+      paths = file.start_with?(/[a-z]:/i, "\\", "/", ".") ? [""] : load_path + [""]
+      paths.each do |path|
+        filepath ||= path + file if exist_in_datafile?(path + file)
       end
-      
-      if filepath
-        code = load_code(filepath)
-        if priv
-          Module.new.module_eval(code, filepath)
-        else
-          eval(code, TOPLEVEL_BINDING, filepath)
-        end
+
+      return _neri_orig_load(file, priv) unless filepath
+
+      code = load_code(filepath)
+      if priv
+        Module.new.module_eval(code, filepath)
       else
-        _neri_orig_load(filepath || file, priv)
+        eval(code, TOPLEVEL_BINDING, filepath)
       end
+      true
     end
-    
+
     def file_exist?(filename)
-      return exist_in_datafile?(filename) || File.exist?(filename)
+      exist_in_datafile?(filename) || File.exist?(filename)
     end
-    
+
     def file_read(filename, encoding = Encoding::BINARY)
+      filename = filename.encode(Encoding::UTF_8)
       str = nil
       if exist_in_datafile?(filename)
-        length, offset = @files[adjust_path(filename.encode(Encoding::UTF_8))]
+        length, offset = fullpath_files[File.expand_path(filename)]
         str = read(length, offset)
       else
         str = File.binread(filename)
       end
       str.force_encoding(encoding)
-      return str
     end
-    
-    def files()
-      return @files.keys
+
+    def files
+      @files.keys
     end
-    
+
     def exist_in_datafile?(filename)
-      return @files.has_key?(adjust_path(filename.encode(Encoding::UTF_8)))
+      fullpath_files.key?(File.expand_path(filename.encode(Encoding::UTF_8)))
     end
-    
+
     private
-    
-    def xor(str)
-      str.force_encoding(Encoding::BINARY)
-      while str.bytesize % BLOCK_LENGTH != 0
-        str << rand(256).chr
-      end
-      if defined?(Xorcist)
-        return Xorcist.xor!(str, @xor * (str.bytesize / BLOCK_LENGTH))
-      else
-        s = []
-        str.unpack("Q*").zip((@xor * (str.bytesize / BLOCK_LENGTH)).unpack("Q*")){|a, b| s.push(a ^ b)}
-        return s.pack("Q*")
+
+    def fullpath_files
+      if @current_directory != Dir.pwd
+        @current_directory = Dir.pwd
+        @fullpath_files = @files.transform_keys { |k| File.expand_path(k) }
       end
+      @fullpath_files
     end
-    
-    def adjust_path(path)
-      return path.sub(/^\.\//, "")
+
+    def xor(str)
+      str.force_encoding(Encoding::BINARY)
+      str << rand(256).chr while str.bytesize % BLOCK_LENGTH != 0
+      xor_str = @xor * (str.bytesize / BLOCK_LENGTH)
+      return Xorcist.xor!(str, xor_str) if defined?(Xorcist)
+
+      s = []
+      str.unpack("Q*").zip((xor_str).unpack("Q*")) { |a, b| s.push(a ^ b) }
+      s.pack("Q*")
     end
-    
+
     def read(length, offset)
-      if @xor
-        tmp_length = length
-        tmp_length += BLOCK_LENGTH - length % BLOCK_LENGTH unless length % BLOCK_LENGTH == 0
-        return xor(File.binread(@datafile, tmp_length, offset))[0, length]
-      else
-        return File.binread(@datafile, length, offset)
-      end
+      return File.binread(@datafile, length, offset) unless @xor
+
+      tmp_length = length
+      tmp_length += BLOCK_LENGTH - length % BLOCK_LENGTH unless length % BLOCK_LENGTH == 0
+      xor(File.binread(@datafile, tmp_length, offset))[0, length]
     end
-    
-    def load_path()
+
+    def load_path
       paths = $LOAD_PATH.map { |path| path.encode(Encoding::UTF_8) }
       return paths unless @system_dir
+
       paths.map { |path| path.sub(@system_dir, "*neri*#{File::SEPARATOR}") + File::SEPARATOR }
     end
-    
+
     def load_code(file)
       code = file_read(file)
       encoding = "UTF-8"
-      encoding = $1 if code.lines[0..2].join("\n").match(/coding:\s*(\S+)/)
+      encoding = Regexp.last_match(1) if code.lines[0..2].join("\n").match(/coding:\s*(\S+)/)
       code.force_encoding(encoding)
-      return code
     end
   end
 end

data/lib/neri/version.rb

@@ -1,3 +1,3 @@
 module Neri
-  VERSION = "0.9.2"
+  VERSION = -"0.9.3"
 end

data/neri.gemspec

@@ -8,11 +8,11 @@ Gem::Specification.new do |spec|
   spec.authors       = ["nodai2hITC"]
   spec.email         = ["nodai2h.itc@gmail.com"]
 
-  spec.summary       = %q{One-Click Ruby Application Builder}
-  spec.description   = %q{Neri builds Windows batfile or exefile from Ruby script.}
+  spec.summary       = "One-Click Ruby Application Builder"
+  spec.description   = "Neri builds Windows batfile or exefile from Ruby script."
   spec.homepage      = "https://github.com/nodai2hITC/neri"
   spec.license       = "MIT"
-  spec.required_ruby_version = ">= 2.4.0"
+  spec.required_ruby_version = ">= 2.5.0"
 
   # spec.metadata["allowed_push_host"] = "TODO: Set to 'https://mygemserver.com'"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neri
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - nodai2hITC
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-22 00:00:00.000000000 Z
+date: 2021-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: win32api
@@ -63,14 +63,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.27
+rubygems_version: 3.2.30
 signing_key:
 specification_version: 4
 summary: One-Click Ruby Application Builder