neri 0.9.1 → 0.9.5

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,146 +1,164 @@
 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 load(file, priv = false)
-  Neri.load(file, priv)
+  def require(feature)
+    Neri.require(feature)
+  end
+
+  def load(file, priv = false)
+    Neri.load(file, priv)
+  end
 end
 
 module Neri
   BLOCK_LENGTH = 32
   @datafile = nil
-  @system_dir = nil
-  @files = {}
+  @file_informations = {}
+  @fullpath_files = {}
+  @virtual_files = {}
+  @virtual_directory = "."
   @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)
       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
+      @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 virtual_directory=(path)
+      @virtual_directory = path
+      @virtual_files = @file_informations.transform_keys { |k| File.expand_path(k, path) }
     end
-    
+
     def require(feature)
-      filepath = nil
-      (feature.match?(/\A([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)
-        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
+      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)
-      filepath = nil
-      (load_path + [""]).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
+      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_original_load(file, priv) unless path_str
+
+      code = load_code(path_str)
+      if priv
+        Module.new.module_eval(code, path_str)
       else
-        _neri_orig_load(filepath || file, priv)
+        eval(code, TOPLEVEL_BINDING, path_str)
       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)
-      str = nil
-      if exist_in_datafile?(filename)
-        length, offset = @files[adjust_path(filename.encode(Encoding::UTF_8))]
-        str = read(length, offset)
-      else
-        str = File.binread(filename)
-      end
+      filename = filename.encode(Encoding::UTF_8)
+      length, offset = file_information(filename)
+      str = length ? read(length, offset) : File.binread(filename)
       str.force_encoding(encoding)
-      return str
     end
-    
-    def files()
-      return @files.keys
+
+    def files
+      @file_informations.keys
     end
-    
+
     def exist_in_datafile?(filename)
-      return @files.has_key?(adjust_path(filename.encode(Encoding::UTF_8)))
+      file_information(filename) != nil
     end
-    
+
     private
-    
+
+    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)
       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*")
-      end
-    end
-    
-    def adjust_path(path)
-      return path.sub(/^\.\//, "")
+      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)
+      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 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 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 }
+
+    def path_in_datafile(file_path)
+      fullpath = File.expand_path(file_path.to_s)
+      return fullpath if exist_in_datafile?(fullpath)
+
+      virtual_path = File.expand_path(file_path.to_s, @virtual_directory)
+      exist_in_datafile?(virtual_path) ? virtual_path : nil
     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.1"
+  VERSION = -"0.9.5"
 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'"
 
@@ -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.1
+  version: 0.9.5
 platform: ruby
 authors:
 - nodai2hITC
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-22 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
@@ -63,14 +49,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