neri 0.9.4 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8829588155f0a2fa2381d8a6da3f2010136a1c22b3b5e9168cacddb8d78cae1c
-  data.tar.gz: 5f0fcf15b0ea35ee9c1dfaf56a83b1284ad542eaa68ab805c077a70b3b487089
+  metadata.gz: 588a4e8a5a9ad862218a5ed2b58607fc6433d0dfd3921b82201053194e4b11e2
+  data.tar.gz: 643ad4e58dfb6235532967bff42fcbcb2482abf78a47f4e180e22012b3105c52
 SHA512:
-  metadata.gz: 7d8bb8a32247d0a4a8e3dfdd3bc933064f531384db15d2f01209c900905b8a1b59166bb61d1cb8137b97eec0d77677c20a8fb26c14e4a3dfbd0877834cff06ae
-  data.tar.gz: c6551635e0f20d969c770c5bb2b8355c1f0e1f4e1b815089690d3115140a2015d90f0c6221ac2fc927cf013ceac574f70f388a15ecda5a3904bba5e83853ffed
+  metadata.gz: 0e653c9a96b631386bd0501ace47feafa2c46d58d68358cb9735f9e1d53a03bcb3f8e7710e8f54c874c932c03c9bc9c91b47e5cee34741b7c1661cffc06d7983
+  data.tar.gz: 8ca1e16f5eb2e768ceec1dc5d1e04a019985411c684d70b186cec26796f044308d01cb68263f86e23dba7ef4e986df95278ede44200e0220e7938618080ff2ca

data/lib/neri/build.rb

@@ -18,7 +18,7 @@ module Neri
 
     enable_gems:         false,
     enable_did_you_mean: false,
-    chdir_first:         false,
+    chdir_first:         true,
     pause_last:          nil,
     pause_text:          nil,
 
@@ -27,6 +27,7 @@ module Neri
 
     datafile:       nil,
     encryption_key: nil,
+    virtual_directory: nil,
 
     no_exe: false,
     use_b2ec: false,
@@ -111,7 +112,7 @@ options:
 
   --enable-gems
   --enable-did-you-mean
-  --chdir-first
+  --no-chdir
   --pause-last
   --no-pause-last
   --pause-text <text>
@@ -155,6 +156,7 @@ options:
 
   --create-recipe <recipefile>
   --recipe <recipefile>
+  --virtual-directory <string>
       HELP_MESSAGE
     end
 
@@ -209,7 +211,9 @@ options:
           options[:enable_gems] = true
         when "--enable-did-you-mean"
           options[:enable_did_you_mean] = true
-        when "--chdir-first"
+        when "--no-chdir"
+          options[:chdir_first] = false
+        when "--chdir-first" # deprecated
           options[:chdir_first] = true
         when "--pause-last"
           options[:pause_last] = true
@@ -292,6 +296,8 @@ options:
           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")
         when "--"
           break
         when /^(--.+)/
@@ -328,27 +334,54 @@ options:
     end
 
     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")
-
+      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_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_LONG,
+        Fiddle::Importer.const_get(:CALL_TYPE_TO_ABI)[:stdcall]
+      )
+      getcurrentprocess = Fiddle::Function.new(
+        kernel32["GetCurrentProcess"],
+        [],
+        Fiddle::TYPE_LONG,
+        Fiddle::Importer.const_get(:CALL_TYPE_TO_ABI)[:stdcall]
+      )
+      
       bytes_needed = 4 * 32
       module_handle_buffer = nil
       process_handle = getcurrentprocess.call
       loop do
         module_handle_buffer = "\x00" * bytes_needed
         bytes_needed_buffer = [0].pack("I")
-        enumprocessmodules.call(process_handle, module_handle_buffer, module_handle_buffer.size, bytes_needed_buffer)
+        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)
+        )
         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_length = getmodulefilename.call(
+          [handle].pack("I").unpack1("i"),
+          [str].pack("p").unpack1(pointer_type),
+          [str.size].pack("I").unpack1("i")
+        )
         str[0, modulefilename_length * 2].force_encoding("UTF-16LE").encode("UTF-8")
       end
 
@@ -535,7 +568,20 @@ options:
       @data_files.select { |file| File.directory? file }.each do |dir|
         data_files += Dir.glob("#{dir}/**/*").select { |file| File.file? file }
       end
-      data_files = data_files.reverse.uniq { |file| File.expand_path(file) }
+      data_files.uniq! { |file| File.expand_path(file) }
+
+      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_/")
+        puts "virtual_directory: #{options[:virtual_directory]}"
+      end
+
       if options[:encryption_key]
         require "digest/sha2"
         @encryption_key = Digest::SHA2.hexdigest(options[:encryption_key])
@@ -543,23 +589,20 @@ options:
       Neri.key = @encryption_key || "0" * 64
       File.open(datafile, "wb") do |f|
         pos = 0
-        files_str = data_files.map { |file|
+        file_informations = data_files.map do |file|
           fullpath = File.expand_path(file)
           filename = if fullpath.start_with?(rubydir)
-                       relative_path(fullpath, rubydir, "*neri*#{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"
-          if File.expand_path(filename).start_with?(Dir.pwd) && filename.include?("..")
-            cd_path = ".#{File.expand_path(filename).delete_prefix(Dir.pwd)}"
-            filedata += "\n" + [cd_path, File.size(file), pos].join("\t")
-          end
           pos += File.size(file)
           pos += BLOCK_LENGTH - pos % BLOCK_LENGTH unless pos % BLOCK_LENGTH == 0
           filedata
-        }.join("\n").encode(Encoding::UTF_8)
+        end
+        files_str = file_informations.join("\n").encode(Encoding::UTF_8)
 
         f.write(format("%#{BLOCK_LENGTH}d", files_str.bytesize))
         f.write(xor(files_str))
@@ -721,6 +764,9 @@ END
       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])};"
+        end
         ruby_code += "load #{unpack_filename(File.basename(scriptfile))}"
       else
         ruby_code += "load File.expand_path('#{system_dir}' + #{unpack_filename(scriptfile)})"

data/lib/neri/runtime.rb

@@ -1,79 +1,91 @@
 require "neri/version"
+require "pathname"
 
-alias _neri_orig_require require
-alias _neri_orig_load    load
+module Kernel
+  unless defined?(neri_original_require)
+    alias    neri_original_require require
+    private :neri_original_require
+  end
 
-def require(feature)
-  Neri.require(feature)
-end
+  unless defined?(neri_original_load)
+    alias    neri_original_load load
+    private :neri_original_load
+  end
+
+  def require(feature)
+    Neri.require(feature)
+  end
 
-def load(file, priv = false)
-  Neri.load(file, priv)
+  def load(file, priv = false)
+    Neri.load(file, priv)
+  end
 end
 
 module Neri
   BLOCK_LENGTH = 32
   @datafile = nil
-  @system_dir = nil
-  @files = {}
-  @fullpath_files = nil
-  @current_directory = nil
+  @file_informations = {}
+  @fullpath_files = {}
+  @virtual_files = {}
+  @virtual_directory = "."
   @xor = nil
 
   class << self
     def datafile=(datafile)
       @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
       pos += BLOCK_LENGTH - pos % BLOCK_LENGTH unless pos % BLOCK_LENGTH == 0
       files_str.force_encoding(Encoding::UTF_8)
-      files_str.split("\n").each do |line|
+      files_str.each_line do |line|
         filename, length, offset = line.split("\t")
-        @files[filename] = [length.to_i, offset.to_i + pos]
+        @file_informations[filename] = [length.to_i, offset.to_i + pos]
       end
-      @current_directory = nil
+      @fullpath_files = @file_informations.transform_keys { |k| File.expand_path(k) }
     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.start_with?(/[a-z]:/i, "\\", "/", ".") ? [""] : load_path).each do |path|
-        ["", ".rb"].each do |ext|
-          tmp_path = path + feature + ext
-          filepath ||= tmp_path if exist_in_datafile?(tmp_path)
-        end
-      end
-
-      return _neri_orig_require(feature) unless filepath
-      return false if $LOADED_FEATURES.index(filepath)
+    def virtual_directory=(path)
+      @virtual_directory = path
+      @virtual_files = @file_informations.transform_keys { |k| File.expand_path(k, path) }
+    end
 
-      code = load_code(filepath)
-      eval(code, TOPLEVEL_BINDING, filepath)
-      $LOADED_FEATURES.push(filepath)
+    def require(feature)
+      feature_path = Pathname.new(feature.encode(Encoding::UTF_8))
+      feature_path = feature_path.sub_ext(".rb") if feature_path.extname == ""
+      return neri_original_require(feature) if feature_path.extname == ".so"
+
+      path_str = if feature_path.absolute? || feature.start_with?(".")
+                   path_in_datafile(feature_path)
+                 else
+                   search_in_load_path(feature_path)
+                 end
+
+      return neri_original_require(feature) unless path_str
+      return false if $LOADED_FEATURES.index(path_str)
+
+      code = load_code(path_str)
+      eval(code, TOPLEVEL_BINDING, path_str)
+      $LOADED_FEATURES.push(path_str)
       true
     end
 
     def load(file, priv = false)
-      file = file.encode(Encoding::UTF_8)
-      filepath = nil
-      paths = file.start_with?(/[a-z]:/i, "\\", "/", ".") ? [""] : load_path + [""]
-      paths.each do |path|
-        filepath ||= path + file if exist_in_datafile?(path + file)
-      end
+      file_path = Pathname.new(file.encode(Encoding::UTF_8))
+      path_str = search_in_load_path(file_path) if file_path.relative? && !file.start_with?(".")
+      path_str ||= path_in_datafile(file_path)
 
-      return _neri_orig_load(file, priv) unless filepath
+      return neri_original_load(file, priv) unless path_str
 
-      code = load_code(filepath)
+      code = load_code(path_str)
       if priv
-        Module.new.module_eval(code, filepath)
+        Module.new.module_eval(code, path_str)
       else
-        eval(code, TOPLEVEL_BINDING, filepath)
+        eval(code, TOPLEVEL_BINDING, path_str)
       end
       true
     end
@@ -84,32 +96,26 @@ module Neri
 
     def file_read(filename, encoding = Encoding::BINARY)
       filename = filename.encode(Encoding::UTF_8)
-      str = nil
-      if exist_in_datafile?(filename)
-        length, offset = fullpath_files[File.expand_path(filename)]
-        str = read(length, offset)
-      else
-        str = File.binread(filename)
-      end
+      length, offset = file_information(filename)
+      str = length ? read(length, offset) : File.binread(filename)
       str.force_encoding(encoding)
     end
 
     def files
-      @files.keys
+      @file_informations.keys
     end
 
     def exist_in_datafile?(filename)
-      fullpath_files.key?(File.expand_path(filename.encode(Encoding::UTF_8)))
+      file_information(filename) != nil
     end
 
     private
 
-    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
+    def file_information(filename)
+      fullpath = File.expand_path(filename)
+      return @fullpath_files[fullpath] if @fullpath_files.key?(fullpath)
+
+      @virtual_files[File.expand_path(filename, @virtual_directory)]
     end
 
     def xor(str)
@@ -131,11 +137,21 @@ module Neri
       xor(File.binread(@datafile, tmp_length, offset))[0, length]
     end
 
-    def load_path
-      paths = $LOAD_PATH.map { |path| path.encode(Encoding::UTF_8) }
-      return paths unless @system_dir
+    def search_in_load_path(file_path)
+      $LOAD_PATH.each do |path_str|
+        load_path = Pathname.new(path_str.encode(Encoding::UTF_8))
+        candidate_path_str = path_in_datafile(load_path + file_path)
+        return candidate_path_str if candidate_path_str
+      end
+      nil
+    end
+
+    def path_in_datafile(file_path)
+      fullpath = File.expand_path(file_path.to_s)
+      return fullpath if exist_in_datafile?(fullpath)
 
-      paths.map { |path| path.sub(@system_dir, "*neri*#{File::SEPARATOR}") + File::SEPARATOR }
+      virtual_path = File.expand_path(file_path.to_s, @virtual_directory)
+      exist_in_datafile?(virtual_path) ? virtual_path : nil
     end
 
     def load_code(file)

data/lib/neri/version.rb

@@ -1,3 +1,3 @@
 module Neri
-  VERSION = -"0.9.4"
+  VERSION = -"0.9.5"
 end

data/neri.gemspec

@@ -30,6 +30,4 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-
-  spec.add_dependency "win32api"
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: neri
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5
 platform: ruby
 authors:
 - nodai2hITC
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-24 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: win32api
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2021-12-29 00:00:00.000000000 Z
+dependencies: []
 description: Neri builds Windows batfile or exefile from Ruby script.
 email:
 - nodai2h.itc@gmail.com