neri 0.9.0 → 0.9.4

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,115 +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
-      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, nil, 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, nil, 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()
-      return $LOAD_PATH unless @system_dir
-      return $LOAD_PATH.map{|path| path.sub(@system_dir, "*neri*#{File::SEPARATOR}") + File::SEPARATOR }
+
+    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.0"
+  VERSION = -"0.9.4"
 end

data/neri.gemspec

@@ -1,36 +1,35 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "neri/version"
+# frozen_string_literal: true
+
+require_relative "lib/neri/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "neri"
   spec.version       = Neri::VERSION
   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"
-  
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  if spec.respond_to?(:metadata)
-    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-  else
-    raise "RubyGems 2.0 or newer is required to protect against " \
-      "public gem pushes."
-  end
-  
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+  spec.required_ruby_version = ">= 2.5.0"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'https://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
   end
   spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  
-  spec.add_development_dependency "bundler", "~> 1.15"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "pry"
+
+  spec.add_dependency "win32api"
 end

metadata

@@ -1,51 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: neri
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.4
 platform: ruby
 authors:
 - nodai2hITC
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-08-16 00:00:00.000000000 Z
+date: 2021-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: pry
+  name: win32api
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -60,7 +32,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.ja.md
@@ -81,8 +52,10 @@ files:
 homepage: https://github.com/nodai2hITC/neri
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/nodai2hITC/neri
+  source_code_uri: https://github.com/nodai2hITC/neri
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,16 +63,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-signing_key: 
+rubygems_version: 3.2.30
+signing_key:
 specification_version: 4
 summary: One-Click Ruby Application Builder
 test_files: []

data/.gitignore

@@ -1,9 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/