eturem 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c96c7ae5b183ce6fc301daa33a6279158dbe2e4426dce6dde798834dc84901dc
-  data.tar.gz: 1bfe20edbb9da9e037b7ebe0896c62f4975631f5760fde2900ff814cc99ea3de
+  metadata.gz: 767768a9b608e0cf83064badb5717aecec8d95d729cd6f578944e69240410145
+  data.tar.gz: 91f5d7e50048c588b5ec8ee922ee7db379173b64e731382f0f4e14f07c1b81ec
 SHA512:
-  metadata.gz: 5f929faa102e9a9b297d4732dd36cfe19a83ae3cb89b54b7ff1f60db16c4d30c872524fe6717f39120bd9096670f90c77244afa36d1e0088efe6c89b46f3becc
-  data.tar.gz: 044c90b8262a37e838c197002c479f913a767344065f551a9973b5cff46d904193d38f5def3d2180021452166e3c05a120be06519a95e7a8c03e6f0a1885b100
+  metadata.gz: 288c49a8a1093d696fcc897f076a21c800640ee9b6229a48325f68ed769acf366fcdb4c085b09ebb2f0f3a1386f9f95d2d417f2f99a96733c50bb238d030b834
+  data.tar.gz: c658ff6c2fa82566e5052b515306b78cd096bca286d2a41875f2ef0aec1271dcb7a0f44962e7bb51c8d466485f37d4d86a5f79a840d471569b31dbf4689a16d9

data/Gemfile

@@ -1,6 +1,7 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
 # Specify your gem's dependencies in eturem.gemspec
 gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 nodai2hITC
+Copyright (c) 2018-2020 nodai2hITC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.ja.md

@@ -12,6 +12,10 @@ Easy To Understand Ruby Error Message の略。
 
     $ ruby -returem/ja <your_script.rb>
 
+または
+
+    $ eturem lang=ja <your_script.rb>
+
 と使用すればよいのですが、最初に書いたとおり初心者が使用することを想定した gem ですので、そんなことを初心者に強いるのは酷というもの。だれか詳しい人が、事前に ```gem install eturem``` した上で、環境変数 RUBYOPT に ```-returem/ja``` を追加しておいてあげましょう。
 
 ## 使用するとどうなるか
@@ -129,7 +133,7 @@ Eturem を使用すると、次のようなエラー表示になります。
  => 2: puts "a" if a = 1
 ```
 
-現状「条件式内での = 使用」のみにしか対応していませんが、上記のように日本語での警告に加えて該当行を表示することができます。
+現状あまり多くの種類の警告に対応できてはいませんが、上記のように日本語での警告に加えて該当行を表示することができます。
 
 ### 例５：エラー発生時に自動で binding.irb
 
@@ -139,9 +143,33 @@ Eturem を使用すると、次のようなエラー表示になります。
 
 なお、この機能だけを切り出した gem「[autoirb](https://github.com/nodai2hITC/autoirb)」もあります。
 
+### その他細かなこと
+
+#### 全角空白・全角記号による NameError
+
+日本人ならきっと誰もがやったことがあり、そして意外と気付けない全角空白や全角記号によるエラー。通常の NameError の場合とは異なるメッセージでわかりやすくしています。（下の表示ではわかりませんが、実際には全角空白部分に下線が引かれています。）
+
+```
+【エラー】ファイル"example5.rb" 1行目：(NoMethodError)
+スクリプト中に全角空白が混じっています。
+ => 1: puts　"こんにちは世界"
+```
+
+#### 大文字・小文字を間違えた場合の NameError
+
+did_you_mean は、例えば `Time.now` と書くべきところを `time.now` と間違えて小文字で書いてしまった場合、 `Time` をサジェストしないようになっています。（サジェスト範囲を広げると誤反応が多くなるため、敢えてそうしているのだそうです。）
+
+とはいえ、初心者は大文字小文字が区別されるという意識が無く、つい小文字で入力してしまうことが少なからずあるように思えます。そこでスペルが同一で大文字小文字のみが異なる場合に限り、定数もサジェスト対象になるようにしています。
+
+```
+【エラー】ファイル"example6.rb" 1行目：(NameError)
+変数/メソッド「time」は存在しません。「Time」の入力ミスではありませんか？
+ => 1: start_time = time.now
+```
+
 ## .eturem ファイルによる設定
 
-HOME に「.eturem」というファイルを用意すると、詳細設定ができます。
+HOME またはカレントディレクトリに「.eturem」というファイルを用意すると、詳細設定ができます。（下の例の設定が、各項目を省略した際に使用される初期値です。）
 
 ```
 enable: true
@@ -150,6 +178,7 @@ lang: en
 output_backtrace: true
 output_original: true
 output_script: true
+override_warning: true
 use_coderay: false
 before_line_num: 2
 after_line_num: 2
@@ -157,13 +186,27 @@ repl: nil
 ```
 
 - enable: eturem の使用/不使用を切り替えます。
-- debug: eturem 自体をデバッグするための機能なので、使う必要はありません。
-- lang: 表示言語を切り替えます。ただし、`-returem/ja` のように言語を指定して使用した場合、この設定よりもそちらが優先されます。
+- debug: eturem 自体をデバッグするための機能なので、通常は使う必要はありません。
+- lang: 表示言語を切り替えます。ただし `-returem/ja` のように言語を指定して使用した場合、この設定よりもそちらが優先されます。
 - output_backtrace: バックトレース表示の有無を切り替えます。
 - output_original: Ruby 本来のエラーメッセージの表示の有無を切り替えます。
 - output_script: エラーの起きた個所のスクリプト表示の有無を切り替えます。
+- override_warning: 警告に対してもわかりやすいメッセージを表示するかを設定します。
 - before_line_num / after_line_num: スクリプト表示の際、エラー行の前後何行を表示するかを設定します。
-- repl: irb または pry と書いておくと、エラー発生時に binding.irb / binding.pry します。
+- repl: irb または pry と書いておくと、エラー発生時に自動的に binding.irb / binding.pry します。
+
+## 簡単な仕組み
+
+```ruby
+begin
+  load($PROGRAM_NAME)
+rescue Exception => e
+  # エラー表示処理
+end
+exit
+```
+
+実際はもう少しいろいろやっていますが、このように本来のスクリプト実行が始まる前に `-returem` オプションで eturem を呼び出し、そこから `load` でスクリプトを実行しているのがポイントです。これにより、SyntaxError 等も取得できるようになっています。
 
 ## Contributing
 

data/README.md

@@ -14,6 +14,10 @@ install it yourself as:
 
     $ ruby -returem <your_script.rb>
 
+or
+
+    $ eturem <your_script.rb>
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/nodai2hITC/eturem. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/eturem.gemspec

@@ -1,7 +1,5 @@
 
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "eturem/version"
+require_relative 'lib/eturem/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "eturem"
@@ -13,24 +11,20 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Easy To Understand Ruby Error Message.}
   spec.homepage      = "https://github.com/nodai2hITC/eturem"
   spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
-  # 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.metadata["allowed_push_host"] = "Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+#  spec.metadata["changelog_uri"] = spec.homepage
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+  # 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('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
 end

data/exe/eturem

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+lang = nil
+if ARGV.first.to_s =~ /^lang=(.+)$/
+  lang = $1 
+  ARGV.shift
+end
+
+if ARGV.empty?
+  puts "usage: eturem (lang=**) script.rb"
+  exit
+end
+
+$PROGRAM_NAME = ARGV.shift
+require lang ? "eturem/#{lang}" : "eturem"

data/lib/eturem.rb

@@ -4,39 +4,59 @@ lang   = "en"
 output_backtrace = true
 output_original  = true
 output_script    = true
+override_warning = true
 use_coderay      = false
 before_line_num  = 2
 after_line_num   = 2
 repl             = nil
 
-if File.exist?($PROGRAM_NAME)
-  config_file = File.join(Dir.home, ".eturem")
-  if File.exist?(config_file)
-    config = File.read(config_file)
-    enable = false                    if config.match(/^enable\s*\:\s*(?:false|off|0)/i)
-    debug  = true                     if config.match(/^debug\s*\:\s*(?:true|on|1)/i)
-    lang   = Regexp.last_match(:lang) if config.match(/^lang\s*\:\s*(?<lang>\S+)/i)
-    output_backtrace = false if config.match(/^output_backtrace\s*\:\s*(?:false|off|0)/i)
-    output_original  = false if config.match( /^output_original\s*\:\s*(?:false|off|0)/i)
-    output_script    = false if config.match(   /^output_script\s*\:\s*(?:false|off|0)/i)
-    use_coderay      = true  if config.match(     /^use_coderay\s*\:\s*(?:true|on|1)/i)
-    before_line_num = Regexp.last_match(:num).to_i if config.match(/^before_line_num\s*\:\s*(?<num>\d+)/i)
-    after_line_num  = Regexp.last_match(:num).to_i if config.match( /^after_line_num\s*\:\s*(?<num>\d+)/i)
-    repl = Regexp.last_match(:repl).downcase if config.match(/^repl\s*\:\s*(?<repl>irb|pry)/i)
+config_file = File.exist?("./.eturem") ? "./.eturem" : File.join(Dir.home, ".eturem")
+if File.exist?(config_file)
+  config = File.read(config_file).gsub(/#.*/, "")
+  enable = false                    if config.match(/^enable\s*\:\s*(?:false|off|0)/i)
+  debug  = true                     if config.match(/^debug\s*\:\s*(?:true|on|1)/i)
+  lang   = Regexp.last_match(:lang) if config.match(/^lang\s*\:\s*(?<lang>\S+)/i)
+  output_backtrace = false if config.match(/^output_backtrace\s*\:\s*(?:false|off|0)/i)
+  output_original  = false if config.match( /^output_original\s*\:\s*(?:false|off|0)/i)
+  output_script    = false if config.match(   /^output_script\s*\:\s*(?:false|off|0)/i)
+  override_warning = false if config.match(/^override_warning\s*\:\s*(?:false|off|0)/i)
+  use_coderay      = true  if config.match(     /^use_coderay\s*\:\s*(?:true|on|1)/i)
+  before_line_num = Regexp.last_match(:num).to_i if config.match(/^before_line_num\s*\:\s*(?<num>\d+)/i)
+  after_line_num  = Regexp.last_match(:num).to_i if config.match( /^after_line_num\s*\:\s*(?<num>\d+)/i)
+  repl = Regexp.last_match(:repl).downcase if config.match(/^repl\s*\:\s*(?<repl>irb|pry)/i)
+end
+
+if enable
+  require "eturem/#{lang}/main" unless defined?(Eturem)
+  require "eturem/warning" if override_warning
+  Eturem::Base.output_backtrace = output_backtrace
+  Eturem::Base.output_original  = output_original
+  Eturem::Base.output_script    = output_script
+  Eturem::Base.use_coderay      = use_coderay
+  Eturem::Base.before_line_num  = before_line_num
+  Eturem::Base.after_line_num   = after_line_num
+
+  eturem_path = File.expand_path("..", __FILE__)
+  last_binding = nil
+  tracepoint = TracePoint.trace(:raise) do |tp|
+    last_binding = tp.binding unless File.expand_path(tp.path).start_with?(eturem_path)
   end
-  
-  if enable
-    require "eturem/#{lang}" unless defined?(Eturem)
-    Eturem.set_config(
-      output_backtrace: output_backtrace,
-      output_original:  output_original,
-      output_script:    output_script,
-      use_coderay:      use_coderay,
-      before_line_num:  before_line_num,
-      after_line_num:   after_line_num
-    )
-    
-    Eturem.load_and_output($PROGRAM_NAME, repl, debug)
-    exit
+  exception = Eturem.load(File.expand_path(Eturem.program_name))
+  tracepoint.disable
+
+  if exception.is_a?(Exception)
+    begin
+      Eturem.extend_exception(exception)
+      $stderr.write exception.eturem_full_message
+    rescue Exception => e
+      raise debug ? e : exception
+    end
+
+    repl ||= $eturem_repl if defined?($eturem_repl)
+    if repl && last_binding && exception.is_a?(StandardError)
+      require repl
+      last_binding.public_send(repl)
+    end
   end
+  exit
 end

data/lib/eturem/base.rb

@@ -1,309 +1,313 @@
 require "eturem/version"
 
 module Eturem
-  # load script and return eturem_exception if exception raised
-  # @param [String] file script file
-  # @return [Eturem::Base] if exception raised
-  # @return [nil] if exception did not raise
-  def self.load(file)
-    eturem = @eturem_class.new(file)
-    begin
-      Kernel.load(file)
-    rescue Exception => exception
-      raise exception if exception.is_a? SystemExit
-      eturem.exception = exception
-    end
-    eturem.exception ? eturem : nil
+  @program_name = $PROGRAM_NAME.encode("utf-8")
+
+  def self.rescue
+    yield
+  rescue Exception => exception
+    raise exception if exception.is_a? SystemExit
+    exception
   end
-  
-  def self.load_and_output(file, repl = nil, debug = false)
-    eturem = @eturem_class.new(file, true)
-    last_binding = nil
-    tp = TracePoint.trace(:raise) do |t|
-      last_binding = t.binding unless File.expand_path(t.path) == File.expand_path(__FILE__)
-    end
-    script = read_script(file)
-    begin
-      TOPLEVEL_BINDING.eval(script, file, 1)
-      tp.disable
-      eturem.comeback_stderr
-    rescue Exception => exception
-      tp.disable
-      eturem.comeback_stderr
-      raise exception if exception.is_a? SystemExit
-      repl ||= $eturem_repl
-      use_repl = repl && last_binding && exception.is_a?(StandardError)
-      begin
-        eturem.exception = exception
-        $stderr.write eturem.inspect
-      rescue Exception => e
-        raise debug ? e : eturem.exception
-      end
-      return unless use_repl
-      require repl
-      last_binding.public_send(repl)
+
+  # load script and return exception if exception raised
+  # @param [String] filename script file
+  # @return [Exception] if exception raised
+  # @return [true] if exception did not raise
+  def self.load(filename, wrap = false)
+    self.rescue do
+      Kernel.load(filename, wrap)
     end
   end
-  
+
   def self.eval(expr, bind = nil, fname = "(eval)", lineno = 1)
-    eturem = @eturem_class.new(fname)
-    begin
+    self.rescue do
       bind ? Kernel.eval(expr, bind, fname, lineno) : Kernel.eval(expr)
-    rescue Exception => exception
-      raise exception if exception.is_a? SystemExit
-      eturem.exception = exception
     end
-    return eturem.exception ? eturem : nil
   end
-  
-  def self.set_config(config)
-    @eturem_class.set_config(config)
+
+  def self.extend_exception(exception)
+    ext = _extend_exception(exception) ||
+          case exception
+          when SyntaxError   then SyntaxErrorExt
+          when NameError     then NameErrorExt
+          when ArgumentError then ArgumentErrorExt
+          else ExceptionExt
+          end
+    exception.extend ext
+    exception.eturem_prepare
   end
-  
-  def self.read_script(file)
-    script = nil
-    if File.exist?(file)
-      script = File.binread(file)
-      encoding = "utf-8"
-      if script.match(/\A(?:#!.*\R)?#.*coding *[:=] *(?<encoding>[^\s:]+)/)
-        encoding = Regexp.last_match(:encoding)
-      end
-      script.force_encoding(encoding)
-    end
-    return script
+
+  def self.program_name
+    @program_name
   end
-  
-  class Base
-    attr_reader :exception, :backtrace_locations, :path, :lineno, :label
-    
-    @@output_backtrace = true
-    @@output_original  = true
-    @@output_script    = true
-    @@use_coderay      = false
-    @@before_line_num  = 2
-    @@after_line_num   = 2
-    
-    @inspect_methods = {}
-    
-    def self.inspect_methods
-      return @inspect_methods
+
+
+  module Base
+    @@eturem_output_backtrace = true
+    @@eturem_output_original  = true
+    @@eturem_output_script    = true
+    @@eturem_use_coderay      = false
+    @@eturem_before_line_num  = 2
+    @@eturem_after_line_num   = 2
+
+    def self.output_backtrace=(value)
+      @@eturem_output_backtrace = value
     end
-    
-    def self.set_config(config)
-      @@output_backtrace = config[:output_backtrace] if config.has_key?(:output_backtrace)
-      @@output_original  = config[:output_original]  if config.has_key?(:output_original)
-      @@output_script    = config[:output_script]    if config.has_key?(:output_script)
-      @@use_coderay      = config[:use_coderay]      if config.has_key?(:use_coderay)
-      @@before_line_num  = config[:before_line_num]  if config.has_key?(:before_line_num)
-      @@after_line_num   = config[:after_line_num]   if config.has_key?(:after_line_num)
+
+    def self.output_original=(value)
+      @@eturem_output_original = value
     end
-    
-    def initialize(load_file, replace_stderr = false)
-      @load_file = load_file.encode("utf-8")
-      @scripts = {}
-      @decoration = {}
-      if replace_stderr
-        @stderr = $stderr
-        $stderr = self
-      end
+
+    def self.output_script=(value)
+      @@eturem_output_script = value
     end
-    
-    def exception=(exception)
-      @exception   = exception
-      @exception_s = exception.to_s
-      
-      eturem_path = File.dirname(File.expand_path(__FILE__))
-      @backtrace_locations = (@exception.backtrace_locations || []).reject do |location|
-        path = File.expand_path(location.path)
-        path.start_with?(eturem_path) || path.end_with?("/rubygems/core_ext/kernel_require.rb")
-      end
-      
-      if @exception.is_a?(SyntaxError) && @exception_s.match(/\A(?<path>.+?)\:(?<lineno>\d+)/)
-        @path   = Regexp.last_match(:path)
-        @lineno = Regexp.last_match(:lineno).to_i
-      else
-        backtrace_locations_shift
-      end
-      
-      @script_lines = read_script(@path) || []
-      @output_linenos = default_output_linenos
-      prepare
+
+    def self.use_coderay=(value)
+      @@eturem_use_coderay = value
     end
-    
-    def inspect
-      str = @@output_backtrace ? backtrace_inspect : ""
-      error_message = exception_inspect
-      if error_message.empty?
-        str << original_exception_inspect
-      else
-        str = "#{original_exception_inspect}\n#{str}" if @@output_original
-        str << "#{error_message}\n"
-      end
-      str << script_inspect if @@output_script
-      return str
+
+    def self.before_line_num=(value)
+      @@eturem_before_line_num = value
     end
-    
-    def backtrace_inspect
-      return "" if @backtrace_locations.empty?
-      
-      str = "#{traceback_most_recent_call_last}\n"
-      backtraces = []
-      size = @backtrace_locations.size
-      format = "%#{8 + size.to_s.length}d: %s\n"
-      @backtrace_locations.reverse.each_with_index do |location, i|
-        backtraces.push(sprintf(format, size - i, location_inspect(location)))
-      end
-      
-      if @exception_s == "stack level too deep"
-        str << backtraces[0..7].join
-        str << "         ... #{backtraces.size - 12} levels...\n"
-        str << backtraces[-4..-1].join
-      else
-        str << backtraces.join
-      end
-      return str
+
+    def self.after_line_num=(value)
+      @@eturem_after_line_num = value
     end
-    
-    def exception_inspect
-      inspect_methods = self.class.inspect_methods
-      inspect_methods.keys.reverse_each do |key|
-        if (key.is_a?(Class)  && @exception.is_a?(key)) || 
-           (key.is_a?(String) && @exception.class.to_s == key)
-          method = inspect_methods[key]
-          return method ? public_send(method) : ""
-        end
-      end
-      return ""
+
+    def self.highlight(str, pattern, highlight)
+      str.sub!(pattern) { "#{highlight}#{$1 || $&}\e[0m#{$2}" } if str
     end
-    
-    def original_exception_inspect
-      if @exception.is_a? SyntaxError
-        return "#{@exception_s.chomp}\n"
-      else
-        location_str = "#{@path}:#{@lineno}:in `#{@label}'"
-        @exception_s.match(/\A(?<first_line>.*)/)
-        return "#{location_str}: #{Regexp.last_match(:first_line)} (\e[4m#{@exception.class}\e[0m)" +
-               "#{Regexp.last_match.post_match.chomp}\n"
+
+    def self.unhighlight(str)
+      str.gsub(/\e\[[0-9;]*m/, "")
+    end
+
+    def self.read_script(filename)
+      return [] unless File.exist?(filename)
+      script = File.binread(filename)
+      encoding = "utf-8"
+      if script.match(/\A(?:#!.*\R)?#.*coding *[:=] *(?<encoding>[^\s:]+)/)
+        encoding = Regexp.last_match(:encoding)
       end
+      script.force_encoding(encoding).encode!("utf-8")
+      if @@eturem_use_coderay
+        require "coderay"
+        script = CodeRay.scan(script, :ruby).terminal
+      end
+      [""] + script.lines(chomp: true)
     end
-    
-    def script_inspect(path = @path, linenos = @output_linenos, lineno = @lineno, decoration = @decoration)
-      script_lines = read_script(path)
-      return "" unless script_lines
-      
+
+    def self.script(lines, linenos, lineno)
       str = ""
       max_lineno_length = linenos.max.to_s.length
-      last_i = linenos.min - 1
+      last_i = linenos.min.to_i - 1
       linenos.uniq.sort.each do |i|
-        line = script_lines[i]
-        line = highlight(line, decoration[i][0], decoration[i][1]) if decoration[i]
-        str << "\e[0m    #{' ' * max_lineno_length}  :\n" if last_i + 1 != i
-        str << (lineno == i ? "\e[0m => \e[1;34m" : "\e[0m    \e[1;34m")
-        str << sprintf("%#{max_lineno_length}d\e[0m: %s\n", i, line)
+        line = lines[i]
+        next unless line
+        str += "    #{' ' * max_lineno_length}  :\n" if last_i + 1 != i
+        str += (lineno == i ? " => " : "    ")
+        str += sprintf("\e[1;34m%#{max_lineno_length}d\e[0m: %s\e[0m\n", i, line)
         last_i = i
       end
-      return str
+      str
     end
-    
-    def write(*str)
-      message = nil
-      if str.join.force_encoding("utf-8").match(/^(.+?):(\d+):\s*warning:\s*/)
-        path, lineno, warning = $1, $2.to_i, $'.strip
-        message = warning_message(path, lineno, warning)
+
+
+    def eturem_prepare
+      this_filepath = File.expand_path(__FILE__)
+      @eturem_backtrace_locations = self.backtrace_locations || []
+      index = @eturem_backtrace_locations.index do |location|
+        File.expand_path(location.path) == this_filepath
+      end
+      @eturem_backtrace_locations = @eturem_backtrace_locations[0...index] if index
+
+      program_filepath = File.expand_path(Eturem.program_name)
+      @eturem_backtrace_locations.each do |location|
+        if File.expand_path(location.path) == program_filepath
+          def location.path; Eturem.program_name; end
+          if location.label == "<top (required)>"
+            def location.label; "<main>"; end
+          end
+        end
+      end
+
+      @eturem_message = self.message
+      unless @eturem_message.encoding == Encoding::UTF_8
+        @eturem_message.force_encoding("utf-8")
+        unless @eturem_message.valid_encoding?
+          @eturem_message.force_encoding(Encoding.locale_charmap).encode!("utf-8")
+        end
       end
-      if message
-        @stderr.write(message)
+
+      if self.is_a?(SyntaxError) && @eturem_message.match(/\A(?<path>.+?)\:(?<lineno>\d+):\s*/)
+        @eturem_path    = Regexp.last_match(:path)
+        @eturem_lineno  = Regexp.last_match(:lineno).to_i
+        @eturem_message = Regexp.last_match.post_match
+        @eturem_path = Eturem.program_name if @eturem_path == program_filepath
       else
-        @stderr.write(*str)
+        eturem_backtrace_locations_shift
       end
+
+      @eturem_script_lines = Eturem::Base.read_script(@eturem_path)
+      @eturem_output_linenos = eturem_default_output_linenos
     end
-    
-    def comeback_stderr
-      $stderr = @stderr || STDERR
+
+    def eturem_original_error_message()
+      @eturem_message.match(/\A(?<first_line>.*)/)
+      "#{@eturem_path}:#{@eturem_lineno}:in `#{@eturem_label}': " +
+      "\e[1m#{Regexp.last_match(:first_line)} (\e[4m#{self.class}\e[0;1m)" +
+      "#{Regexp.last_match.post_match.chomp}\e[0m\n"
     end
-    
-    def to_s
-      @exception_s
+
+    def eturem_backtrace_str(order = :bottom)
+      str = @eturem_backtrace_locations.empty? ? "" : eturem_traceback(order)
+      str + (order == :top ? eturem_backtrace_str_top : eturem_backtrace_str_bottom)
     end
-    
-    private
-    
-    def prepare
-      case @exception
-      when NameError     then prepare_name_error
-      when ArgumentError then prepare_argument_error
+
+    def eturem_backtrace
+      eturem_backtrace_locations.map do |location|
+        eturem_location_to_s(location)
       end
     end
-    
-    def prepare_name_error
-      return unless @exception_s.match(/Did you mean\?/)
-      @did_you_mean = Regexp.last_match.post_match.strip.scan(/\S+/)
-      @decoration[@lineno] = [@exception.name.to_s, "\e[1;31m\e[4m"]
-      
-      @did_you_mean.each do |name|
-        index = @script_lines.index { |line| line.include?(name) }
-        next unless index
-        @decoration[index] = [name, "\e[1;33m"]
-        @output_linenos.push(index)
-      end
+
+    def eturem_location_to_s(location)
+      "#{location.path}:#{location.lineno}:in `#{location.label}'"
     end
-    
-    def prepare_argument_error
-      @method = @label
-      backtrace_locations_shift
-      @script_lines = read_script(@path)
-      @output_linenos = default_output_linenos
+
+    def eturem_backtrace_locations
+      @eturem_backtrace_locations
     end
-    
-    def backtrace_locations_shift
-      @label  = @backtrace_locations.first.label
-      @path   = @backtrace_locations.first.path
-      @lineno = @backtrace_locations.first.lineno
-      @backtrace_locations.shift
+
+    def eturem_message
+      ""
+    end
+
+    def eturem_script
+      Eturem::Base.script(@eturem_script_lines, @eturem_output_linenos, @eturem_lineno)
     end
-    
-    def traceback_most_recent_call_last
-      "Traceback (most recent call last):"
+
+    def eturem_full_message(highlight: true, order: :bottom)
+      unless $stderr == STDERR && $stderr.tty?
+        highlight = false
+        order = :top
+      end
+
+      str = @@eturem_output_backtrace ? eturem_backtrace_str(order) : ""
+      ext_message = eturem_message
+      if ext_message.empty?
+        str += eturem_original_error_message
+      else
+        str = "#{eturem_original_error_message}\n#{str}" if @@eturem_output_original
+        str += "#{ext_message}\n"
+      end
+      str += eturem_script if @@eturem_output_script
+
+      highlight ? str : Eturem::Base.unhighlight(str)
     end
-    
-    def location_inspect(location)
-      "from #{location.path}:#{location.lineno}:in `#{location.label}'"
+
+    private
+
+    def eturem_backtrace_locations_shift
+      location = @eturem_backtrace_locations.shift
+      @eturem_label  = location.label
+      @eturem_path   = location.path
+      @eturem_lineno = location.lineno
     end
-    
-    def default_output_linenos
-      from = [1, @lineno - @@before_line_num].max
-      to   = [@script_lines.size - 1, @lineno + @@after_line_num].min
+
+    def eturem_default_output_linenos
+      from = [1, @eturem_lineno - @@eturem_before_line_num].max
+      to   = [@eturem_script_lines.size - 1, @eturem_lineno + @@eturem_after_line_num].min
       (from..to).to_a
     end
-    
-    def highlight(str, keyword, color)
-      str.to_s.gsub(keyword){ "#{color}#{$&}\e[0m" }
+
+    def eturem_traceback(order = :bottom)
+      order == :top ? "" : "\e[1mTraceback\e[0m (most recent call last):\n"
     end
-    
-    def warning_message(file, line, warning)
-      case warning
-      when "found `= literal' in conditional, should be =="
-        "#{file}:#{line}: warning: #{warning}\n" +
-        script_inspect(file, [line], line, { line => [/(?<![><!=])=(?!=)/, "\e[1;31m\e[4m"] })
-      else
-        nil
+
+    def eturem_backtrace_str_bottom
+      lines = []
+      backtrace = eturem_backtrace
+      size = backtrace.size
+      format = "%#{8 + size.to_s.length}d: %s\n"
+      backtrace.reverse.each_with_index do |bt, i|
+        lines.push(sprintf(format, size - i, bt))
       end
+
+      if @eturem_message == "stack level too deep"
+        lines = lines[-4..-1] +
+                ["         ... #{lines.size - 12} levels...\n"] +
+                lines[0..7]
+      end
+      lines.join
     end
-    
-    def read_script(file)
-      unless @scripts[file]
-        script = Eturem.read_script(file)
-        return nil unless script
-        script.encode!("utf-8")
-        if @@use_coderay
-          require "coderay" 
-          script = CodeRay.scan(script, :ruby).terminal
-        end
-        @scripts[file] = [""] + script.lines(chomp: true)
+
+    def eturem_backtrace_str_top
+      lines = eturem_backtrace.map do |bt|
+        "        from #{bt}\n"
       end
-      return @scripts[file]
+      if @eturem_message == "stack level too deep"
+        lines = lines[0..7] +
+                ["         ... #{lines.size - 12} levels...\n"] +
+                lines[-4..-1]
+      end
+      lines.join
     end
   end
+
+
+  module ExceptionExt
+    include Base
+  end
+
+
+  module NameErrorExt
+    include ExceptionExt
+
+    def eturem_prepare()
+      @eturem_corrections = self.respond_to?(:corrections) ? self.corrections : []
+      @eturem_corrections += Object.constants.select do |const|
+        const.casecmp?(self.name)
+      end
+      @eturem_corrections.uniq!
+      def self.corrections; @eturem_corrections; end
+      super
+      uname = self.name.to_s.encode("utf-8")
+      if @eturem_script_lines[@eturem_lineno]
+        Eturem::Base.highlight(@eturem_script_lines[@eturem_lineno], uname, "\e[1;4;31m")
+      end
+      @eturem_corrections.each do |name|
+        index = @eturem_script_lines.index { |line| line.include?(name.to_s.encode("utf-8")) }
+        next unless index
+        Eturem::Base.highlight(@eturem_script_lines[index], name.to_s.encode("utf-8"), "\e[1;33m")
+        @eturem_output_linenos.push(index)
+      end
+    end
+  end
+
+
+  module ArgumentErrorExt
+    include ExceptionExt
+
+    def eturem_prepare()
+      super
+      @eturem_method = @eturem_label
+      eturem_backtrace_locations_shift
+      @eturem_script_lines = Eturem::Base.read_script(@eturem_path)
+      @eturem_output_linenos = eturem_default_output_linenos
+    end
+  end
+
+
+  module SyntaxErrorExt
+    include ExceptionExt
   
-  @eturem_class = Base
+    def eturem_original_error_message()
+      ret = "#{@eturem_path}:#{@eturem_lineno}: #{@eturem_message}"
+      unless @eturem_path == Eturem.program_name
+        ret = "\e[1m#{ret} (\e[4m#{self.class}\e[0;1m)\e[0m"
+      end
+      ret + "\n"
+    end
+  end
 end