review-retrovert 0.9.7 → 0.9.8

data/testdata/mybook/lib/ruby/review-builder.rb

@@ -4,6 +4,8 @@
 ### ReVIEW::Builderクラスを拡張する
 ###
 
+require 'csv'
+
 require 'review/builder'
 
 
@@ -14,6 +16,22 @@ module ReVIEW
 
   class Builder
 
+    def target_name
+      c = self.class.to_s.gsub('ReVIEW::', '').gsub('Builder', '').downcase
+      return c
+    end
+
+    def config_starter
+      return @book.config['starter']
+    end
+
+    def _current_target?(name_str)
+      s = name_str.to_s.strip
+      return true if s.empty? || s == '*'
+      t = target_name()
+      return s.split(',').map(&:strip).include?(t)
+    end
+
     ## Re:VIEW3で追加されたもの
     def on_inline_balloon(arg)
       return "← #{yield}"
@@ -27,6 +45,12 @@ module ReVIEW
     def ol_item_end()
     end
 
+    def dl_dd_begin()
+    end
+
+    def dl_dd_end()
+    end
+
     protected
 
     def truncate_if_endwith?(str)
@@ -41,6 +65,18 @@ module ReVIEW
       end
     end
 
+    def truncate_blank()
+      sio = @output   # StringIO object
+      if sio.string.end_with?("\n\n")
+        pos = sio.pos - 1
+        sio.seek(pos)
+        sio.truncate(pos)
+        true
+      else
+        false
+      end
+    end
+
     def enter_context(key)
       @doc_status[key] = true
     end
@@ -62,7 +98,7 @@ module ReVIEW
 
     def within_codeblock?
       d = @doc_status
-      d[:program] || d[:terminal] \
+      d[:program] || d[:terminal] || d[:output]\
       || d[:list] || d[:emlist] || d[:listnum] || d[:emlistnum] \
       || d[:cmd] || d[:source]
     end
@@ -85,112 +121,137 @@ module ReVIEW
     end
     protected :on_minicolumn
 
+    ## 画像横に文章
+
     def on_sideimage_block(imagefile, imagewidth, option_str=nil, &b)
-      raise NotImplementedError.new("#{self.class.name}#on_sideimage_block(): not implemented yet.")
+      opts = _sideimage_parse_options(option_str) { "//sideimage[#{imagefile}][#{imagewidth}]" }
+      _sideimage_validate_args(imagefile, imagewidth)
+      filepath = find_image_filepath(imagefile)
+      _render_sideimage(filepath, imagewidth, opts, &b)
+    end
+
+    def _render_sideimage(filepath, imagewidth, opts, &b)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
     end
 
-    def validate_sideimage_args(imagefile, imagewidth, option_str)
+    def _sideimage_parse_options(option_str, &b)
       opts = {}
-      if option_str.present?
-        option_str.split(',').each do |kv|
-          kv.strip!
-          next if kv.empty?
-          kv =~ /(\w[-\w]*)=(.*)/  or
-            error "//sideimage: [#{option_str}]: invalid option string."
-          opts[$1] = $2
-        end
-      end
-      #
-      opts.each do |k, v|
+      _each_block_option(option_str) do |k, v|
         case k
         when 'side'
           v == 'L' || v == 'R'  or
-            error "//sideimage: [#{option_str}]: 'side=' should be 'L' or 'R'."
+            error "#{yield}[#{k}=#{v}]: 'side=' should be 'L' or 'R'."
         when 'boxwidth'
           v =~ /\A\d+(\.\d+)?(%|mm|cm|zw)\z/  or
-            error "//sideimage: [#{option_str}]: 'boxwidth=' invalid (expected such as 10%, 30mm, 3.0cm, or 5zw)"
+            error "#{yield}[#{k}=#{v}]: 'boxwidth=' invalid (expected such as 10%, 30mm, 3.0cm, or 5zw)"
         when 'sep'
           v =~ /\A\d+(\.\d+)?(%|mm|cm|zw)\z/  or
-            error "//sideimage: [#{option_str}]: 'sep=' invalid (expected such as 2%, 5mm, 0.5cm, or 1zw)"
+            error "#{yield}[#{k}=#{v}]: 'sep=' invalid (expected such as 2%, 5mm, 0.5cm, or 1zw)"
         when 'border'
-          v =~ /\A(on|off)\z/  or
-            error "//sideimage: [#{option_str}]: 'border=' should be 'on' or 'off'"
-          opts[k] = v == 'on' ? true : false
+          v.nil? || v =~ /\A(on|off)\z/  or
+            error "#{yield}[#{k}=#{v}]: 'border=' should be 'on' or 'off'"
+          v = v.nil? ? true : v == 'on'
         else
-          error "//sideimage: [#{option_str}]: unknown option '#{k}=#{v}'."
+          error "#{yield}[#{k}=#{v}]: unknown option '#{k}=#{v}'."
         end
+        opts[k] = v
       end
-      #
+      return opts
+    end
+
+    def _sideimage_validate_args(imagefile, imagewidth)
       imagefile.present?  or
         error "//sideimage: 1st option (image file) required."
       imagewidth.present?  or
         error "//sideimage: 2nd option (image width) required."
       imagewidth =~ /\A\d+(\.\d+)?(%|mm|cm|zw|pt)\z/  or
         error "//sideimage: [#{imagewidth}]: invalid image width (expected such as: 30mm, 3.0cm, 5zw, or 100pt)"
-      #
-      return imagefile, imagewidth, opts
     end
-    protected :validate_sideimage_args
-
-    ## コードブロック（//program, //terminal）
 
-    CODEBLOCK_OPTIONS = {
-      'fold'   => true,
-      'lineno' => false,
-      'linenowidth' => -1,
-      'eolmark'     => false,
-      'foldmark'    => true,
-      'lang'        => nil,
-    }
+    ## コードブロック（//program, //terminal, //output）
 
     ## プログラム用ブロック命令
-    ## ・//list と似ているが、長い行を自動的に折り返す
-    ## ・seqsplit.styの「\seqsplit{...}」コマンドを使っている
     def program(lines, id=nil, caption=nil, optionstr=nil)
       _codeblock('program', lines, id, caption, optionstr)
     end
 
     ## ターミナル用ブロック命令
-    ## ・//cmd と似ているが、長い行を自動的に折り返す
-    ## ・seqsplit.styの「\seqsplit{...}」コマンドを使っている
     def terminal(lines, id=nil, caption=nil, optionstr=nil)
       _codeblock('terminal', lines, id, caption, optionstr)
     end
 
+    ## 出力結果用ブロック命令
+    def output(lines, id=nil, caption=nil, optionstr=nil)
+      _codeblock('output', lines, id, caption, optionstr)
+    end
+
     protected
 
     def _codeblock(blockname, lines, id, caption, optionstr)
-      raise NotImplementedError.new("#{self.class.name}#_codeblock(): not implemented yet.")
+      opts = _codeblock_parse_options(optionstr) {
+        "//#{blockname}[#{id}][#{caption}]"
+      }
+      default_opts = _codeblock_default_options(blockname)
+      default_opts.each {|k, v| opts[k] = v unless opts.key?(k) }
+      #
+      if opts['file']
+        lines = _codeblock_read_file(opts['file'], opts['encoding'])
+      end
+      #
+      lines = lines.map {|line| detab(line) }
+      #
+      if id.present? || caption.present?
+        caption_str = _build_caption_str(id, caption)
+      else
+        caption_str = nil
+      end
+      #
+      _render_codeblock(blockname, lines, id, caption_str, opts)
+    end
+
+    def _codeblock_default_options(blockname)
+      terminal_p = (blockname == 'terminal' || blockname == 'cmd')
+      dict = self.config_starter()
+      return dict['terminal_default_options'] if terminal_p
+      return dict['program_default_options']
     end
 
     def _each_block_option(option_str)
+      return if option_str.nil?
+      option_str = option_str.strip()
+      return if option_str.empty?
+      b = nil
       option_str.split(',').each do |kvs|
-        k, v = kvs.split('=', 2)
+        k, v = kvs.strip.split('=', 2)
+        if k =~ /::?/
+          t = $`; k = $'
+          b ||= target_name()
+          next unless t == b
+        end
         yield k, v
-      end if option_str && !option_str.empty?
+      end
     end
 
-    def _parse_codeblock_optionstr(optionstr, blockname)  # parse 'fold={on|off},...'
+    def _codeblock_parse_options(option_str, &b)  # parse 'fold={on|off},...'
       opts = {}
-      return opts if optionstr.nil? || optionstr.empty?
+      return opts if option_str.nil? || option_str.empty?
       vals = {nil=>true, 'on'=>true, 'off'=>false}
-      optionstr.split(',').each_with_index do |x, i|
-        x = x.strip()
+      i = -1
+      _each_block_option(option_str) do |k, v|
+        i += 1
         ## //list[][][1] は //list[][][lineno=1] とみなす
-        if x =~ /\A[0-9]+\z/
-          opts['lineno'] = x.to_i
+        if v.nil? && k =~ /\A[0-9]+\z/
+          opts['lineno'] = k.to_i
           next
         end
         #
-        x =~ /\A([-\w]+)(?:=(.*))?\z/  or
-          raise "//#{blockname}[][][#{x}]: invalid option format."
-        k, v = $1, $2
+        x = v ? "#{k}=#{v}" : k
         case k
-        when 'fold', 'eolmark', 'foldmark'
+        when 'fold', 'eolmark', 'foldmark', 'widecharfit'
           if vals.key?(v)
             opts[k] = vals[v]
           else
-            raise "//#{blockname}[][][#{x}]: expected 'on' or 'off'."
+            error "#{yield}[#{x}]: expected 'on' or 'off'."
           end
         when 'lineno'
           if vals.key?(v)
@@ -200,43 +261,168 @@ module ReVIEW
           elsif v =~ /\A\d+-?\d*(?:\&+\d+-?\d*)*\z/
             opts[k] = v
           else
-            raise "//#{blockname}[][][#{x}]: expected line number pattern."
+            error "#{yield}[#{x}]: expected line number pattern."
           end
         when 'linenowidth'
           if v =~ /\A-?\d+\z/
             opts[k] = v.to_i
           else
-            raise "//#{blockname}[][][#{x}]: expected integer value."
+            error "#{yield}[#{x}]: expected integer value."
           end
         when 'fontsize'
           if v =~ /\A((x-|xx-)?small|(x-|xx-)?large)\z/
             opts[k] = v
           else
-            raise "//#{blockname}[][][#{x}]: expected small/x-small/xx-small."
+            error "#{yield}[#{x}]: expected small/x-small/xx-small."
           end
-        when 'indentwidth'
+        when 'indent', 'indentwidth'
           if v =~ /\A\d+\z/
+            k = 'indent'
             opts[k] = v.to_i
+          elsif vals.key?(v)
+            opts[k] = vals[v]
+          else
+            error "#{yield}[#{x}]: expected integer (>=0)."
+          end
+        when 'charspace'
+          if v =~ /\A-?\d+(\.\d*)?\z/
+            error "#{yield}[#{x}]: unit of measure required, such as '#{v}em'."
+          elsif v =~ /\A-?\d+(\.\d*)?([a-zA-Z]+)?$/
+            opts[k] = v
           else
-            raise "//#{blockname}[][][#{x}]: expected integer (>=0)."
+            error "#{yield}[#{x}]: length expected (such as '0.04em')"
           end
         when 'lang'
           if v
             opts[k] = v
           else
-            raise "//#{blockname}[][][#{x}]: requires option value."
+            error "#{yield}[#{x}]: requires option value."
           end
+        when 'file', 'encoding'
+          v.present?  or
+            error "#{yield}[#{x}]: requires #{k} name."
+          errmsg = __send__("_check_#{k}_option", v)
+          error "#{yield}[#{x}]: #{errmsg}" if errmsg
+          opts[k] = v
+        when 'classname'
+          v.present?  or
+            error "#{yield}[#{x}]: class name should not be empty."
+          v =~ /\A[-\w]+\z/  or
+            error "#{yield}[#{x}]: invalid class name."
+          opts[k] = v
         else
-          if i == 0
-            opts['lang'] = v
+          if i == 0 && v.nil?
+            opts['lang'] = k    # for compatibility with Re:VIEW
           else
-            raise "//#{blockname}[][][#{x}]: unknown option."
+            error "#{yield}[#{x}]: unknown option."
           end
         end
       end
       return opts
     end
 
+    alias _parse_codeblock_optionstr _codeblock_parse_options
+
+    def _check_file_option(file)
+      File.exist?(file)     or return "file not exist."
+      File.file?(file)      or return "not a file."
+      File.readable?(file)  or return "cannot read that file (maybe permission denied)."
+      nil
+    end
+
+    def _check_encoding_option(encoding)
+      Encoding.find(encoding)  or return "unknown encoding."
+      nil
+    end
+
+    def _codeblock_read_file(filename, enc)
+      encoding = enc ? "#{enc}:utf-8" : "utf-8"
+      lines = File.open(filename, encoding: encoding) {|f| f.to_a }
+      return lines
+    end
+
+    def _codeblock_eolmark()
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
+    end
+
+    def _codeblock_indentmark()
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
+    end
+
+    def _render_codeblock(blockname, lines, id, caption_str, opts)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
+    end
+
+    def _parse_inline(str, &b)
+      en = enum_for(:_scan_inline_commands, str)
+      buf = []
+      _parse_inline_commands(en, buf, nil, &b)
+      return buf.join()
+    end
+
+    def _scan_inline_commands(str)
+      pos = 0
+      str.scan(/(\@<\w+>[{|$])|(\\[}\\])|([}|$])/) do
+        s1 = $1; s2 = $2; s3 = $3
+        m = Regexp.last_match
+        text = str[pos...m.begin(0)]
+        pos = m.end(0)
+        yield text, s1, s2, s3
+      end
+      remained = pos == 0 ? str : str[pos..-1]
+      yield remained, nil, nil, nil
+    end
+
+    def _parse_inline_commands(en, buf, echar, &b)
+      while true
+        text, s1, s2, s3 = en.next()
+        buf << (yield text) unless text.empty?
+        if s1
+          command = s1[2..-3]
+          schar_ = s1[-1]
+          echar_ = schar_ == '{' ? '}' : schar_
+          if respond_to?("on_inline_#{command}")
+            x = __send__("on_inline_#{command}") { "\0" }
+          elsif respond_to?("inline_#{command}")
+            x = __send__("inline_#{command}", "\0")
+          else
+            error "#{s1}#{echar_}: inline command not found."
+          end
+          stag, etag = x.split("\0", 2)
+          buf << stag
+          if _raw_inline_command?(command)
+            errmsg = _parse_inline_commands(en, buf, echar_) {|text| text }
+          else
+            errmsg = _parse_inline_commands(en, buf, echar_, &b)
+          end
+          if errmsg
+            error "#{s1}#{echar_}: #{errmsg}"
+          end
+          buf << etag
+        elsif s2
+          if echar == '}'
+            buf << (yield s2[1..-1])
+          else
+            buf << (yield s2)
+          end
+        elsif s3
+          if echar && echar == s3
+            return
+          else
+            buf << (yield s3)
+          end
+        else
+          echar.nil?  or
+            return "inline command not closed."
+          return
+        end
+      end
+    end
+
+    def _raw_inline_command?(cmd)
+      return cmd == 'm'
+    end
+
     def _build_caption_str(id, caption)
       str = ""
       with_context(:caption) do
@@ -262,6 +448,435 @@ module ReVIEW
 
     public
 
+    ## テーブル
+    def table(lines, id=nil, caption=nil, option=nil)
+      opts = _table_options(option) { "//table[#{id}][#{caption}]" }
+      rows = _table_parse(lines, opts) { "//table[#{id}][#{caption}]" }
+      return if rows.empty?
+      #
+      opts[:pos] = 'H' if ! opts[:pos] && ! _positioning_allowed_here?()
+      #
+      header_rows, has_header = _table_split_header(rows, opts)
+      rows = adjust_n_cols(rows)
+      #
+      if opts[:hline] != nil  ; hline_default = opts[:hline]
+      #elsif opts[:csv]       ; hline_default = false
+      else                    ; hline_default = true
+      end
+      header_ncols = opts[:headercols] || (has_header ? 0 : 1)
+      #
+      _table_before(id, caption, opts)
+      table_header(id, caption, opts)
+      table_begin(rows.first.length, fontsize: opts[:fontsize])
+      _render_table_rows(rows, header_rows,
+                         header_ncols: header_ncols,
+                         hline_default: hline_default)
+      _table_bottom(hline: !hline_default)
+      table_end()
+      _table_after(id, caption, opts)
+    end
+
+    def _table_parse(lines, opts, &b)
+      content = nil
+      if opts[:file]
+        content = _table_readfile(opts[:file], encoding: opts[:encoding], &b)
+        opts[:csv] ||= (opts[:file] =~ /\.csv\z/i)
+        lines = content.each_line unless opts[:csv]
+      else
+        content = lines.join() if opts[:csv]
+      end
+      rows = opts[:csv] ? _table_parse_csv(content) \
+                        : _table_parse_txt(lines)
+      return rows
+    end
+
+    def _table_parse_txt(lines)
+      rows = []
+      sepidx = nil
+      rows = lines.map {|line|
+        line.strip.split(/\t+/).map {|s| s.sub(/\A\./, '') }
+      }
+      return rows
+    end
+
+    def _table_parse_csv(csvstr)
+      rows = CSV.parse(csvstr)
+      return rows
+    end
+
+    def _table_readfile(filename, encoding: 'utf-8')
+      _table_checkfile(filename)
+      encoding ||= 'utf-8'
+      Encoding.find(encoding)  or
+        error(yield + "[encoding=#{encoding}]: unknown encoding.")
+      #
+      return File.read(filename, encoding: "#{encoding}:UTF-8")
+    end
+
+    def _table_checkfile(filename)
+      File.exist?(filename)  or
+        error(yield + "[file=#{filename}]: file not found.")
+      File.file?(filename)  or
+        error(yield + "[file=#{filename}]: not a file.")
+      File.readable?(filename)  or
+        error(yield + "[file=#{filename}]: file not readable (permission denied).")
+    end
+
+    def _table_split_header(rows, opts)
+      has_header  = true
+      top_nlines = 3  # 最初の3行以内にヘッダ区切りがあるか調べる
+      if opts[:headerrows]
+        header_rows = rows.shift(opts[:headerrows])
+      elsif (sepidx = _table_headerline_index(rows, top_nlines))
+        header_rows = rows.shift(sepidx)
+        rows.shift  # ignore separator
+      else
+        header_rows = nil
+        has_header  = false
+      end
+      return header_rows, has_header
+    end
+
+    def _table_headerline_index(rows, top_nlines=3)
+      top_nlines.times do |i|
+        return i if rows[i] && _table_headerlinerow?(rows[i])
+      end
+      return nil
+    end
+
+    def _table_headerlinerow?(row)
+      return false if row.empty?
+      #return true if row.all? {|s| !s.present? }
+      return true if _table_headerline?(row[0]) && \
+                     row[1..-1].all? {|s| !s.present? }
+      return false
+    end
+
+    def _table_headerline?(line)
+      return line =~ /\A={12,}\z/ || line =~ /\A-{12,}\z/
+    end
+
+    def _table_hline?(row)
+      return true if row.empty?
+      return true if row.all? {|s| !s.present? }
+      #return true if row[0] =~ /\A-----+\z/ && \
+      #               row[1..-1].all? {|s| !s.present? }
+      return false
+    end
+
+    def _render_table_rows(rows, header_rows=nil, header_ncols: 0, hline_default: true)
+      if header_rows
+        n = header_rows.length - 1
+        header_rows.each_with_index do |row, i|
+          cells = row.map {|s| th(compile_inline(s)) }
+          puts _table_tr(cells, hline: n == i)
+        end
+      end
+      flags = rows.map {|row| _table_hline?(row) || nil }
+      rows.each_with_index do |row, i|
+        next if flags[i]   # skip '-----'
+        cells = row.map {|s| compile_inline(s) }
+        if header_ncols == 0
+          cells = cells.map {|s| td(s) }
+        elsif header_ncols == 1
+          cells = [th(cells.shift)] + cells.map {|s| td(s) }
+        else
+          n = header_ncols
+          cells = cells.shift(n).map {|s| th(s) } + cells.map {|s| td(s) }
+        end
+        hline = hline_default ? true : flags[i+1]
+        puts _table_tr(cells, hline: hline)
+      end
+    end
+
+    def _table_options(option_str, &b)
+      opts = {}
+      return opts unless option_str.present?
+      _each_block_option(option_str) do |k, v|
+        case k
+        when 'file'
+          v.present?  or
+            error(yield + "[#{k}=]: filename required.")
+          opts[:file] = v
+        when 'encoding'
+          v.present?  or
+            error(yield + "[#{k}=]: encoding name required.")
+          opts[:encoding] = v
+        when 'csv', 'hline'
+          sym = k.intern
+          if ! v.present?  ; opts[sym] = true
+          elsif v == 'on'  ; opts[sym] = true
+          elsif v == 'off' ; opts[sym] = false
+          else
+            error(yield + "[#{k}=#{v}]: 'on' or 'off' expected.")
+          end
+        when 'pos'
+          _validate_positioning_option(k, v, &b)
+          opts[:pos] = v
+        when 'fontsize'
+          case v
+          when 'small', 'x-small', 'xx-small'
+          when 'large', 'x-large', 'xx-large'
+          when 'medium'
+          else
+            error(yield + "[#{k}=#{v}]: invalid font size.")
+          end
+          opts[:fontsize] = v
+        when 'headerrows', 'headercols'
+          v =~ /\A\d+\z/  or
+            error(yield + "[#{k}=#{v}]: integer expected.")
+          opts[k.intern] = v.to_i
+        else
+          error(yield + "[#{k}=#{v}]: unknown option.")
+        end
+      end
+      return opts
+    end
+
+    def _table_before(id, caption, opts)
+    end
+
+    def _table_after(id, caption, opts)
+    end
+
+    def _table_bottom(hline: false)
+      nil
+    end
+
+    def _table_tr(cells, hline: false)
+      tr(cells)
+    end
+
+    def _table_th(x)
+      th(x)
+    end
+
+    def _table_td(x)
+      td(x)
+    end
+
+    public
+
+    ## ブロック命令を上書き
+
+    def tsize(target, str=nil)
+      ## //tsize[|latex||lcr|]  ← Re:VIEW original
+      ## //tsize[latex][|lcr|]  ← Starter extended
+      if str.nil?
+        if target =~ /\A\|([^\|]*)\|(.*)/
+          target, str = $1, $2
+        else
+          target, str = nil, target
+        end
+      end
+      if target.nil? || target.empty? || target == '*'
+        @tsize = str
+      else
+        builders = target.split(',').map {|x| x.strip }
+        c = self.class.to_s.gsub('ReVIEW::', '').gsub('Builder', '').downcase
+        @tsize = str if builders.include?(c)
+      end
+    end
+
+    ## //imgtable
+    def imgtable(lines, id, caption=nil, option=nil)
+      @chapter.image(id).bound?  or
+        error "//imgtable[#{id}]: image not found."
+      opts, metric = _imgtable_parse_options(option) { "//imgtable[#{id}][#{caption}]" }
+      opts['pos'] = 'H' if ! opts['pos'] && ! _positioning_allowed_here?()
+      _render_imgtable(id, caption, opts) do
+        with_context(:caption) do
+          _render_imgtable_caption(caption)
+        end
+        _render_imgtable_label(id)
+        imgtable_image(id, caption, metric)
+      end
+    end
+
+    def _imgtable_parse_options(option_str, &b)
+      opts = {}; metric = []
+      _each_block_option(option_str) do |k, v|
+        case k
+        when 'pos'
+          _validate_positioning_option(k, v, &b)
+          opts[k] = v
+        else
+          metric << (v ? "#{k}=#{v}" : k)
+        end
+      end
+      return opts, metric.join()
+    end
+
+    def _render_imgtable(id, caption, opts)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented.")
+    end
+
+    def _render_imgtable_caption(caption)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented.")
+    end
+
+    def _render_imgtable_label(id)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented.")
+    end
+
+    ## 章 (Chapter) の概要
+    def on_abstract_block()
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented.")
+    end
+
+    ## 章 (Chapter) の著者
+    def on_chapterauthor_block(name)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented.")
+    end
+
+    ## 会話リスト
+    def on_talklist_block(option=nil, &b)
+      opts = _talklist_parse_options(option) { "//talklist" }
+      _render_talklist(opts) do
+        yield
+      end
+    end
+
+    def _talklist_parse_options(option_str, &b)
+      opts = {}
+      _each_block_option(option_str) do |k, v|
+        case k
+        when 'indent'
+        when 'imagewidth'
+        when 'imageheight'
+        when 'needvspace'
+        when 'itemmargin'
+        when 'listmargin'
+        #
+        when 'imageborder'
+          case v
+          when nil   ;  v = true
+          when 'on'  ;  v = true
+          when 'off' ;  v = false
+          else
+            raise "#{yield}[#{k}=#{v}]: unexpected value; 'on' or 'off' expected."
+          end
+        #
+        when 'separator', 'itemstart', 'itemend'
+          case v
+          when /\A"(.*)"\z/  ; v = $1
+          when /\A'(.*)'\z/  ; v = $1
+          end
+        #
+        when 'classname'
+        else
+          error "#{yield}[#{k}=#{v}]: unknown talklist option."
+        end
+        opts[k.intern] = v
+      end
+      return opts
+    end
+
+    ## 会話項目
+    def on_talk_block(imagefile, name=nil, text=nil, &b)
+      if imagefile.present?
+        imgpath = find_image_filepath(imagefile)  or
+          error "//talk[#{imagefile}]: image file not found."
+      else
+        imgpath = nil
+      end
+      _render_talk(imgpath, name) do
+        if text.nil?
+          yield
+        else
+          puts ""
+          puts compile_inline(text)
+        end
+      end
+    end
+
+    ## 会話項目（ショートカット用）
+    def on_t_block(key, text=nil, &b)
+      dict = self.config_starter['talk_shortcuts']  or
+        error "//t[#{key}]: missing 'talk_shortcuts:' setting in 'config-starter.yml'."
+      item = dict[key]  or
+        error "//t[#{key}]: key not registered in 'config-starter.yml'."
+      on_talk_block(item['image'], item['name'], text, &b)
+    end
+
+    ## キーと説明文のリスト
+    def on_desclist_block(option=nil, &b)
+      opts = _desclist_parse_option(option) { "//desclist" }
+      _render_desclist(opts) do
+        yield
+      end
+    end
+
+    def _desclist_parse_option(option_str)
+      opts = {}
+      return opts unless option_str.present?
+      _each_block_option(option_str) do |k, v|
+        case k
+        when 'indent', 'space', 'listmargin', 'itemmargin'
+          v.present?  or
+            error "[#{k}]: value required."
+        when 'bold', 'compact'
+          case v
+          when nil, ''  ; v = true
+          when 'on'     ; v = true
+          when 'off'    ; v = false
+          else
+            error yield + "[#{k}=#{v}]: expected 'on' or 'off'."
+          end
+        when 'classname'
+        else
+          error yield + "[#{k}]: unknown option."
+        end
+        opts[k.intern] = v
+      end
+      return opts
+    end
+
+    ## キーと値
+    def on_desc_block(key, text=nil, &b)
+      _render_desc(key) do
+        if text.nil?
+          yield
+        else
+          #puts ""
+          puts compile_inline(text)
+        end
+      end
+    end
+
+    ## 縦方向の空きを入れる
+    def vspace(target, size)
+      if _current_builder?(target)
+        _render_vspace(size)
+      end
+    end
+
+    def addvspace(target, size)
+      if _current_builder?(target)
+        _render_addvspace(size)
+      end
+    end
+
+    def _current_builder?(target)
+      return true if target.nil? || target.empty?
+      return true if target == '*'
+      c = self.class.to_s.gsub('ReVIEW::', '').gsub('Builder', '').downcase
+      return target.split(',').any? {|x| x.strip == c }
+    end
+
+    ## 縦方向のスペースがなければ改ページ
+    def needvspace(target_name, height)
+      if _current_target?(target_name)
+        _render_needvspace(height)
+      end
+    end
+
+    ## 生コード埋め込み
+    def embed(lines, target=nil)
+      yes = _current_target?(target)
+      puts lines.join() if yes
+    end
+
     ## インライン命令のバグ修正
 
     def inline_raw(str)
@@ -451,6 +1066,230 @@ module ReVIEW
       return ReVIEW::Book::ImageFinder.new(imagedir, chap_id, builder, types)
     end
 
+    public
+
+    ## 画像ファイルが見つからなければエラーとするよう変更
+    def image(lines, id, caption, option=nil)
+      image = @chapter.image(id)
+      image.bound?  or
+        error "//image[#{id}]: image not found."
+      image_filepath = image.path
+      opts = _image_parse_options(option) { "//image[#{id}][#{caption}]" }
+      opts[:pos] = 'H' if ! opts[:pos] && ! _positioning_allowed_here?()
+      _render_image(id, image.path, caption, opts)
+    end
+
+    def _render_image(id, image_filepath, caption, opts)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
+    end
+
+    def _image_parse_options(option_str, &b)
+      opts = {}
+      _each_block_option(option_str) do |k, v|
+        case k
+        when 'pos'
+          _validate_positioning_option(k, v, &b)
+        when 'border', 'draft'
+          case v
+          when nil  ; v = true
+          when 'on' ; v = true
+          when 'off'; v = false
+          else
+            error "#{yield}[#{k}=#{v}]: expected '#{k}=on' or '#{k}=off'"
+          end
+        when 'scale'
+          case v
+          when /\A\d+\.\d*\z/, /\A\.\d+\z/
+          when /\A\d+(\.\d+)?%\z/
+          else
+            error "#{yield}[#{k}=#{v}]: invalid scale value."
+          end
+        when 'width'
+          case v
+          when /\A[\d.]+\z/
+            error "#{yield}[#{k}=#{v}]: unit of measure required (for example: 80%, 200px, 50mm)."
+          end
+        when 'style'
+          if v =~ /\A"(.*?)"\z/ || v =~ /\A'(.*?)'\z/
+            v = $1
+          end
+        when 'class'
+        else
+          error "#{yield}[#{k}=#{v}]: unknown image option."
+        end
+        opts[k.intern] = v
+      end
+      return opts
+    end
+
+    def _validate_positioning_option(k, v, &b)
+      v.present?  or
+        error "#{yield}[#{k}=]: position char required."
+      _positioning_allowed_here?() || v == 'H'  or
+        error "#{yield}[#{k}=#{v}]: positioning not allowed here; please remove `pos=#{v}' option, or use `pos=H' instead."
+      v =~ /\A[hHtbp]+\z/  or  # H: Here, h: here, t: top, b: bottom, p: page
+        error "#{yield}[#{k}=#{v}]: contains invalid char (availables: 'h', 'H', 't', 'b', 'p', or combination of them)."
+    end
+
+    def _positioning_allowed_here?
+      return true  if within_context?(:note)       # //note の中はOK
+      return false if within_context?(:minicolumn) # //info や //caution の中はダメ
+      return false if within_context?(:column)     # ==[column] の中はダメ
+      return true                                  # それ以外はOK
+    end
+
+    ## LaTeXでは「``」と「''」で囲み、HTMLでは「“」と「”」で囲む
+    def on_inline_qq()
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented.")
+    end
+
+    ## 索引に載せる用語（@<term>{}, @<idx>{}, @<hidx>{}）
+    def inline_idx(str)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
+    end
+    def inline_hidx(str)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
+    end
+    def inline_term(str)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
+    end
+    def inline_termnoidx(str)
+      raise NotImplementedError.new("#{self.class.name}##{__method__}(): not implemented yet.")
+    end
+    def parse_term(str, placeholder_str)
+      @terms_dict ||= {}   # key: term, value: yomigana
+      #
+      see = nil
+      if str =~ %r`==>>(.*?)\z`
+        str = $`
+        see = $1
+      end
+      #
+      display_str = ""
+      tmpchar = "\x08"
+      placeholder_rexp = TERM_PLACEHOLDER_REXP   # /---/
+      str.split('<<>>').each do |item|
+        if item =~ /\(\((.*?)\)\)\z/
+          term = $`
+          yomi = $1
+          @terms_dict[term] = yomi   # may override existing key
+        elsif @terms_dict[item]
+          term = item
+          yomi = @terms_dict[item]
+        else
+          term = item
+          yomi = _find_yomi(term)
+          @terms_dict[term] = yomi
+        end
+        if ! display_str.empty? && term =~ placeholder_rexp
+          display_str = compile_inline(term.gsub(placeholder_rexp, tmpchar)).gsub(tmpchar, display_str)
+        else
+          display_str += compile_inline(term)
+        end
+        term_e = compile_inline(term.gsub(placeholder_rexp, tmpchar))
+        term_e = escape_index(term_e).gsub(tmpchar, placeholder_str)
+        yield term, term_e, yomi
+      end
+      return display_str, see
+    end
+    protected :parse_term
+
+    TERM_PLACEHOLDER_REXP = /---/
+
+    def _find_yomi(term)
+      if @index_db
+        yomi = @index_db[term]
+        return yomi if yomi
+      end
+      return nil  if term =~ /\A[[:ascii:]]+\Z/ || @index_mecab.nil?
+      return _to_yomigana(term)
+    end
+    private :_find_yomi
+
+    def _to_yomigana(term)
+      return NKF.nkf('-w --hiragana', @index_mecab.parse(term).force_encoding('UTF-8').chomp)
+    end
+    private :_to_yomigana
+
+    def escape_index(str)
+      str
+    end
+
+    ## キーを単語へ展開する（@<w>{}, @<wb>{}, @<W>{}）
+    def inline_w(str)
+      key = str
+      @words_dict ||= _load_words_file(@book.config['words_file'], key)
+      unless @words_dict.key?(key)
+        filenames = [@book.config['words_file']].flatten
+        error "@<w>{#{key}}: key '#{key}' not found in words file (#{filenames.join(', ')})."
+      end
+      return escape(@words_dict[key])
+    end
+
+    def inline_wb(str)
+      inline_b(inline_w(str))
+    end
+
+    def inline_W(str)
+      inline_strong(inline_w(str))
+    end
+
+    private
+
+    def _load_words_file(words_files, key)
+      words_files.present?  or
+        error "`@<w>{#{key}}`: `words_file:` not configured in config.yml."
+      filepaths = [words_files].flatten.compact
+      filepaths.each do |filepath|
+        _validate_words_file(filepath, key)
+      end
+      #
+      dict = {}
+      filepaths.each do |filepath|
+        case filepath
+        when /\.csv/i
+          _load_words_file_csv(filepath, dict)
+        when /\.tsv/i, /\.txt/i
+          _load_words_file_txt(filepath, dict)
+        else
+          raise "uneachable: filepath=#{filepath.inspect}"
+        end
+      end
+      return dict
+    end
+
+    def _validate_words_file(filepath, key)
+      File.exist?(filepath)  or
+        error "`@<w>{#{key}}`: words file `#{filepath}` not found."
+      File.file?(filepath)  or
+        error "`@<w>{#{key}}`: words file `#{filepath}` should be a file, but not."
+      File.readable?(filepath)  or
+        error "`@<w>{#{key}}`: cannot read words file `#{filepath}`."
+      filepath =~ /\.(csv|tsv|txt)/i  or
+        error "`@<w>{#{key}}`: words file `#{filepath}` should be *.csv, *.tsv, or *.txt."
+    end
+
+    def _load_words_file_csv(filepath, dict)
+      require 'csv'
+      CSV.read(filepath, :encoding=>'utf-8').each do |row|
+        next if row.length < 2
+        key, val, = row
+        dict[key] = val if key.present? && val.present?
+      end
+      return dict
+    end
+
+    def _load_words_file_txt(filepath, dict)
+      File.open(filepath, :encoding=>'utf-8') do |f|
+        f.each do |line|
+          next if line =~ /\A\#/
+          key, val, = line.chomp.split(/\t+/)
+          dict[key] = val if key.present? && val.present?
+        end
+      end
+      return dict
+    end
+
   end
 
 
@@ -482,7 +1321,7 @@ module ReVIEW
             end_  = $2 ? $2.to_i : inf
             @ranges << (start..end_)
           else
-            raise ArgumentError.new("'#{strpat}': invalid lineno format")
+            raise ArgumentError.new("'#{arg}': invalid lineno format")
           end
         end
       end