neri 0.9.3 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9c11506aa1729506a8f2386ea1a37e45c6ef5f72cec65e3677931ef6f18910f
-  data.tar.gz: fb4307dd5e026985659ab652e27436759bd60531f1b9044ab6ca82f6d28eab22
+  metadata.gz: 54122cb7af8b62506615a9be8916791a0051fd6cfc4ad395727a23714997b019
+  data.tar.gz: c79aa6b985eadfa33888aeb35af6fe70f4b17ec89d38d581bffccbf789de5b3b
 SHA512:
-  metadata.gz: b2d6307c498084b7327d96fb041304b6df4f2aca8756a81f90d6065b1a5b966eef64056d76ca6917267bd75f531ec1bead1e987195fc7379276d0de3233af7aa
-  data.tar.gz: b2002fe10dc92c4c87ddf7e961d77c5bddda93f0b9782b41e87e2b4ae5cc969b11123217b98f4d91d75a25c64db934a3db8eab6ed39be6072f3c046214923811
+  metadata.gz: a3bf286b9a366b38a4c37749ea48d690724331bd5aa208a435cbff987e160fc501d2617014a05ac047864c6a97f62e3f571ca077857119877d392640ab542fb2
+  data.tar.gz: d1830c564fdbe69c2418936ce86227509292ea0c05af462a5ac886fd8f8ebf5bbc931fb08a99a23dc71685df84d913bbe1b2c669eb31491fe17818b0b2fcf704

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 /^(--.+)/
@@ -317,6 +323,7 @@ options:
       unless options[:enable_did_you_mean] || @rubyopt.index("--disable-did_you_mean")
         @rubyopt += " --disable-did_you_mean"
       end
+      @rubyopt.sub!(%r{-r\S+/bundler/setup}, "")
       if @data_files.size > 1 || options[:encryption_key]
         options[:datafile] ||= "#{basename}.dat"
       end
@@ -328,27 +335,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,6 +569,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.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_/")
+        nputs "virtual_directory: #{options[:virtual_directory]}"
+      end
+
       if options[:encryption_key]
         require "digest/sha2"
         @encryption_key = Digest::SHA2.hexdigest(options[:encryption_key])
@@ -542,19 +590,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]
+          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
-          nputs_v "  - #{filename}:#{File.size(file)} bytes"
-          filedata.join("\t")
-        }.join("\n").encode(Encoding::UTF_8)
+          filedata
+        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))
@@ -716,6 +765,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.3"
+  VERSION = -"0.9.7"
 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.3
+  version: 0.9.7
 platform: ruby
 authors:
 - nodai2hITC
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-21 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