「Reline」の記事 - Crieit

Reline.readmultilineの練習: mysqlコマンドのラッパーを作ってちょっといい感じにしてみる

2021-05-04T02:12:42+09:00

Reline.readmultiline の基本的な使い方を前回調べましたので、練習で何か作ってみようかと。

何でもよかったのですが、ためしに mysql コマンド（MySQLクライアント）のラッパーを作ってみました。mysql コマンドの対話的インターフェイス、複数行入力はできますが、履歴を遡ると1行にされてちょっと不便ですよね（という体でやってみました）。

使い方

先にテスト用の MySQL サーバを Docker で起動しておいて mysql_wrapper.rb を実行します。

$ docker run -d --rm --name mysql_test \
  -e MYSQL_ALLOW_EMPTY_PASSWORD=yes \
  mysql:8.0.23

# サーバが起動するのを待ってから
$ ruby mysql_wrapper.rb

mysql_wrapper.rb

require "json"
require "shellwords"

require "bundler/inline"
gemfile do
  source "https://rubygems.org"
  gem "reline", "0.2.5" # 最新バージョンで試すため
end

HISTORY_FILE = "mysql_history"
PROMPT = "*mysql> "

def add_history(text)
  File.open(HISTORY_FILE, "a") { |f| f.puts JSON.generate(text) }
end

def load_history
  return unless File.exist?(HISTORY_FILE)

  File.read(HISTORY_FILE).each_line do |json|
    Reline::HISTORY << JSON.parse(json)
  end
end

def execute_sql(sql)
  cmd = Shellwords.shelljoin([
    "docker", "exec", "-it", "mysql_test",
    "/usr/bin/mysql", "-e", sql
  ])

  output = `#{cmd}`
  unless $?.success?
    puts output
    return
  end

  if output.empty? # use, create table などの場合
    puts "(empty output)"
    puts "----"
    return
  end

  puts output
end

Reline.prompt_proc =
  Proc.new do |lines|
    lines.each_with_index.map do |line, i|
      i == 0 ? PROMPT : "*    -> "
    end
  end

load_history

loop do
  text =
    Reline.readmultiline(PROMPT, true) do |input|
      input.strip.end_with?(";")
    end

  add_history text

  if text.start_with?("exit")
    puts "bye"
    break
  end

  execute_sql text
end

実行の例

$ ruby mysql_wrapper.rb 
*mysql> create database db1;
(empty output)
----
*mysql> create table db1.t1 (
*    ->   c1 int
*    -> , c2 text
*    -> , c3 text
*    -> );
(empty output)
----
*mysql> insert into db1.t1 values
*    ->   (   1, 'null' , 'NULL')
*    -> , (  12, ''     , '  ')
*    -> , ( 123, '寿司ビール🍣🍺', ' x ')
*    -> , (1234, 'xml[&<>"] sq[''] bs[\\] t[\t] n[\n] r[\r]', null)
*    -> ;
(empty output)
----
*mysql> select * from db1.t1;
+------+--------------------------------------+------+
| c1   | c2                                   | c3   |
+------+--------------------------------------+------+
|    1 | null                                 | NULL |
|   12 |                                      |      |
|  123 | 寿司ビール🍣🍺              |  x   |
| 1234 | xml[&<>"] sq['] bs[\] t[       ] n[
] | NULL |
+------+--------------------------------------+------+
*mysql> exit;
bye
$

履歴を遡ってもちゃんと複数行のまま復元されます。

1回ごとに mysql コマンドを実行しているので、 use 文などで状態を変えても毎回リセットされる点に注意。mysql プロセスとパイプでやりとりするというのも一瞬考えましたが、サンプルにしては大げさになるかなと思ってやめました。

「末尾が ; になっていること」を編集完了の条件にしているので、 exit ではなく exit; のように末尾にセミコロンを付ける必要があります。

今回のこれはお遊び程度のものですが、入力されたクエリをどこかのサーバに送って記録するとか、MySQL に渡す前にチェックして drop や delete などの文の実行を禁止するとか、いろいろ応用できそうな気がします。

おまけ

+------+--------------------------------------+------+
| c1   | c2                                   | c3   |
+------+--------------------------------------+------+
|    1 | null                                 | NULL |
|   12 |                                      |      |
|  123 | 寿司ビール🍣🍺              |  x   |
| 1234 | xml[&<>"] sq['] bs[\] t[       ] n[
] | NULL |
+------+--------------------------------------+------+

この MySQL の標準の表示ももうちょっといい感じになってほしいんですよね……。

文字列の NULL と null が区別できない
空文字なのか半角スペースなのか分からない
半角じゃない文字があるとずれる
改行があると表が崩れる
上の例だと CR の前の部分が見えない

というわけで、結果をパースしていい感じにしてみます。

mysql コマンドのオプションに --xml を付けて、出力された XML をパースして pp で表示。
CR, LF の変換は今回の例をうまく動かすための適当なものです。適切な対処方ではない気がします。

require "rexml/document"

def parse_mysql_xml(xml)
  doc = REXML::Document.new(
    xml
      .gsub("\n", "
")
      .gsub("\r", "")
  )

  row_els = REXML::XPath.match(doc, "resultset/row")

  colnames = row_els[0].elements.map { |field_el| field_el["name"] }

  body_rows =
    row_els.map do |row_el|
      row_el.elements.map do |field_el|
        if field_el["xsi:nil"] == "true"
          nil
        else
          if field_el.text.nil?
            ""
          else
            field_el.text.gsub("\r\n", "\n")
          end
        end
      end
    end

  [colnames, *body_rows]
end

# ...
rows = parse_mysql_xml(output)
pp rows

# 出力:
[["c1", "c2", "c3"],
 ["1", "null", "NULL"],
 ["12", "", "  "],
 ["123", "寿司ビール🍣🍺", " x "],
 ["1234", "xml[&<>\"] sq['] bs[\\] t[\t] n[\n" + "] r[\r]", nil]]

さらにおまけとして、以前書いたこれを使って列を揃えてみました。

  require_relative "json_array_table"
  # ...
  rows = parse_mysql_xml(output)
  puts JsonArrayTable.generate(rows)

// 出力:
[ "c1"   , "c2"                                        , "c3"   ]
[ "1"    , "null"                                      , "NULL" ]
[ "12"   , ""                                          , "  "   ]
[ "123"  , "寿司ビール🍣🍺"                            , " x "  ]
[ "1234" , "xml[&<>\"] sq['] bs[\\] t[\t] n[\n] r[\r]" , null   ]

割と満足。

Reline.readmultiline ちょっと調べたメモ

2021-04-28T08:43:35+09:00

Reline を使うと複数行編集ができるようなので、自分が使いそうな基本的な部分について調べてみました。

このリッチなのが標準で使えるの嬉しいですよね。ありがたや……。

RUBY_VERSION    #=> 3.0.0
Reline::VERSION #=> 0.2.5

最初の雛形

ブロックは必須。

require "reline"

PROMPT = "> "

loop do
  text =
    Reline.readmultiline(PROMPT) do |_|
      # このブロックについては後述
      true
    end

  # 編集が完了した複数行文字列を使った処理
  puts "text (#{text})"
end

これだけだとまだ複数行編集できないんですが、デバッグ用のログと履歴まわりを準備しておくと捗るので先にそっちを片付けます。

挙動確認のためのデバッグログ出力

デバッグ用の表示を同じターミナルに出力すると混ざって分かりにくいので、ファイルに出力して別ターミナルで tail -F することに。

$log = File.open("debug.log", "a")

def debug(*args)
  $log.puts *args
  $log.flush
end

履歴の保存・復元

同じ入力を繰り返すのは面倒なので履歴まわりを用意しておきます。

Reline.readmultiline の第2引数 add_hist を true にすると Reline が履歴を覚えてくれて、カーソルキー上下や ctrl-n ctrl-p で履歴を辿れるようになります。

  text = Reline.readmultiline(PROMPT, true) do |input| ...

一度終了して次回実行したときに前回までの履歴が復元されてほしいので、シリアライズしてファイルに保存します。とりあえず JSON で適当に。

require "json"

HISTORY_FILE = "history"

def add_history(text)
  File.open(HISTORY_FILE, "a") { |f| f.puts JSON.generate(text) }
end

def load_history
  return unless File.exist?(HISTORY_FILE)

  File.read(HISTORY_FILE).each_line do |json|
    Reline::HISTORY << JSON.parse(json)
  end
end

Reline.readmultiline のブロック

  text =
    Reline.readmultiline(PROMPT, true) do |input|
      debug ""
      debug "-->> readmultiline block"
      debug input.inspect
      true
    end

こんな感じでデバッグ出力して動作を見てみると、Enter キーが押されたタイミングでこのブロックが呼び出されているようだぞ、ということが確認できます。

11 Enter 22 Enter と入力したときのデバッグ出力:

-->> readmultiline block
"11\n"

-->> readmultiline block
"22\n"

このブロックは LineEditor#confirm_multiline_termination_proc にセットされ、

ed_newline
=> confirm_multiline_termination
=> @confirm_multiline_termination_proc

という流れで呼び出されるようです。 ed_newline という名前のメソッドから呼ばれているので、改行の入力がトリガーになっていると考えて良さそうな雰囲気です。

ブロックの呼び出しはこのようになっていて、

@confirm_multiline_termination_proc.(temp_buffer.join("\n") + "\n")

各行の末尾に LF の付いた文字列がブロックの引数に渡ってくることが分かります。

ブロックの評価値の扱いも見てみます。

class Reline::LineEditor
  # ...
  private def ed_newline(key)
    # ...
          if confirm_multiline_termination
            finish
          else
            key_newline(key)
          end

真だったら編集完了、偽だったら編集継続となるようです（見た感じでは）。

というわけで、

編集中の複数行文字列が引数としてブロックに渡ってくる
編集が完了しているかを判断し、完了している場合はブロックの評価値を真にする。途中だったら偽にする。

というあたりを踏まえて、ブロックの中身を修正します。例として、末尾が ; になっていたら編集完了というルールにします。

  text =
    Reline.readmultiline(PROMPT, true) do |input|
      debug ""
      debug "--> readmultiline block"
      debug input.inspect

      finished = input.strip.end_with?(";")
      debug "finished (#{finished})"
      finished
    end

11 Enter ;22 Enter ; Enter と入力したときのデバッグ出力:

-->> readmultiline block
"11\n"
finished (false)       ... まだ編集の途中

-->> readmultiline block
"11\n;22\n"
finished (false)       ... まだ編集の途中

-->> readmultiline block
"11\n;22\n;\n"
finished (true)        ... 末尾が ; なので編集が完了したと判断

なるほど。基本的なことがやりたいだけであればこのくらい分かっていれば良さそうですね。

プロンプトをカスタマイズする

たとえば、最初の行とそれ以外で異なるプロンプトを表示したいといった場合、 Reline.prompt_proc に Proc オブジェクトをセットすることでカスタマイズできるようです。

PROMPT = "> "

Reline.prompt_proc =
  Proc.new do |lines|
    lines.each_with_index.map do |line, i|
      i == 0 ? PROMPT : "| "
    end
  end

$ ruby sample.rb 
> 11
| 22
| ;
text (11
22
;)
>

この場合、Reline.prompt_proc で生成したプロンプト文字列が優先して使われ、Reline.readmultiline の第一引数で渡したプロンプト文字列は使われなくなるようです（表面的な挙動を見た感じでは）。

ただし、Reline.readmultiline の第一引数で渡したプロンプト文字列と長さが異なっていると履歴を移動した際にカーソル位置がずれるので、とりあえず同じ長さにしておくと良いようです。

まとめたもの

require "reline"
require "json"

HISTORY_FILE = "history"
PROMPT = "> "

$log = File.open("debug.log", "a")

def debug(*args)
  $log.puts *args
  $log.flush
end

def add_history(text)
  File.open(HISTORY_FILE, "a") { |f| f.puts JSON.generate(text) }
end

def load_history
  return unless File.exist?(HISTORY_FILE)

  File.read(HISTORY_FILE).each_line do |json|
    Reline::HISTORY << JSON.parse(json)
  end
end

def finished?(input)
  stripped = input.strip
  return true if stripped == "exit"
  return true if stripped.end_with?(";")

  false
end

Reline.prompt_proc =
  Proc.new do |lines|
    lines.each_with_index.map do |line, i|
      i == 0 ? PROMPT : "| "
    end
  end

load_history

loop do
  text =
    Reline.readmultiline(PROMPT, true) do |input|
      debug ""
      debug "-->> readmultiline block"
      debug input.inspect

      finished = finished?(input)
      debug "finished (#{finished})"
      finished
    end

  add_history text

  # 編集が完了した複数行文字列を使った処理
  puts "text (#{text})"

  break if text == "exit"
end

メモ

使用例については irb のソースも見てみると良さそう
- たとえば v3.0.1 だとここで使われています
  https://github.com/ruby/ruby/blob/v3_0_1/lib/irb/input-method.rb#L319

参考

2019-12-26 Ruby 2.7のここがすごい！パターンマッチ、コンパクションGCなどをリリースマネージャーに聞いた - エンジニアHub｜Webエンジニアのキャリアを考える！