eturem 0.3.2 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cafde349114833d7d2ec857ff349c9b90be5d1ec
-  data.tar.gz: d80d846f4b2e628dab97a0e81cec9f64d3a162f9
+SHA256:
+  metadata.gz: 02f58a271e2dc5649f9a44f03c338609d7484a21c117765f015b37b2fa987a0e
+  data.tar.gz: f64968cfff79d69874addbe967624ee89b3c064d5039f6b97878037f52c38337
 SHA512:
-  metadata.gz: e7614e84b0e772b45d733c2fa25587855c314c7b10bdaf5052a4647ab2a666da4c08b233dfafb921ca7f8a3bcfd47833232a9488146d14221d242adf7d81b884
-  data.tar.gz: 2c6cc910538e61fb935788b9f47390129f7d1896caeebb170bd14dde8c986232b04eaa1d91d2c190deb3a7f42d941a9d47bbf4b7afbc24e872d1bee0953c7131
+  metadata.gz: 6c4caaf3140eff2837ed1aa13517a6955d4a7039fc2266d46420c14738d7eae20ce418cb470b1fdaabdad3f4f17c4a454fb4bcab1483223a7ea4c0af1eee4fc6
+  data.tar.gz: f3b5c7db9d90865be0705b7193d1fd7dd9feeb103c2eba394342486eef6e9a08ce460bae42d9e4bea07b385a82b6f9974c91fc7b788b8aa84e8477b786fb5c39

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``` を追加しておいてあげましょう。
 
 ## 使用するとどうなるか
@@ -41,7 +45,7 @@ example1.rb:5: syntax error, unexpected end-of-input, expecting keyword_end
 Eturem を使用すると、次のようなエラー表示になります。
 
 ```
-ファイル"example1.rb" 5行目でエラーが発生しました。
+【エラー】ファイル"example1.rb" 5行目：
 （ただし、実際のエラーの原因はおそらくもっと前にあります。）
 構文エラーです。endが足りません。「if」に対応する「end」があるか確認してください。
     3:     puts "なんたらかんたら"
@@ -74,7 +78,7 @@ did_you_mean のおかげで昔より格段にわかりやすくなったとは
 Eturem を使用すると、次のようなエラー表示になります。（実際には色付き）
 
 ```
-ファイル"example2.rb" 5行目でエラーが発生しました。
+【エラー】ファイル"example2.rb" 5行目：
 変数/メソッド「player_life」は存在しません。「prayer_life」の入力ミスではありませんか？
     1: prayer_life = 100
        :
@@ -110,7 +114,7 @@ example3.rb:1:in `foo': wrong number of arguments (given 1, expected 2) (Argumen
 Eturem を使用すると、次のようなエラー表示になります。
 
 ```
-ファイル"example3.rb" 4行目でエラーが発生しました。
+【エラー】ファイル"example3.rb" 4行目：
 引数の数が正しくありません。「foo」は本来2個の引数を取りますが、1個の引数が渡されています。
     2: end
     3: # 中略
@@ -119,6 +123,91 @@ Eturem を使用すると、次のようなエラー表示になります。
 
 このように、呼び出し行をエラー発生行として表示してくれます。
 
+### 例４：warning
+
+0.4.0 から、warning に対してもサポートができるようになりました。
+
+```
+【警告】ファイル"example4.rb" 2行目：
+条件式部分で「 = 」が使われています。「 == 」の間違いではありませんか？
+ => 2: puts "a" if a = 1
+```
+
+現状あまり多くの種類の警告に対応できてはいませんが、上記のように日本語での警告に加えて該当行を表示することができます。
+
+### 例５：エラー発生時に自動で binding.irb
+
+変数の値が不適切だったためにエラーが起きた可能性がある場合、エラーが起きた瞬間の変数の値を調べる必要があります。そうした際には「エラー発生箇所の直前に binding.irb を入れて調べる」という手がありますが、そうするとたまにしか起きないエラーの場合何度も binding.irb が動いてしまって面倒です。
+
+そこで、後述する設定ファイル .eturem で設定するか、あるいはプログラム中に `$eturem_repl = "irb"` と入れておくことで、エラー発生時に自動的に binding.irb することができます。
+
+なお、この機能だけを切り出した 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」というファイルを用意すると、詳細設定ができます。（下の例の設定が、各項目を省略した際に使用される初期値です。）
+
+```
+enable: true
+debug: false
+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
+```
+
+- enable: eturem の使用/不使用を切り替えます。
+- 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 します。
+
+## 簡単な仕組み
+
+```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/Rakefile

@@ -5,6 +5,7 @@ Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
+  t.warning = false
 end
 
 task :default => :test

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

@@ -1,39 +1,79 @@
 enable = true
+debug  = false
 lang   = "en"
 output_backtrace = true
 output_original  = true
 output_script    = true
+override_warning = true
 use_coderay      = false
-max_backtrace    = 16
 before_line_num  = 2
 after_line_num   = 2
+repl             = nil
 
-config_file = File.join(Dir.home, ".eturem")
+config_file = File.exist?("./.eturem") ? "./.eturem" : File.join(Dir.home, ".eturem")
 if File.exist?(config_file)
-  config = File.read(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)
-  use_coderay      = true           if config.match(     /^use_coderay\s*\:\s*(?:true|on|1)/i)
-  max_backtrace   = Regexp.last_match(:num).to_i if config.match(  /^max_backtrace\s*\:\s*(?<num>\d+)/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
-require "eturem/#{lang}" if enable && !defined?(Eturem)
 
-if defined? Eturem
-  Eturem.eturem_class.output_backtrace = output_backtrace
-  Eturem.eturem_class.output_original  = output_original
-  Eturem.eturem_class.output_script    = output_script
-  Eturem.eturem_class.use_coderay      = use_coderay
-  Eturem.eturem_class.max_backtrace    = max_backtrace
-  Eturem.eturem_class.before_line_num  = before_line_num
-  Eturem.eturem_class.after_line_num   = after_line_num
-  
-  require "coderay" if use_coderay
-  exception = Eturem.load($0)
-  exception.output if exception
+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
+
+  if File.exist?($PROGRAM_NAME)
+    program_file = File.open($PROGRAM_NAME, "rb")
+    script = program_file.read
+    if script.match(/^__END__\R/)
+      program_file.pos = Regexp.last_match.end(0)
+      encoding = "utf-8"
+      if script.match(/\A(?:#!.*\R)?#.*coding *[:=] *(?<encoding>[^\s:]+)/)
+        encoding = Regexp.last_match(:encoding)
+      end
+      program_file.set_encoding(encoding)
+      Object.const_set(:DATA, program_file)
+      program_file
+    else
+      program_file.close
+    end
+  end
+
+  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
+  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,280 +1,312 @@
 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)
-    begin
-      Kernel.load(File.expand_path(file))
-    rescue Exception => exception
-      return @eturem_class.new(exception) unless exception.is_a? SystemExit
+  @program_name = $PROGRAM_NAME.encode("utf-8")
+
+  def self.rescue
+    yield
+  rescue Exception => exception
+    raise exception if exception.is_a? SystemExit
+    exception
+  end
+
+  # 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
-    return nil
   end
-  
+
   def self.eval(expr, bind = nil, fname = "(eval)", lineno = 1)
-    begin
+    self.rescue do
       bind ? Kernel.eval(expr, bind, fname, lineno) : Kernel.eval(expr)
-    rescue Exception => exception
-      return @eturem_class.new(exception) unless exception.is_a? SystemExit
     end
-    return nil
   end
-  
-  def self.eturem_class
-    @eturem_class
+
+  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.eturem_class=(klass)
-    @eturem_class = klass
+
+  def self.program_name
+    @program_name
   end
-  
-  class Base
-    attr_reader :exception
-    
-    @@output_backtrace = true
-    @@output_original  = true
-    @@output_script    = true
-    @@use_coderay      = false
-    @@max_backtrace    = 16
-    @@before_line_num  = 2
-    @@after_line_num   = 2
-    
-    @inspect_methods = {}
-    
-    def self.inspect_methods
-      return @inspect_methods
-    end
-    
+
+
+  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)
-      @@output_backtrace = value
+      @@eturem_output_backtrace = value
     end
-    
+
     def self.output_original=(value)
-      @@output_original = value
+      @@eturem_output_original = value
     end
-    
+
     def self.output_script=(value)
-      @@output_script = value
+      @@eturem_output_script = value
     end
-    
+
     def self.use_coderay=(value)
-      @@use_coderay = value
-    end
-    
-    def self.max_backtrace=(value)
-      @@max_backtrace = value
+      @@eturem_use_coderay = value
     end
-    
+
     def self.before_line_num=(value)
-      @@before_line_num = value
+      @@eturem_before_line_num = value
     end
-    
+
     def self.after_line_num=(value)
-      @@after_line_num = value
+      @@eturem_after_line_num = value
     end
-    
-    def initialize(exception)
-      @exception   = exception
-      @exception_s = exception.to_s
-      
-      eturem_path = File.dirname(File.absolute_path(__FILE__))
-      @backtrace_locations = (@exception.backtrace_locations || []).reject do |location|
-        path = File.absolute_path(location.path)
-        path.start_with?(eturem_path) || path.end_with?("/rubygems/core_ext/kernel_require.rb")
-      end
-      @backtrace_locations.each do |location|
-        if $0 == location.path
-          def location.label
-            super.sub("<top (required)>", "<main>")
-          end
-        end
+
+    def self.highlight(str, pattern, highlight)
+      str.sub!(pattern) { "#{highlight}#{$1 || $&}\e[0m#{$2}" } if str
+    end
+
+    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
-      
-      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
+      script.force_encoding(encoding).encode!("utf-8")
+      if @@eturem_use_coderay
+        require "coderay"
+        script = CodeRay.scan(script, :ruby).terminal
       end
-      
-      load_script
-      prepare
+      [""] + script.lines(chomp: true)
     end
-    
-    # output backtrace + error message + script
-    def output
-      output_backtrace if @@output_backtrace
-      error_message = exception_inspect
-      if error_message.to_s.empty?
-        puts original_exception_inspect
-      else
-        puts original_exception_inspect if @@output_original
-        puts error_message
+
+    def self.script(lines, linenos, lineno)
+      str = ""
+      max_lineno_length = linenos.max.to_s.length
+      last_i = linenos.min.to_i - 1
+      linenos.uniq.sort.each do |i|
+        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
-      output_script if @@output_script
+      str
     end
-    
-    def output_backtrace
-      return if @backtrace_locations.empty?
-      
-      puts traceback_most_recent_call_last
-      @backtrace_locations[0, @@max_backtrace].reverse.each_with_index do |location, i|
-        puts sprintf("%9d: %s", @backtrace_locations.size - i, location_inspect(location))
+
+
+    def eturem_prepare
+      this_dirpath = File.dirname(File.expand_path(__FILE__))
+      @eturem_backtrace_locations = (self.backtrace_locations || []).reject do |location|
+        File.expand_path(location.path).start_with?(this_dirpath) ||
+        location.path.end_with?("/rubygems/core_ext/kernel_require.rb")
       end
-    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) : nil
+
+      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
-      return nil
-    end
-    
-    def original_exception_inspect
-      if @exception.is_a? SyntaxError
-        return @exception_s
-      else
-        location_str = "#{@path}:#{@lineno}:in `#{@label}'"
-        if @exception_s.match(/\A(?<first_line>.*?)\n/)
-          return "#{location_str}: #{Regexp.last_match(:first_line)} (#{@exception.class})\n" +
-            "#{Regexp.last_match.post_match}"
-        else
-          return "#{location_str}: #{@exception_s} (#{@exception.class})"
+
+      @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
-    end
-    
-    def output_script
-      return if @script.empty?
-      
-      max_lineno_length = @output_lines.compact.max.to_s.length
-      @output_lines.each do |i|
-        if @lineno == i
-          puts sprintf("\e[0m => \e[1;34m%#{max_lineno_length}d\e[0m: %s", i, @script_lines[i])
-        elsif i
-          puts sprintf("\e[0m    \e[1;34m%#{max_lineno_length}d\e[0m: %s", i, @script_lines[i])
-        else
-          puts         "\e[0m    #{" " * max_lineno_length}  :"
-        end
+
+      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
+        eturem_backtrace_locations_shift
       end
+
+      @eturem_script_lines = Eturem::Base.read_script(@eturem_path)
+      @eturem_output_linenos = eturem_default_output_linenos
     end
-    
-    private
-    
-    def prepare
-      case @exception
-      when SyntaxError   then prepare_syntax_error
-      when NameError     then prepare_name_error
-      when ArgumentError then prepare_argument_error
-      when TypeError     then prepare_type_error
-      end
+
+    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 prepare_syntax_error
-      @unexpected = @exception_s.match(/unexpected (?<unexpected>(?:','|[^,])+)/) ?
-        Regexp.last_match(:unexpected) : nil
-      @expected   = @exception_s.match(/[,\s]expecting (?<expected>\S+)/) ?
-        Regexp.last_match(:expected)   : nil
-      if !@expected && @exception_s.match(/(?<invalid>(?:break|next|retry|redo|yield))/)
-        @invalid = Regexp.last_match(:invalid)
-      end
+
+    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
-    
-    def prepare_name_error
-      highlight!(@script_lines[@lineno], @exception.name.to_s, "\e[1;31m\e[4m")
-      return unless @exception_s.match(/Did you mean\?/)
-      @did_you_mean = Regexp.last_match.post_match.strip.scan(/\S+/)
-      return if @script.empty?
-      
-      new_range = []
-      @did_you_mean.each do |name|
-        index = @script_lines.index { |line| line.include?(name) }
-        next unless index
-        highlight!(@script_lines[index], name, "\e[1;33m")
-        new_range.push(index)
-      end
-      new_range.sort!
-      before = new_range.select { |i| i < @output_lines.first }
-      after  = new_range.select { |i| i > @output_lines.last  }
-      unless before.empty?
-        @output_lines.unshift(nil) if before.last + 1 != @output_lines.first
-        @output_lines.unshift(*before)
-      end
-      unless after.empty?
-        @output_lines.push(nil) if @output_lines.last + 1 != after.first
-        @output_lines.push(*after)
+
+    def eturem_backtrace
+      eturem_backtrace_locations.map do |location|
+        eturem_location_to_s(location)
       end
     end
-    
-    def prepare_argument_error
-      @method = @label
-      old_path = @path
-      backtrace_locations_shift
-      load_script unless old_path == @path
-      @output_lines = default_output_lines
-      if @exception_s.match(/given (?<given>\d+)\, expected (?<expected>[^)]+)/)
-        @given    = Regexp.last_match(:given).to_i
-        @expected = Regexp.last_match(:expected)
+
+    def eturem_location_to_s(location)
+      "#{location.path}:#{location.lineno}:in `#{location.label}'"
+    end
+
+    def eturem_backtrace_locations
+      @eturem_backtrace_locations
+    end
+
+    def eturem_message
+      ""
+    end
+
+    def eturem_script
+      Eturem::Base.script(@eturem_script_lines, @eturem_output_linenos, @eturem_lineno)
+    end
+
+    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 prepare_type_error
-      @method = @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 backtrace_locations_shift
-      @label  = @backtrace_locations.first.label
-      @path   = @backtrace_locations.first.path
-      @lineno = @backtrace_locations.first.lineno
-      @backtrace_locations.shift
+
+    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 traceback_most_recent_call_last
-      "Traceback (most recent call last):"
+
+    def eturem_traceback(order = :bottom)
+      order == :top ? "" : "\e[1mTraceback\e[0m (most recent call last):\n"
     end
-    
-    def location_inspect(location)
-      "from #{location.path}:#{location.lineno}:in `#{location.label}'"
+
+    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 load_script
-      @script ||= ""
-      if @path && File.exist?(@path)
-        @script = File.binread(@path)
-        encoding = "utf-8"
-        if @script.match(/\A(?:#!.*\R)?#.*coding *[:=] *(?<encoding>[^\s:]+)/)
-          encoding = Regexp.last_match(:encoding)
-        end
-        @script.force_encoding(encoding)
+
+    def eturem_backtrace_str_top
+      lines = eturem_backtrace.map do |bt|
+        "        from #{bt}\n"
+      end
+      if @eturem_message == "stack level too deep"
+        lines = lines[0..7] +
+                ["         ... #{lines.size - 12} levels...\n"] +
+                lines[-4..-1]
       end
-      @script = CodeRay.scan(@script, :ruby).terminal if @@use_coderay
-      @script_lines = @script.lines
-      @script_lines.unshift("")
-      @output_lines = default_output_lines
+      lines.join
     end
-    
-    def highlight(str, keyword, color)
-      str.to_s.gsub(keyword){ color + ($1 || $&) + "\e[0m" }
+  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.map(&:to_s).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
-    
-    def highlight!(str, keyword, color)
-      str.gsub!(keyword){ color + ($1 || $&) + "\e[0m" } if str
+  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
-    
-    def default_output_lines
-      from = [1, @lineno - @@before_line_num].max
-      to   = [@script_lines.size - 1, @lineno + @@after_line_num].min
-      (from..to).to_a
+  end
+
+
+  module SyntaxErrorExt
+    include ExceptionExt
+  
+    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
-    
-    Eturem.eturem_class = self
   end
 end