neri 0.9.4 → 1.0.0

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,22 @@ 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|
+        path_str = path_str.dup.force_encoding(Encoding::UTF_8) if path_str.encoding == Encoding::BINARY
+        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 = -"1.0.0"
 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: 1.0.0
 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: 2022-01-08 00:00:00.000000000 Z
+dependencies: []
 description: Neri builds Windows batfile or exefile from Ruby script.
 email:
 - nodai2h.itc@gmail.com
@@ -70,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.30
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: One-Click Ruby Application Builder