ruby-japanize 0.1.0 → 0.2.0

data/lib/japanize/base.rb

@@ -22,7 +22,11 @@ require 'japanize/core'
   別名 :自動配置か?,                      :autoload?
   # 別名 :部で評価,                       :module_eval       # japanize/coreで定義済み
   # 別名 :組で評価,                       :class_eval        # japanize/coreで定義済み
+  別名 :部で実行,                         :module_exec
+  別名 :組で実行,                         :class_exec
   別名 :組の変数は定義済みか?,            :class_variable_defined?
+  別名 :組の変数を取得,                   :class_variable_get
+  別名 :組の変数を設定,                   :class_variable_set
   別名 :組の変数の一覧,                   :class_variables
   # 別名 :定数は定義済みか?,              :const_defined?    # japanize/coreで定義済み
   # 別名 :定数を取得,                     :const_get         # japanize/coreで定義済み
@@ -31,7 +35,7 @@ require 'japanize/core'
   # 別名 :定数を設定,                     :const_set         # japanize/coreで定義済み
   別名 :定数の一覧,                       :constants
   # 別名 :定義,                           :define_method     # japanize/coreで定義済み
-  別名 :凍結する,                         :freeze
+  別名 :定数を非推奨にする,               :deprecate_constant
   別名 :付加,                             :include
   別名 :付加済みか?,                      :include?
   別名 :含まれる部の一覧,                 :included_modules
@@ -41,24 +45,22 @@ require 'japanize/core'
   別名 :操作は定義済みか?,                :method_defined?
   別名 :付与,                             :prepend
   別名 :組が持つ操作を秘密にする,         :private_class_method
+  別名 :秘密の定数,                       :private_constant
   別名 :生成物が持つ秘密の操作の一覧,     :private_instance_methods
   別名 :秘密の操作は定義済みか?,          :private_method_defined?
   別名 :生成物が持つ保護された操作の一覧, :protected_instance_methods
   別名 :保護された操作は定義済みか?,      :protected_method_defined?
   別名 :組が持つ操作を公開する,           :public_class_method
+  別名 :公開された定数,                   :public_constant
   別名 :生成物が持つ公開された操作を取得, :public_instance_method
   別名 :生成物が持つ公開された操作の一覧, :public_instance_methods
   別名 :公開された操作は定義済みか?,      :public_method_defined?
   別名 :組の変数を除去する,               :remove_class_variable
   別名 :操作を除去する,                   :remove_method
+  別名 :特異組か?,                        :singleton_class?
   別名 :操作を未定義にする,               :undef_method
 
   別名 :機能を付加する,         :append_features
-  別名 :部で実行,               :module_exec
-  別名 :組で実行,               :class_exec
-  別名 :組の変数を取得,         :class_variable_get
-  別名 :組の変数を設定,         :class_variable_set
-  別名 :定数を非推奨にする,     :deprecate_constant
   別名 :物を拡張する,           :extend_object
   別名 :拡張した時,             :extended
   定義(:extended) {|物| 拡張した時(物) }
@@ -75,21 +77,13 @@ require 'japanize/core'
   別名 :付与された時,           :prepended
   定義(:prepended) {|組または部| 付与された時(組または部) }
   # 別名 :秘密,                 :private            # japanize/coreで定義済み
-  別名 :秘密の定数,             :private_constant
   別名 :保護,                   :protected
   別名 :公開,                   :public
-  別名 :公開された定数,         :public_constant
   別名 :限定拡張,               :refine
   別名 :定数を除去する,         :remove_const
-  別名 :特異組か?,              :singleton_class?
   別名 :限定拡張を使用,         :using
 
   秘密 :機能を付加する,
-       :部で実行,
-       :組で実行,
-       :組の変数を取得,
-       :組の変数を設定,
-       :定数を非推奨にする,
        :物を拡張する,
        :拡張した時, :extended,
        :付加された時, :included,
@@ -98,13 +92,10 @@ require 'japanize/core'
        :操作が未定義にされた時, :method_undefined,
        :機能を付与する,
        :付与された時, :prepended,
-       :秘密の定数,
        :保護,
        :公開,
-       :公開された定数,
        :限定拡張,
        :定数を除去する,
-       :特異組か?,
        :限定拡張を使用
 
   定義(:日本語の定数を移譲) {|移譲先の部, 名前, *名前の一覧, 上書き: 偽値|
@@ -165,7 +156,11 @@ require 'japanize/core'
   }
 
   別名 :生成, :allocate
-  定義(:新規) {|*引数, &塊| new(*引数, &塊) } # 個別の組でnewを再定義するかもしれないので別名にしない
+  if (_バージョンが2_7以上か?) then
+    定義(:新規) {|*引数, **名前付き引数, &塊| new(*引数, **名前付き引数, &塊) } # 個別の組でnewを再定義するかもしれないので別名にしない
+  else
+    定義(:新規) {|*引数,                 &塊| new(*引数,                 &塊) } # 個別の組でnewを再定義するかもしれないので別名にしない
+  end
   別名 :原型, :superclass
 
   別名 :継承された時, :inherited
@@ -181,8 +176,17 @@ require 'japanize/core'
   別名 :生成物で評価, :instance_eval
   別名 :生成物で実行, :instance_exec
 
+  別名 :初期化,                     :initialize
   別名 :不明な操作,                 :method_missing
-  定義(:method_missing) {|名前, *引数, &塊| 不明な操作(名前, *引数, &塊) }
+  if (::JA::日本語化._バージョンが2_7以上か?) then
+    定義(:method_missing) {|名前, *引数, **名前付き引数, &塊|
+      不明な操作(名前, *引数, **名前付き引数, &塊)
+    }
+  else
+    定義(:method_missing) {|名前, *引数, &塊|
+      不明な操作(名前, *引数, &塊)
+    }
+  end
   別名 :特異操作が追加された時,     :singleton_method_added
   定義(:singleton_method_added) {|名前| 特異操作が追加された時(名前) }
   別名 :特異操作が除去された時,     :singleton_method_removed
@@ -190,27 +194,28 @@ require 'japanize/core'
   別名 :特異操作が未定義にされた時, :singleton_method_undefined
   定義(:singleton_method_undefined) {|名前| 特異操作が未定義にされた時(名前) }
 
-  秘密 :不明な操作, :method_missing,
+  秘密 :初期化,
+       :不明な操作, :method_missing,
        :特異操作が追加された時, :singleton_method_added,
        :特異操作が除去された時, :singleton_method_removed,
        :特異操作が未定義にされた時, :singleton_method_undefined
 }
 
-組(物) {
+# 物の操作は実際は核で定義されている
+部(核) {
   別名 :送信,                      :send
   別名 :生成元,                    :class
-  定義(:複写) {|*引数, &塊| clone(*引数, &塊) }                # cloneを継承先で再定義するかもしれないので別名にしない
-  定義(:複製) {|*引数, &塊| dup(*引数, &塊) }                  # dupを継承先で再定義するかもしれないので別名にしない
+  # 別名 :複写,                    :clone                # cloneを継承先で再定義するかもしれないので別名にしない
+  # 別名 :複製,                    :dup                  # dupを継承先で再定義するかもしれないので別名にしない
   別名 :特異操作の定義,            :define_singleton_method
   別名 :表示する,                  :display
   別名 :列挙に変換,                :to_enum
   別名 :列挙する,                  :enum_for
-  定義(:等しいか?) {|他の物| eql?(他の物) }                    # eql?を継承先で再定義するかもしれないので別名にしない
+  # 別名 :等しいか?,               :eql?                 # eql?を継承先で再定義するかもしれないので別名にしない
   別名 :拡張,                      :extend
-  別名 :凍結する,                  :freeze
   別名 :凍結済みか?,               :frozen?
-  定義(:ハッシュ値) { hash }                                   # hashを継承先で再定義するかもしれないので別名にしない
-  定義(:検査) {|*引数, &塊| inspect(*引数, &塊) }              # inspectを継承先で再定義するかもしれないので別名にしない
+  # 別名 :ハッシュ値,              :hash                 # hashを継承先で再定義するかもしれないので別名にしない
+  # 別名 :検査,                    :inspect              # inspectを継承先で再定義するかもしれないので別名にしない
   別名 :生成物か?,                 :instance_of?
   別名 :生成物の変数は定義済みか?, :instance_variable_defined?
   別名 :生成物の変数を取得,        :instance_variable_get
@@ -229,7 +234,7 @@ require 'japanize/core'
   別名 :公開された範囲で送信,      :public_send
   別名 :生成物の変数を除去する,    :remove_instance_variable
   別名 :応答するか?,               :respond_to?
-  # 別名 :特異組,                  :singleton_class            # japanize/coreで定義済み
+  # 別名 :特異組,                  :singleton_class      # japanize/coreで定義済み
   別名 :特異操作を取得,            :singleton_method
   別名 :特異操作の一覧,            :singleton_methods
   別名 :汚染させる,                :taint
@@ -237,26 +242,45 @@ require 'japanize/core'
   別名 :蛇口,                      :tap
   別名 :それから,                  :then
   別名 :自分を委ねる,              :yield_self
-  定義(:文字列に変換) {|*引数, &塊| to_s(*引数, &塊) }         # to_sを継承先で再定義するかもしれないので別名にしない
+  # 別名 :文字列に変換,              :to_s               # to_sを継承先で再定義するかもしれないので別名にしない
   別名 :汚染を除去する,            :untaint
 
-  別名 :初期化,        :initialize
   別名 :不明な応答か?, :respond_to_missing?
 
-  秘密 :初期化,
-       :不明な応答か?
+  秘密 :不明な応答か?
+}
+
+組(物) {
+  定義(:等しいか?) {|他の物| eql?(他の物) }                                                    # eql?を継承先で再定義するかもしれないので別名にしない
+  定義(:凍結する) { freeze }                                                                   # freezeを継承先で再定義するかもしれないので別名にしない
+  定義(:ハッシュ値) { hash }                                                                   # hashを継承先で再定義するかもしれないので別名にしない
+  if (_バージョンが2_7以上か?) then
+    定義(:複写)         {|*引数, **名前付き引数, &塊|   clone(*引数, **名前付き引数, &塊) }    # cloneを継承先で再定義するかもしれないので別名にしない
+    定義(:複製)         {|*引数, **名前付き引数, &塊|     dup(*引数, **名前付き引数, &塊) }    # dupを継承先で再定義するかもしれないので別名にしない
+    定義(:検査)         {|*引数, **名前付き引数, &塊| inspect(*引数, **名前付き引数, &塊) }    # inspectを継承先で再定義するかもしれないので別名にしない
+    定義(:文字列に変換) {|*引数, **名前付き引数, &塊|    to_s(*引数, **名前付き引数, &塊) }    # to_sを継承先で再定義するかもしれないので別名にしない
+  else
+    定義(:複写)         {|*引数,                 &塊|   clone(*引数,                 &塊) }    # cloneを継承先で再定義するかもしれないので別名にしない
+    定義(:複製)         {|*引数,                 &塊|     dup(*引数,                 &塊) }    # dupを継承先で再定義するかもしれないので別名にしない
+    定義(:検査)         {|*引数,                 &塊| inspect(*引数,                 &塊) }    # inspectを継承先で再定義するかもしれないので別名にしない
+    定義(:文字列に変換) {|*引数,                 &塊|    to_s(*引数,                 &塊) }    # to_sを継承先で再定義するかもしれないので別名にしない
+  end
 }
 
 部(日本語化) {
   # initializeを直接上書きすると警告が出るので、間接的に上書きする。
   部(:物の初期化を日本語化する) {
-    定義(:initialize) {|*引数, &塊| 初期化(*引数, &塊) }
+    if (_バージョンが2_7以上か?) then
+      定義(:initialize) {|*引数, **名前付き引数, &塊|  初期化(*引数, **名前付き引数, &塊) }
+    else
+      定義(:initialize) {|*引数,                 &塊|  初期化(*引数,                 &塊) }
+    end
     秘密 :initialize
   }
 
   # respond_to_missing?を直接上書きすると警告が出るので、間接的に上書きする。
   部(:物の不明な応答を日本語化する) {
-    定義(:respond_to_missing?) {|名前, *引数| 不明な応答か?(名前, *引数) }
+    定義(:respond_to_missing?) {|名前, *引数| 不明な応答か?(名前, *引数) } # `**名前付き引数'を定義するとシステムスタックが超過する、何故?
     秘密 :respond_to_missing?
   }
 
@@ -269,61 +293,131 @@ require 'japanize/core'
 # 組の定義と被る変換関数を定義する。
 部(核) {
   部(:変換関数の日本語化) {
-    定義(:配列) {|*引数|
-      if (引数.empty?) then
-        Array
-      else
-        Array(*引数)
-      end
-    }
+    if (_バージョンが2_7以上か?) then
+      定義(:配列) {|*引数, **名前付き引数, &塊|
+        if (引数.empty? && 名前付き引数.empty? && ! 塊) then
+          Array
+        else
+          Array(*引数, **名前付き引数, &塊)
+        end
+      }
+    else
+      定義(:配列) {|*引数, &塊|
+        if (引数.empty? &&! 塊) then
+          Array
+        else
+          Array(*引数, &塊)
+        end
+      }
+    end
 
-    定義(:複素数) {|*引数|
-      if (引数.empty?) then
-        Complex
-      else
-        Complex(*引数)
-      end
-    }
+    if (_バージョンが2_7以上か?) then
+      定義(:複素数) {|*引数, **名前付き引数, &塊|
+        if (引数.empty? && 名前付き引数.empty? && ! 塊) then
+          Complex
+        else
+          Complex(*引数, **名前付き引数, &塊)
+        end
+      }
+    else
+      定義(:複素数) {|*引数, &塊|
+        if (引数.empty? && ! 塊) then
+          Complex
+        else
+          Complex(*引数, &塊)
+        end
+      }
+    end
 
-    定義(:不動小数点) {|*引数|
-      if (引数.empty?) then
-        Float
-      else
-        Float(*引数)
-      end
-    }
+    if (_バージョンが2_7以上か?) then
+      定義(:不動小数点) {|*引数, **名前付き引数, &塊|
+        if (引数.empty? && 名前付き引数.empty? && ! 塊) then
+          Float
+        else
+          Float(*引数, **名前付き引数, &塊)
+        end
+      }
+    else
+      定義(:不動小数点) {|*引数, &塊|
+        if (引数.empty? && ! 塊) then
+          Float
+        else
+          Float(*引数, &塊)
+        end
+      }
+    end
 
-    定義(:連想配列) {|*引数|
-      if (引数.empty?) then
-        Hash
-      else
-        Hash(*引数)
-      end
-    }
+    if (_バージョンが2_7以上か?) then
+      定義(:連想配列) {|*引数, **名前付き引数, &塊|
+        if (引数.empty? && 名前付き引数.empty? && ! 塊) then
+          Hash
+        else
+          Hash(*引数, **名前付き引数, &塊)
+        end
+      }
+    else
+      定義(:連想配列) {|*引数, &塊|
+        if (引数.empty? && ! 塊) then
+          Hash
+        else
+          Hash(*引数, &塊)
+        end
+      }
+    end
 
-    定義(:整数) {|*引数|
-      if (引数.empty?) then
-        Integer
-      else
-        Integer(*引数)
-      end
-    }
+    if (_バージョンが2_7以上か?) then
+      定義(:整数) {|*引数, **名前付き引数, &塊|
+        if (引数.empty? && 名前付き引数.empty? && ! 塊) then
+          Integer
+        else
+          Integer(*引数, **名前付き引数, &塊)
+        end
+      }
+    else
+      定義(:整数) {|*引数, &塊|
+        if (引数.empty? &&! 塊) then
+          Integer
+        else
+          Integer(*引数, &塊)
+        end
+      }
+    end
 
-    定義(:有理数) {|*引数|
-      if (引数.empty?) then
-        Rational
-      else
-        Rational(*引数)
-      end
-    }
+    if (_バージョンが2_7以上か?) then
+      定義(:有理数) {|*引数, **名前付き引数, &塊|
+        if (引数.empty? && 名前付き引数.empty? && ! 塊) then
+          Rational
+        else
+          Rational(*引数, **名前付き引数, &塊)
+        end
+      }
+    else
+      定義(:有理数) {|*引数, &塊|
+        if (引数.empty? && ! 塊) then
+          Rational
+        else
+          Rational(*引数, &塊)
+        end
+      }
+    end
 
-    定義(:文字列) {|*引数|
-      if (引数.empty?) then
-        String
-      else
-        String(*引数)
-      end
-    }
+    if (_バージョンが2_7以上か?) then
+      定義(:文字列) {|*引数, **名前付き引数, &塊|
+        if (引数.empty? && 名前付き引数.empty? && ! 塊) then
+          String
+        else
+          String(*引数, **名前付き引数, &塊)
+        end
+      }
+    else
+      定義(:文字列) {|*引数, &塊|
+        if (引数.empty? && ! 塊) then
+          String
+        else
+          String(*引数, &塊)
+        end
+      }
+    end
   }
   拡張 変換関数の日本語化
 }
@@ -466,7 +560,8 @@ require 'japanize/core'
 
 組(例外) {
   特異組{
-    別名 :例外を生成, :exception
+    別名 :例外を生成,            :exception
+    別名 :端末に向かっているか?, :to_tty?
   }
 
   別名 :呼び出し履歴,             :backtrace
@@ -477,21 +572,35 @@ require 'japanize/core'
   # 別名 :検査,                   :inspect    # 物で定義済み
   別名 :伝文,                     :message
   # 別名 :文字列に変換,           :to_s       # 物で定義済み
+  別名 :応答するか?,              :respond_to?
   別名 :呼び出し履歴を設定,       :set_backtrace
 }
 
 部(日本語化) {
   部(:不明な操作の呼び出し履歴を消す) {
-    定義(:不明な操作) {|名前, *引数, &塊|
-      begin
-        super(名前, *引数, &塊)
-      rescue 名前解決に失敗 => ある例外
-        # 物#不明な操作 と Object#method_missing の履歴を消して、元の場所で例外が発生したように見せる
-        ある例外.呼び出し履歴.shift(2)
-        ある例外.呼び出し履歴の場所の一覧.shift(2)
-        例外を発生 ある例外
-      end
-    }
+    if (_バージョンが2_7以上か?) then
+      定義(:不明な操作) {|名前, *引数, **名前付き引数, &塊|
+        begin
+          super(名前, *引数, **名前付き引数, &塊)
+        rescue ::JA::名前解決に失敗 => ある例外
+          # 物#不明な操作 と Object#method_missing の履歴を消して、元の場所で例外が発生したように見せる
+          ある例外.呼び出し履歴.shift(2)
+          ある例外.呼び出し履歴の場所の一覧.shift(2)
+          ::JA::核.例外を発生 ある例外
+        end
+      }
+    else
+      定義(:不明な操作) {|名前, *引数, &塊|
+        begin
+          super(名前, *引数, &塊)
+        rescue ::JA::名前解決に失敗 => ある例外
+          # 物#不明な操作 と Object#method_missing の履歴を消して、元の場所で例外が発生したように見せる
+          ある例外.呼び出し履歴.shift(2)
+          ある例外.呼び出し履歴の場所の一覧.shift(2)
+          ::JA::核.例外を発生 ある例外
+        end
+      }
+    end
   }
 
   組(物の土台) {
@@ -552,9 +661,15 @@ require 'japanize/core'
           super(名前)
           if (本来の名前 = 日本語化対応表[名前]) then
             if (! (操作は定義済みか? 本来の名前) || (生成物が持つ操作を取得(名前) != 生成物が持つ操作を取得(本来の名前))) then
-              定義(本来の名前) {|*引数, &塊|
-                __送信__(名前, *引数, &塊)
-              }
+              if (_バージョンが2_7以上か?) then
+                定義(本来の名前) {|*引数, **名前付き引数, &塊|
+                  __送信__(名前, *引数, **名前付き引数, &塊)
+                }
+              else
+                定義(本来の名前) {|*引数, &塊|
+                  __送信__(名前, *引数, &塊)
+                }
+              end
             end
           end
         }
@@ -589,9 +704,15 @@ require 'japanize/core'
           if (本来の名前 = 日本語化対応表[名前]) then
             特異組{
               if (! (操作は定義済みか? 本来の名前) || (生成物が持つ操作を取得(名前) != 生成物が持つ操作を取得(本来の名前))) then
-                定義(本来の名前) {|*引数, &塊|
-                  __送信__(名前, *引数, &塊)
-                }
+                if (_バージョンが2_7以上か?) then
+                  定義(本来の名前) {|*引数, **名前付き引数, &塊|
+                    __送信__(名前, *引数, **名前付き引数, &塊)
+                  }
+                else
+                  定義(本来の名前) {|*引数, &塊|
+                    __送信__(名前, *引数, &塊)
+                  }
+                end
               end
             }
           end