nihonjin 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d3c0b5e0e4fdf2e779166d6d9b7b2832f34278c
+  data.tar.gz: 753f1727a235b355b18671c3a02be23e3fb96385
+SHA512:
+  metadata.gz: 4b9b4e2da01af0af7ea473a09a10618edbe6c2519c9f084beb4f5ff6ab3efd909668263ce4a4751213b87f92db053237e12b92b0a69dbfab4701e9ceeb5b5c0a
+  data.tar.gz: feef1600e228ac646106d80db82b0e890245f56cfd5a293f83a54fdd5ee2fe5e628acc413c765fd2b0ccd3b7c44a15b4d81c053efc1134a32def0dc6a43dc1ff

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.1
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nihonjin.gemspec
+gemspec

data/README.md

@@ -0,0 +1,94 @@
+#nihonjin 日本人 :sushi:
+
+日本語をもっと気楽に扱うためのgemです:octocat:
+
+※まだ公開していません
+
+## Moji 文字
+
+### いちいちnkfのオプションを調べるのは面倒くさいから、`Moji`で簡単に定義することができます
+```ruby
+moji = Nihonjin::Moji.new
+moji.hiragana("hiragana ni naru.")
+#=> "ひらがな　に　なる。"
+moji.hiragana("ヒラガナ　ニ　ナル。")
+#=> "ひらがな　に　なる。"
+moji.katakana("かたかな　に　なる")
+#=> "カタカナ　ニ　ナル"
+moji.hankaku_katakana("hankaku katakana ni naru")
+#=> "ﾊﾝｶｸ　ｶﾀｶﾅ　ﾆ　ﾅﾙ"
+
+# Rubyではstripはありますが、日本語の文字に対応していないです
+# 次のメソッドを使うと便利です
+moji.hashigiri("     端　に　ある　空白　を　切り落とす　　　　")
+#=> "端　に　ある　空白　を　切り落とす"
+
+# すべての空白を切り落とすこともできる
+moji.kiru("余計な　空白　を　切り落とす")
+#=> "余計な空白を切り落とす"
+
+
+
+# 出力コードもシンボルとして定義できます
+moji.hiragana("hiragana ni naru.", :shift_jis)
+#=> "\x{82D0}\x{82E7}\x{82AA}\x{82C8}\x{8140}\x{82C9}\x{8140}\x{82C8}\x{82E9}\x{8142}"
+Nihonjin::EncodingTypes
+#=> {:utf_8=>"-w", :shift_jis=>"-s", :iso_2022_jp=>"-j", :euc=>"-e"}
+
+# リテラルも渡すことができます
+moji.hiragana("hiragana ni naru.", "-w", "--mac")
+#=> "ひらがな　に　なる。"
+moji.hiragana("hiragana ni naru.", "-w --mac")
+#=> "ひらがな　に　なる。"
+```
+
+
+##Suji 数字
+今はSujiが少しだけできてる<br/>
+次のメソッドでは、どんな値でも入れていい<br/><br/>
+
+```ruby
+suji = Nihonjin::Suji.new
+# 今のところは、kanji_henkanは20桁まで変換できます
+p suji.kanji_henkan(150)
+#=> "百五十"
+p suji.kanji_henkan(3521)
+#=> "三千五百二十一"
+p suji.kanji_henkan(27825672)
+#=> "二千七百八十二万五千六百七十二"
+p suji.kanji_henkan(623_367_289_348)
+#=> "六千二百三十三億六千七百二十八万九千三百四十八"
+p suji.kanji_henkan(56_004_223_746_273_373_565)
+#=> "五千六百京四千二百二十三兆七千四百六十二億七千三百三十七万三千五百六十五"
+
+
+p suji.zenkaku(300)
+#=> "３００"
+p suji.hankaku("三〇〇")
+#=> "300"
+
+# kanji_henkanと違って、普通に数字をそのまま漢字に変換する
+p suji.kanji(800)
+#=> "八〇〇"
+p suji.daiji("三")
+#=> "参"
+
+p Suji.type?(10)
+#=> "半角"
+p Suji.type?("１０")
+#=> "全角"
+p Suji.type?("十")
+#=> "漢字"
+p Suji.type?("壱")
+#=> "大字"
+
+
+# to_iも使えます
+# 尚、上にあるkanji_henkan()が返すような値ではto_iは使えません
+p suji.to_i("三〇一")
+#=> 301
+p suji.to_i("３０１")
+#=> 301
+p suji.to_i("参零壱")
+#=> 301
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nihonjin"
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/nihonjin.rb

@@ -0,0 +1,4 @@
+require "nihonjin/version"
+require "nihonjin/moji"
+require "nihonjin/suji"
+

data/lib/nihonjin/moji.rb

@@ -0,0 +1,371 @@
+require 'nkf'
+require 'nihonjin/options'
+
+module Nihonjin
+
+  class Moji
+
+    Hiragana = {
+      kya: "きゃ",        kyu: "きゅ",        kyo: "きょ",
+      sha: "しゃ",        shu: "しゅ", she: "しぇ", sho: "しょ",
+      cha: "ちゃ",        chu: "ちゅ",        cho: "ちょ",
+      dya: "ぢゃ",        dyu: "ぢゅ",        dyo: "ぢょ",
+      nya: "にゃ",        nyu: "にゅ",        nyo: "にょ",
+      hya: "ひゃ",        hyu: "ひゅ",        hyo: "ひょ",
+      mya: "みゃ",        myu: "みゅ",        myo: "みょ",
+      rya: "りゃ",        ryu: "りゅ",        ryo: "りょ",
+
+      gya: "ぎゃ",        gyu: "ぎゅ",        gyo: "ぎょ",
+      ja: "じゃ",         ju: "じゅ", je: "じぇ", jo: "じょ",
+      jya: "じゃ",         jyu: "じゅ",       jyo: "じょ",
+      bya: "びゃ",        byu: "びゅ",        byo: "びょ",
+
+      pya: "ぴゃ",        pyu: "ピュ",        pyo: "ぴょ",
+
+      tsu: "つ",
+      tu: "つ",
+
+      ka: "か", ki: "き", ku: "く", ke: "け", ko: "こ",
+      sa: "さ", shi: "し", si: "し", su: "す", se: "せ", so: "そ",
+      ta: "た", chi: "ち", te: "て", to: "と",
+      na: "な", ni: "に", nu: "ぬ", ne: "ね", no: "の",
+      ha: "は", hi: "ひ", fu: "ふ", he: "へ", ho: "ほ",
+      ma: "ま", mi: "み", mu: "む", me: "め", mo: "も",
+      ya: "や",           yu: "ゆ",          yo: "よ",
+      ra: "ら", ri: "り", ru: "る", re: "れ", ro: "ろ",
+      wa: "わ", wi: "ゐ",           we: "ゑ", wo: "を",
+      n: "ん", n_: "ん", # 「n_」というのは、「はんい」みたいな言葉を書くためです。Issue #16を見てください
+
+      va: "ゔぁ", vi: "ゔぃ", vu: "ゔ", ve: "ゔぇ", vo: "ゔぉ",
+      ga: "が", gi: "ぎ", gu: "ぐ", ge: "げ", go: "ご",
+      za: "ざ", ji: "じ", zu: "ず", ze: "ぜ", zo: "ぞ",
+      da: "だ", di: "ぢ", du: "づ", de: "で", do: "ど",
+                        dzu: "づ",
+      ba: "ば", bi: "び", bu: "ぶ", be: "べ", bo: "ぼ",
+      pa: "ぱ", pi: "ぴ", pu: "ぷ", pe: "ぺ", po: "ぽ",
+
+      fa: "ふぁ", fi: "ふぃ", fe: "ふぇ", fo: "ふぉ",
+                 di_: "でぃ",
+      a: "あ", i: "い", u: "う", e: "え", o: "お",
+                       wu: "う"
+    }
+
+    Small_hiragana = {
+      ya: "ゃ",          yu: "ゅ",           yo: "ょ",
+      a: "ぁ", i: "ぃ", u: "ぅ", e: "ぇ", o: "ぉ",
+      tsu: "っ"
+    }
+
+    Consonants = ["bb", "cc", "dd", "ff", "gg", "hh", "jj", "kk", "ll", "pp", "qq", "rr", "ss", "tt", "vv", "ww", "yy", "zz"]
+
+    # これはちょっと見にくいから直せばいい
+    # ところで[0]の方は英字で[1]の方は日本語
+    Symbols = [[".", "。"], ["!", "！"], ["?", "？"], [",", "、"], ["~", "〜"]]
+
+    # 対象の文字列をnkfで、ひらがなに変換します。#nkf_passと「たのしいRuby」299ページを参照してください
+    def hiragana(str, *options)
+      
+      need_to_change_encoding = check_encoding(options)
+      options = setup options
+      str_data = utf_8_pass(str)
+      str = str_data[:string]
+      str = str.downcase
+
+      # "matte"みたいな文字列を「まって」に変換します
+      Consonants.each do |c|
+        if str.match(c)
+          str = str.gsub(c, ("っ" + c[0]))
+        end
+      end
+
+      # 対象の文字列にはローマ字がある場合ひらがなに変換します
+      Hiragana.each do |key, value|
+        re = Regexp.new(key.to_s)
+        if str.match(re)
+          str = str.gsub(re, Hiragana[key])
+        end
+      end
+
+      # 「x」を文字の前に入れることで、小さいひらがなを定義することができます
+      if str =~ /x/
+        i = 0
+        str_ary = str.split("")
+        str_ary.each do |s|
+          if s =~ /x/
+            str[i + 1] = Small_hiragana[Hiragana.key(str[i + 1])]
+          end
+          i += 1
+        end
+        str = str.gsub("x", "")
+      end
+
+      # 上記Consonants.eachのコードで重なっている文字は小さい「っ」に変換されるけど、全部は変換されません
+      # 子音が残ってしまえば、変換されます。
+      if str =~ /[a-z]/
+        i = 0
+        str_ary = str.split("")
+        str_ary.each do |s|
+          if s =~ /っ/
+            str[i + 1] = "っ" if str[i + 1] =~ /[a-z]/
+          end
+          i += 1
+        end
+      end
+
+      # びっくりマークなどの記号を日本語の文字にします
+      Symbols.each do |symbol|
+        str = str.gsub(symbol[0], symbol[1])
+      end
+
+      # この時点で if /[a-z]/、エラーをthrowしてください
+      # raise error if str =~ /[a-zA-Z]/
+
+      # これは要るかどうか工夫すること
+      # またオプションとしては定義できるようにしたらいいかどうか工夫すること
+      str = kuhaku(str, :zenkaku) 
+
+      str = NKF.nkf(('-h1 ' + options), str)
+      str = str.encode(str_data[:encoding].name) if need_to_change_encoding
+      str
+
+    end
+
+    def hiragana!(str, *options)
+      str.sub!(str, (hiragana(str, options)))
+    end
+
+
+
+    def katakana(str, *options)
+      str = hiragana(str, options)
+      str = nkf_pass(str, '-h2', options)
+    end
+
+    def katakana!(str, *options)
+      str.sub!(str, (katakana(str, options)))
+    end
+
+
+
+    def hankaku_katakana(str, *options)
+      str = katakana(str, options)
+      str = nkf_pass(str, '-Z4', options)
+    end
+
+    def hankaku_katakana!(str, *options)
+      str.sub!(str, (hankaku_katakana(str, options)))
+    end
+
+
+
+    def kana_invert(str, *options)
+      options = setup options
+      str = nkf_pass(str, '-h3', options)
+    end
+
+    def kana_invert!(str, *options)
+      str.sub!(str, (kana_invert(str, options)))
+    end
+
+
+
+    def romaji(str, encoding=:utf_8)
+
+      need_to_change_encoding = check_encoding(encoding)
+      str_data = utf_8_pass(str)
+
+      # すべての文字をひらがなに統一してからローマ字に変換されます。カタカナなどが入っている時の対応
+      str = hiragana(str, encoding)
+      str = str.downcase
+
+      str_data = utf_8_pass(str)
+      str = str_data[:string]
+
+      change_to = Proc.new do |hash|
+        hash.each do |key, value|
+          re = Regexp.new(value)
+          if str.match(re)
+            str = str.gsub(re, key.to_s)
+          end
+        end
+      end
+
+      change_to.call(Hiragana)
+
+      # while文はちょっと気になる
+      while str =~ /っ/
+        place = str =~ /っ/
+        small_tsu_to_romaji(str, place)
+      end
+
+      # ダブっている文字が小さい「っ」に変換されてからしないといけません
+      change_to.call(Small_hiragana)
+
+      Symbols.each do |symbol|
+        str = str.gsub(symbol[1], symbol[0])
+      end
+
+      str = kuhaku(str)
+      str = str.encode(str_data[:encoding].name) if need_to_change_encoding
+      str
+
+    end
+
+    def romaji!(str, encoding=:utf_8)
+      str.sub!(str, (romaji(str, encoding)))
+    end
+
+
+    #################################
+    #                               #
+    # 以降は空白を扱うためのメソッドです #
+    #                               #
+    #################################
+
+    # 対象の文字列のすべての空白を切り落とす
+    def kiru(str)
+      if str.match(/　/)
+        str = str.gsub(/　/, " ")
+      end
+      str.gsub(/\s/, "")
+    end
+
+    def kiru!(str)
+      str.sub!(str, kiru(str))
+    end
+
+
+    # 対象の文字列の端にある空白を切り落とす
+    def hashigiri(str)
+      if str.match(/^　/)
+        str = str.sub(/^　/, " ")
+      end
+      if str.match(/　$/)
+        str = str.sub(/　$/, " ")
+      end
+      str = str.strip
+    end
+
+    def hashigiri!(str)
+      str.sub!(str, hashigiri(str))
+    end
+
+
+
+    # 対象の文字列の空白を半角の空白にします
+    # :zenkakuをoptionとして渡せば、すべての空白は全角の空白に変換されます
+    def kuhaku(str, option=nil)
+      str_data = utf_8_pass(str)
+      str = str_data[:string]
+      # :double というオプションを入れたい。nkfの-Z2のこと
+      if option == :zenkaku
+        str = str.gsub(/\s/, "　") # 全角に変える
+      else
+        str = str.gsub(/　/, " ") # 普通の空白に変える
+      end
+      str.encode(str_data[:encoding].name)
+    end
+
+    # #kuhakuの文字列を破壊的に変換します
+    def kuhaku!(str, option=nil)
+      str.sub!(str, kuhaku(str))
+    end
+
+
+    # 対象の文字列の全角と半角の空白を逆にします
+    def kuhaku_invert(str)
+      str_data = utf_8_pass(str)
+      str = str_data[:string]
+      str = str.split("")
+      str = str.map do |s|
+        if s =~ /\s/ # 半角であれば
+          s = "　" # 全角に
+        elsif s =~ /　/ # 全角であれば
+          s = " " # 半角に
+        else
+          s
+        end
+      end
+      new_str = String.new
+      str.each do |s|
+        new_str += s
+      end
+      new_str = new_str.encode(str_data[:encoding].name)
+    end
+
+    # #kuhaku_invertの文字列を破壊的に変換します
+    def kuhaku_invert!(str)
+      str.sub!(str, kuhaku_invert(str))
+    end
+
+
+
+    private
+
+    # optionsの中で新しい文字コードを定義すれば、nkfは文字列をそのエンコーディングにします
+    # 定義していなければ、元のエンコーディングに変える必要がありますとtrueを返します
+    def check_encoding(*options)
+      options = options.flatten if options.class == Array
+      need_to_change_encoding = true
+      options.each do |option|
+        EncodingTypes.each do |key, val|
+          if option == key || option =~ Regexp.new(val)
+            need_to_change_encoding = false
+          end
+        end
+      end
+      need_to_change_encoding
+    end
+
+    def setup(options)
+      options = options.flatten
+      options = options.map do |option|
+        option = EncodingTypes[option] if option.class == Symbol
+        option
+      end
+      options = options.join(' ')
+      options = EncodingTypes[:utf_8] if options.empty?
+      options
+    end
+
+    # utf-8でない文字列の対応としては、元のエンコーディングとutf-8バージョンの文字列を配列に格納して返します。
+    # #hiraganaとかのメソッドの処理が終われば、必要であれば、文字列の元のエンコーディングに戻します
+    def utf_8_pass(str)
+      original_encoding = str.encoding
+      str = str.encode("UTF-8")
+      str_data = {
+        string: str,
+        encoding: original_encoding
+      }
+    end
+
+    # specific_optionは'-h2'、'-Z4'などのことを差します
+    # 上記のメソッドで文字列、オプションのリテラル、そしてそれ以外のオプションを定義するだけで、
+    # nkfの関数が呼び出されます
+    def nkf_pass(str, specific_option, *options)
+      need_to_change_encoding = check_encoding(options)
+      options = setup options
+      str_data = utf_8_pass(str)
+      str = str_data[:string]
+      str = NKF.nkf((specific_option + ' ' + options), str)
+      str = str.encode(str_data[:encoding].name) if need_to_change_encoding
+      str
+    end
+
+    # 再帰的に対象の文字列に「っ」が何個か続いたら、「っ」の次の文字の（ローマ字の）子音を見つけて「っ」と代えます。
+    # 「どっっっかん！」を書いたら「dokkkkan!」になる
+    def small_tsu_to_romaji(str, place)
+      if str[place + 1] =~ /[a-zA-Z]/
+        str[place] = str[place + 1]
+      else
+        if str[place + 1] == "っ"
+          str[place] = small_tsu_to_romaji(str, (place + 1))
+        else # びっくりマークなどの場合
+          str[place] = ""
+        end
+      end
+    end
+
+  end
+
+end

data/lib/nihonjin/options.rb

@@ -0,0 +1,10 @@
+module Nihonjin
+
+  EncodingTypes = {
+        utf_8: '-w',
+        shift_jis: '-s',
+        iso_2022_jp: '-j',
+        euc: '-e'
+      }
+
+end

data/lib/nihonjin/suji.rb

@@ -0,0 +1,253 @@
+module Nihonjin
+
+  class Suji
+
+    Hankaku = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    Zenkaku = ["０", "１" , "２", "３", "４", "５", "６", "７", "８", "９"]
+    Kanji = ["〇", "一", "二", "三", "四", "五", "六", "七", "八", "九"]
+    Daiji = ["零", "壱", "弐", "参", "肆", "伍", "陸", "漆", "捌", "玖"]
+    Daisu = ["万", "億", "兆", "京", "垓", "𥝱", "穣", "溝", "澗", "正", "載", "極"]
+    # "恒河沙", "阿僧祇", "那由他", "不可思議", "無量大数" => こういうのを入れたかったら、扱いが変わらないとダメだ（長さは1じゃないから）
+    
+    # 大数の読み方もあればいいかな
+    # メソッドの引数にはカンマが入っている時の対応
+
+    # ユーザも使えるようにpublicにしました
+    def type?(num)
+      num = num.to_s
+      constants = [Hankaku, Zenkaku, Kanji, Daiji]
+      type = nil
+      constants.each do |constant|
+        10.times do |n|
+          regexp = Regexp.new(constant[n].to_s)
+          if num.match(regexp)
+            type = constant
+            break
+          end
+        end
+      end
+      if type == Zenkaku
+        "全角"
+      elsif type == Kanji
+        "漢字"
+      elsif type == Daiji
+        "大字"
+      elsif type == Hankaku
+        "半角"
+      else
+        ""
+      end
+    end
+
+    def to_i(num)
+      return num unless !(num.instance_of? Integer)
+      num = hankaku(num)
+      num.to_i
+    end
+
+    def hankaku(num)
+      type = type?(num)
+      return num.to_i if type == "半角"
+      num = converter(num, type, Hankaku)    
+    end
+
+    def zenkaku(num)
+      type = type?(num)
+      return num if type == "全角"
+      num = converter(num, type, Zenkaku)
+    end
+
+    def kanji(num)
+      type = type?(num)
+      return num if type == "漢字"
+      num = converter(num, type, Kanji)
+    end
+
+    def daiji(num)
+      type = type?(num)
+      return num if type == "大字"
+      num = converter(num, type, Daiji)
+    end
+
+    def kanji_henkan(num)
+      num = num.to_s
+      if num == "0"
+        return kanji(num)
+      end
+      comma_place = 4
+      comma_counter = 0
+      loop do
+        if comma_place > (num.length)
+          break
+        else
+          num[-(comma_place + comma_counter), 0] = "," if num[-(comma_place + comma_counter)] != nil
+          comma_place += 4
+          comma_counter += 1
+        end
+      end
+      split_num = num.split(",")
+      split_num.shift if split_num[0] == ""
+      
+      kanji_array = split_num.map do |n|
+        case n.length
+        when 1
+          ichi(n)
+        when 2
+          ju(n)
+        when 3
+          hyaku(n)
+        when 4
+          sen(n)
+        end
+      end
+
+      num = String.new
+      kanji_array.length.times do |n|
+        num[0, 0] += Daisu[n] + kanji_array[-(n + 1)]
+      end
+      Daisu.each do |ds|
+        regexp_str = "^" + ds
+        regexp = Regexp.new(regexp_str)
+        if num =~ regexp
+          num[0] = ""
+        end
+      end
+
+      # 数字は「一兆億万」とかにならなくて「一兆」みたいになるように
+      num.length.times do |n|
+        Daisu.each do |ds|
+          if num[n] == ds
+            if num[n + 1] == Daisu[(Daisu.index(ds)) - 1]
+              num[n + 1] = ""
+            end
+          end
+        end
+      end
+      
+      # p split_num
+      num
+
+    end
+
+
+
+    private
+
+    def converter(num, type, result_type)
+      num = num.to_s
+      case type
+      when "全角"
+        type = Zenkaku
+      when "漢字"
+        type = Kanji
+      when "大字"
+        type = Daiji
+      else
+        type = Hankaku
+      end
+      10.times do |n|
+        regexp = Regexp.new(type[n].to_s)
+        num = num.gsub(regexp, result_type[n].to_s)
+      end
+      num
+    end
+
+    def ichi(num)
+      if num == "0"
+        ""
+      else
+        num = kanji(num)
+      end
+    end
+
+    # １〜２桁の数字を正しい漢字に変換する
+    def ju(num)
+      num = num.split("")
+
+      # 次の条件が満たされます
+      # （尚、１桁の場合もjuで対応します。空というのは「00」の場合です）
+      # 十、十一、二十、二十一、一、空
+      if num[0] == "1" && num[1] == "0" # 十
+        num = "十"
+      elsif num[0] == "1" && num[1] != "0" # 十一
+        num[0] = "十"
+        num[1] = kanji(num[1])
+      elsif (num[0] != "0" && num != "1") && num[1] == "0" # 二十
+        num[0] = kanji(num[0])
+        num[1] = "十"
+      elsif (num[0] != "0" && num != "1") && num[1] != "0" # 二十一
+        num = num.unshift(num[0])
+        num[0] = kanji(num[0])
+        num[1] = "十"
+        num[2] = kanji(num[2])
+      elsif num[0] == "0" && num[1] != "0" # 一
+        num[0] = ""
+        num[1] = kanji(num[1])
+      elsif num[0] == "0" && num[1] == "0" # 空
+        num = ""
+      end
+
+      new_str = String.new
+      if num.instance_of? Array
+        num.each do |digit|
+          new_str += digit
+        end
+        num = new_str
+      end
+
+      num
+
+    end
+
+    # ３桁の数字を正しい漢字に変換する
+    def hyaku(num)
+
+      num = num.split("")
+      tenth_place = (num[-2] + num[-1])
+      tenth_place = ju(tenth_place)
+      # 次の条件が満たされます
+      # 百、二百、空
+      # 尚、「十」の位置以降はju()で計算されますので、先にそのメソッドを呼んで、戻り値を「百」の尾に連結します
+      if num[0] == "1" # 百
+        num[0] = "百"
+        num = num[0] + tenth_place
+      elsif num[0] == "0" # 空 （num[0]が要らなくなるのでtenth_placeだけをnumに代入します）
+        num = tenth_place
+      elsif (num[0] != "1" && num[0] != "0") # 二百
+        num = num.unshift(num[0])
+        num[0] = kanji(num[0])
+        num[1] = "百"
+        num = num[0] + num[1] + tenth_place
+      end
+
+      num
+
+    end
+
+    # ４桁の数字を正しい漢字に変換する
+    def sen(num)
+      num = num.split("")
+      hundreth_place = (num[-3] + num[-2] + num[-1])
+      hundreth_place = hyaku(hundreth_place)
+
+      # 次の条件が満たされます（hyaku(num)と同じく）
+      # 千、一千、空
+      if num[0] == "1" # 千
+        num[0] = "千"
+        num = num[0] + hundreth_place
+      elsif num[0] == "0" # 空（num[0]が要らなくなるのでhundredth_placeだけをnumに代入します）
+        num = hundreth_place
+      else # 一千など
+        num = num.unshift(num[0])
+        num[0] = kanji(num[0])
+        num[1] = "千"
+        num = num[0] + num[1] + hundreth_place
+      end
+
+      num
+
+    end
+
+  end
+
+end

data/lib/nihonjin/version.rb

@@ -0,0 +1,3 @@
+module Nihonjin
+  VERSION = "0.1.0"
+end

data/nihonjin.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nihonjin/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nihonjin"
+  spec.version       = Nihonjin::VERSION
+  spec.authors       = ["gazayas"]
+  spec.email         = ["g-zayas@hotmail.com"]
+
+  spec.summary       = "handle Japanese<=>English letter strings with ease"
+  spec.description   = "Ruby has the NKF.nkf() method, but the options are unclear by just looking at them, so this gem has methods like hiragana() so you know what you're changing your strings to"
+  spec.homepage      = "https://github.com/gazayas/nihonjin"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "http://rubygems.org/gems/nihonjin"
+  # 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 { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: nihonjin
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- gazayas
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ruby has the NKF.nkf() method, but the options are unclear by just looking
+  at them, so this gem has methods like hiragana() so you know what you're changing
+  your strings to
+email:
+- g-zayas@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/nihonjin.rb
+- lib/nihonjin/moji.rb
+- lib/nihonjin/options.rb
+- lib/nihonjin/suji.rb
+- lib/nihonjin/version.rb
+- nihonjin.gemspec
+homepage: https://github.com/gazayas/nihonjin
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: handle Japanese<=>English letter strings with ease
+test_files: []