review 4.2.0 → 5.0.0

data/lib/review/book/index/item.rb

@@ -32,7 +32,13 @@ module ReVIEW
         alias_method :content, :caption
 
         def path
-          @path ||= @index.find_path(id)
+          if @path
+            return @path
+          end
+
+          @path = @index.find_path(@id)
+
+          @path
         end
       end
     end

data/lib/review/book/part.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2009-2019 Minero Aoki, Kenshi Muto
+# Copyright (c) 2009-2020 Minero Aoki, Kenshi Muto, Masayoshi Takahashi
 #               2002-2008 Minero Aoki
 #
 # This program is free software.
@@ -6,13 +6,11 @@
 # the GNU LGPL, Lesser General Public License version 2.1.
 # For details of the GNU LGPL, see the file "COPYING".
 #
-require 'review/book/compilable'
+require 'review/book/book_unit'
 
 module ReVIEW
   module Book
-    class Part
-      include Compilable
-
+    class Part < BookUnit
       def self.mkpart_from_namelistfile(book, path)
         chaps = []
         File.read(path, mode: 'rt:BOM|utf-8').split.each_with_index do |name, number|
@@ -30,7 +28,7 @@ module ReVIEW
       end
 
       def self.mkpart(chaps)
-        chaps.empty? ? nil : Part.new(self, nil, chaps)
+        chaps.empty? ? nil : Part.new(chaps[0].book, nil, chaps)
       end
 
       # if Part is dummy, `number` is nil.
@@ -38,15 +36,16 @@ module ReVIEW
       def initialize(book, number, chapters, name = '', io = nil)
         @book = book
         @number = number
-        @chapters = chapters
         @name = name
+        @chapters = chapters
         @path = name
-        @content = ''
         if io
           @content = io.read
         elsif @path.present? && File.exist?(File.join(@book.config['contentdir'], @path))
           @content = File.read(File.join(@book.config['contentdir'], @path), mode: 'rt:BOM|utf-8')
-          @name = File.basename(@name, '.re')
+          @name = File.basename(name, '.re')
+        else
+          @content = ''
         end
         if file?
           @title = nil
@@ -54,6 +53,19 @@ module ReVIEW
           @title = name
         end
         @volume = nil
+
+        super()
+      end
+
+      def generate_indexes
+        super
+
+        return unless content
+
+        @numberless_image_index = @indexes.numberless_image_index
+        @image_index = @indexes.image_index
+        @icon_index = @indexes.icon_index
+        @indepimage_index = @indexes.indepimage_index
       end
 
       attr_reader :number

data/lib/review/book/volume.rb

@@ -22,7 +22,7 @@ module ReVIEW
       end
 
       def self.sum(vols)
-        vols.inject(new) { |sum, i| sum + i }
+        vols.inject(new) { |sum, i| sum + i } # rubocop:disable Performance/Sum
       end
 
       def self.dummy

data/lib/review/builder.rb

@@ -11,7 +11,6 @@ require 'review/textutils'
 require 'review/compiler'
 require 'review/sec_counter'
 require 'stringio'
-require 'cgi'
 require 'fileutils'
 require 'tempfile'
 require 'csv'
@@ -20,7 +19,7 @@ module ReVIEW
   class Builder
     include TextUtils
 
-    CAPTION_TITLES = %w[note memo tip info warning important caution notice].freeze
+    CAPTION_TITLES = Compiler.minicolumn_names
 
     def pre_paragraph
       nil
@@ -30,21 +29,17 @@ module ReVIEW
       nil
     end
 
-    attr_accessor :doc_status
+    attr_accessor :doc_status, :previous_list_type
 
-    def initialize(strict = false, *args)
+    def initialize(strict = false, *_args)
       @strict = strict
       @output = nil
       @logger = ReVIEW.logger
       @doc_status = {}
       @dictionary = {}
-      builder_init(*args)
+      @previous_list_type = nil
     end
 
-    def builder_init(*args)
-    end
-    private :builder_init
-
     def bind(compiler, chapter, location)
       @compiler = compiler
       @chapter = chapter
@@ -53,6 +48,10 @@ module ReVIEW
       if @chapter.present?
         @book = @chapter.book
       end
+      @chapter.generate_indexes
+      if @book
+        @book.generate_indexes
+      end
       @tabwidth = nil
       @tsize = nil
       if @book && @book.config
@@ -84,6 +83,7 @@ module ReVIEW
 
     def builder_init_file
       @sec_counter = SecCounter.new(5, @chapter)
+      @doc_status = {}
     end
     private :builder_init_file
 
@@ -91,8 +91,19 @@ module ReVIEW
       false
     end
 
+    def solve_nest(s)
+      check_nest
+      s.gsub(/\x01→.+?←\x01/, '')
+    end
+
+    def check_nest
+      if @children && !@children.empty?
+        error "//beginchild of #{@children.reverse.join(',')} misses //endchild"
+      end
+    end
+
     def result
-      @output.string
+      solve_nest(@output.string)
     end
 
     alias_method :raw_result, :result
@@ -211,7 +222,7 @@ module ReVIEW
       sepidx = nil
       rows = []
       lines.each_with_index do |line, idx|
-        if /\A[\=\-]{12}/ =~ line || /\A[\=\{\-\}]{12}/ =~ line
+        if /\A[=\-]{12}/ =~ line || /\A[={\-}]{12}/ =~ line
           sepidx ||= idx
           next
         end
@@ -240,7 +251,7 @@ module ReVIEW
 
     def adjust_n_cols(rows)
       rows.each do |cols|
-        while cols.last and cols.last.strip.empty?
+        while cols.last && cols.last.strip.empty?
           cols.pop
         end
       end
@@ -544,9 +555,36 @@ module ReVIEW
     CAPTION_TITLES.each do |name|
       class_eval %Q(
         def #{name}(lines, caption = nil)
+          check_nested_minicolumn
           captionblock("#{name}", lines, caption)
         end
-      )
+
+        def #{name}_begin(caption = nil)
+          check_nested_minicolumn
+          @doc_status[:minicolumn] = '#{name}'
+          if caption
+            puts compile_inline(caption)
+          end
+        end
+
+        def #{name}_end
+          @doc_status[:minicolumn] = nil
+        end
+      ), __FILE__, __LINE__ - 17
+    end
+
+    def check_nested_minicolumn
+      if @doc_status[:minicolumn]
+        error "#{@location}: nested mini-column is not allowed"
+      end
+    end
+
+    def in_minicolumn?
+      @doc_status[:minicolumn]
+    end
+
+    def minicolumn_block_name?(name)
+      CAPTION_TITLES.include?(name)
     end
 
     def graph(lines, id, command, caption = '')
@@ -687,6 +725,23 @@ EOTGNUPLOT
       str
     end
 
+    def beginchild
+      @children ||= []
+      unless @previous_list_type
+        error "//beginchild is shown, but previous element isn't ul, ol, or dl"
+      end
+      puts "\x01→#{@previous_list_type}←\x01"
+      @children.push(@previous_list_type)
+    end
+
+    def endchild
+      if @children.nil? || @children.empty?
+        error "//endchild is shown, but any opened //beginchild doesn't exist"
+      else
+        puts "\x01→/#{@children.pop}←\x01"
+      end
+    end
+
     def caption_top?(type)
       unless %w[top bottom].include?(@book.config['caption_position'][type])
         warn("invalid caption_position/#{type} parameter. 'top' is assumed")

data/lib/review/catalog.rb

@@ -41,7 +41,7 @@ module ReVIEW
 
     def replace_part(old_name, new_name)
       @yaml['CHAPS'].map! do |e|
-        if e.is_a?(Hash) and (e.keys.first == old_name)
+        if e.is_a?(Hash) && (e.keys.first == old_name)
           e = { new_name => e.values.first }
         end
         e
@@ -89,7 +89,7 @@ module ReVIEW
         filenames.concat(postdef)
       end
       filenames.each do |filename|
-        refile = File.join(basedir, config['contentdir'], filename)
+        refile = File.expand_path(File.join(config['contentdir'], filename), basedir)
         unless File.exist?(refile)
           raise FileNotFound, "file not found in catalog.yml: #{refile}"
         end

data/lib/review/compiler.rb

@@ -14,8 +14,8 @@ require 'strscan'
 
 module ReVIEW
   class Compiler
-    def initialize(strategy)
-      @strategy = strategy
+    def initialize(builder)
+      @builder = builder
 
       ## commands which do not parse block lines in compiler
       @non_parsed_commands = %i[embed texequation graph]
@@ -24,10 +24,15 @@ module ReVIEW
       @command_name_stack = []
     end
 
-    attr_reader :strategy
+    attr_reader :builder, :previous_list_type
+
+    def strategy
+      error 'Compiler#strategy is obsoleted. Use Compiler#builder.'
+      @builder
+    end
 
     def non_escaped_commands
-      if @strategy.highlight?
+      if @builder.highlight?
         %i[list emlist listnum emlistnum cmd]
       else
         []
@@ -37,7 +42,7 @@ module ReVIEW
     def compile(chap)
       @chapter = chap
       do_compile
-      @strategy.result
+      @builder.result
     end
 
     class SyntaxElement
@@ -68,12 +73,16 @@ module ReVIEW
         end
       end
 
+      def minicolumn?
+        @type == :minicolumn
+      end
+
       def block_required?
-        @type == :block
+        @type == :block or @type == :minicolumn
       end
 
       def block_allowed?
-        @type == :block or @type == :optional
+        @type == :block or @type == :optional or @type == :minicolumn
       end
     end
 
@@ -83,6 +92,10 @@ module ReVIEW
       defsyntax(name, (optional ? :optional : :block), argc, &block)
     end
 
+    def self.defminicolumn(name, argc, _optional = false, &block)
+      defsyntax(name, :minicolumn, argc, &block)
+    end
+
     def self.defsingle(name, argc, &block)
       defsyntax(name, :line, argc, &block)
     end
@@ -95,6 +108,16 @@ module ReVIEW
       INLINE[name] = InlineSyntaxElement.new(name)
     end
 
+    def self.minicolumn_names
+      buf = []
+      SYNTAX.each do |name, syntax|
+        if syntax.minicolumn?
+          buf << name.to_s
+        end
+      end
+      buf
+    end
+
     def syntax_defined?(name)
       SYNTAX.key?(name.to_sym)
     end
@@ -143,18 +166,19 @@ module ReVIEW
     defblock :bpo, 0
     defblock :flushright, 0
     defblock :centering, 0
-    defblock :note, 0..1
-    defblock :memo, 0..1
-    defblock :info, 0..1
-    defblock :important, 0..1
-    defblock :caution, 0..1
-    defblock :notice, 0..1
-    defblock :warning, 0..1
-    defblock :tip, 0..1
     defblock :box, 0..1
     defblock :comment, 0..1, true
     defblock :embed, 0..1
 
+    defminicolumn :note, 0..1
+    defminicolumn :memo, 0..1
+    defminicolumn :tip, 0..1
+    defminicolumn :info, 0..1
+    defminicolumn :warning, 0..1
+    defminicolumn :important, 0..1
+    defminicolumn :caution, 0..1
+    defminicolumn :notice, 0..1
+
     defsingle :footnote, 2
     defsingle :noindent, 0
     defsingle :blankline, 0
@@ -167,6 +191,8 @@ module ReVIEW
     defsingle :include, 1
     defsingle :olnum, 1
     defsingle :firstlinenum, 1
+    defsingle :beginchild, 0
+    defsingle :endchild, 0
 
     definline :chapref
     definline :chap
@@ -231,39 +257,62 @@ module ReVIEW
 
     def do_compile
       f = LineInput.new(StringIO.new(@chapter.content))
-      @strategy.bind(self, @chapter, Location.new(@chapter.basename, f))
+      @builder.bind(self, @chapter, Location.new(@chapter.basename, f))
+
+      ## in minicolumn, such as note/info/alert...
+      @minicolumn_name = nil
 
       tagged_section_init
       while f.next?
         case f.peek
         when /\A\#@/
           f.gets # Nothing to do
-        when /\A=+[\[\s\{]/
+        when /\A=+[\[\s{]/
           compile_headline(f.gets)
+          @builder.previous_list_type = nil
         when /\A\s+\*/
           compile_ulist(f)
+          @builder.previous_list_type = 'ul'
         when /\A\s+\d+\./
           compile_olist(f)
+          @builder.previous_list_type = 'ol'
         when /\A\s+:\s/
           compile_dlist(f)
+          @builder.previous_list_type = 'dl'
         when /\A\s*:\s/
           warn 'Definition list starting with `:` is deprecated. It should start with ` : `.'
           compile_dlist(f)
+          @builder.previous_list_type = 'dl'
         when %r{\A//\}}
-          f.gets
-          error 'block end seen but not opened'
+          if in_minicolumn?
+            _line = f.gets
+            compile_minicolumn_end
+          else
+            f.gets
+            error 'block end seen but not opened'
+          end
         when %r{\A//[a-z]+}
-          # @command_name_stack.push(name) ## <- move into read_command() to use name
-          name, args, lines = read_command(f)
-          syntax = syntax_descriptor(name)
-          unless syntax
-            error "unknown command: //#{name}"
-            compile_unknown_command(args, lines)
+          line = f.peek
+          matched = line =~ %r|\A//([a-z]+)(:?\[.*\])?{\s*$|
+          if matched && minicolumn_block_name?($1)
+            line = f.gets
+            name = $1
+            args = parse_args(line.sub(%r{\A//[a-z]+}, '').rstrip.chomp('{'), name)
+            compile_minicolumn_begin(name, *args)
+          else
+            # @command_name_stack.push(name) ## <- move into read_command() to use name
+            name, args, lines = read_command(f)
+            syntax = syntax_descriptor(name)
+            unless syntax
+              error "unknown command: //#{name}"
+              compile_unknown_command(args, lines)
+              @command_name_stack.pop
+              next
+            end
+            compile_command(syntax, args, lines)
             @command_name_stack.pop
-            next
           end
-          compile_command(syntax, args, lines)
-          @command_name_stack.pop
+          @builder.previous_list_type = nil
         when %r{\A//}
           line = f.gets
           warn "`//' seen but is not valid command: #{line.strip.inspect}"
@@ -271,17 +320,46 @@ module ReVIEW
             warn 'skipping block...'
             read_block(f, false)
           end
+          @builder.previous_list_type = nil
         else
           if f.peek.strip.empty?
             f.gets
             next
           end
           compile_paragraph(f)
+          @builder.previous_list_type = nil
         end
       end
       close_all_tagged_section
     end
 
+    def compile_minicolumn_begin(name, caption = nil)
+      mid = "#{name}_begin"
+      unless @builder.respond_to?(mid)
+        error "strategy does not support minicolumn: #{name}"
+      end
+
+      if @minicolumn_name
+        error "minicolumn cannot be nested: #{name}"
+        return
+      end
+      @minicolumn_name = name
+
+      @builder.__send__(mid, caption)
+    end
+
+    def compile_minicolumn_end
+      unless @minicolumn_name
+        error "minicolumn is not used: #{name}"
+        return
+      end
+      name = @minicolumn_name
+
+      mid = "#{name}_end"
+      @builder.__send__(mid)
+      @minicolumn_name = nil
+    end
+
     def compile_headline(line)
       @headline_indexs ||= [@chapter.number.to_i - 1]
       m = /\A(=+)(?:\[(.+?)\])?(?:\{(.+?)\})?(.*)/.match(line)
@@ -317,18 +395,18 @@ module ReVIEW
         end
         @headline_indexs[index] += 1
         close_current_tagged_section(level)
-        @strategy.headline(level, label, caption)
+        @builder.headline(level, label, caption)
       end
     end
 
     def close_current_tagged_section(level)
-      while @tagged_section.last and @tagged_section.last[1] >= level
+      while @tagged_section.last && (@tagged_section.last[1] >= level)
         close_tagged_section(* @tagged_section.pop)
       end
     end
 
     def headline(level, label, caption)
-      @strategy.headline(level, label, caption)
+      @builder.headline(level, label, caption)
     end
 
     def tagged_section_init
@@ -337,21 +415,21 @@ module ReVIEW
 
     def open_tagged_section(tag, level, label, caption)
       mid = "#{tag}_begin"
-      unless @strategy.respond_to?(mid)
-        error "strategy does not support tagged section: #{tag}"
+      unless @builder.respond_to?(mid)
+        error "builder does not support tagged section: #{tag}"
         headline(level, label, caption)
         return
       end
       @tagged_section.push([tag, level])
-      @strategy.__send__(mid, level, label, caption)
+      @builder.__send__(mid, level, label, caption)
     end
 
     def close_tagged_section(tag, level)
       mid = "#{tag}_end"
-      if @strategy.respond_to?(mid)
-        @strategy.__send__(mid, level)
+      if @builder.respond_to?(mid)
+        @builder.__send__(mid, level)
       else
-        error "strategy does not support block op: #{mid}"
+        error "builder does not support block op: #{mid}"
       end
     end
 
@@ -374,38 +452,38 @@ module ReVIEW
         line =~ /\A\s+(\*+)/
         current_level = $1.size
         if level == current_level
-          @strategy.ul_item_end
+          @builder.ul_item_end
           # body
-          @strategy.ul_item_begin(buf)
+          @builder.ul_item_begin(buf)
         elsif level < current_level # down
           level_diff = current_level - level
           if level_diff != 1
             error 'too many *.'
           end
           level = current_level
-          @strategy.ul_begin { level }
-          @strategy.ul_item_begin(buf)
+          @builder.ul_begin { level }
+          @builder.ul_item_begin(buf)
         elsif level > current_level # up
           level_diff = level - current_level
           level = current_level
           (1..level_diff).to_a.reverse_each do |i|
-            @strategy.ul_item_end
-            @strategy.ul_end { level + i }
+            @builder.ul_item_end
+            @builder.ul_end { level + i }
           end
-          @strategy.ul_item_end
+          @builder.ul_item_end
           # body
-          @strategy.ul_item_begin(buf)
+          @builder.ul_item_begin(buf)
         end
       end
 
       (1..level).to_a.reverse_each do |i|
-        @strategy.ul_item_end
-        @strategy.ul_end { i }
+        @builder.ul_item_end
+        @builder.ul_end { i }
       end
     end
 
     def compile_olist(f)
-      @strategy.ol_begin
+      @builder.ol_begin
       f.while_match(/\A\s+\d+\.|\A\#@/) do |line|
         next if line =~ /\A\#@/
 
@@ -414,24 +492,24 @@ module ReVIEW
         f.while_match(/\A\s+(?!\d+\.)\S/) do |cont|
           buf.push(text(cont.strip))
         end
-        @strategy.ol_item(buf, num)
+        @builder.ol_item(buf, num)
       end
-      @strategy.ol_end
+      @builder.ol_end
     end
 
     def compile_dlist(f)
-      @strategy.dl_begin
+      @builder.dl_begin
       while /\A\s*:/ =~ f.peek
         # defer compile_inline to handle footnotes
-        @strategy.doc_status[:dt] = true
-        @strategy.dt(text(f.gets.sub(/\A\s*:/, '').strip))
-        @strategy.doc_status[:dt] = nil
+        @builder.doc_status[:dt] = true
+        @builder.dt(text(f.gets.sub(/\A\s*:/, '').strip))
+        @builder.doc_status[:dt] = nil
         desc = f.break(/\A(\S|\s*:|\s+\d+\.\s|\s+\*\s)/).map { |line| text(line.strip) }
-        @strategy.dd(desc)
+        @builder.dd(desc)
         f.skip_blank_lines
         f.skip_comment_lines
       end
-      @strategy.dl_end
+      @builder.dl_end
     end
 
     def compile_paragraph(f)
@@ -440,7 +518,7 @@ module ReVIEW
         break if line.strip.empty?
         buf.push(text(line.sub(/^(\t+)\s*/) { |m| '<!ESCAPETAB!>' * m.size }.strip.gsub('<!ESCAPETAB!>', "\t")))
       end
-      @strategy.paragraph(buf)
+      @builder.paragraph(buf)
     end
 
     def read_command(f)
@@ -449,9 +527,9 @@ module ReVIEW
       ignore_inline = @non_parsed_commands.include?(name)
       @command_name_stack.push(name)
       args = parse_args(line.sub(%r{\A//[a-z]+}, '').rstrip.chomp('{'), name)
-      @strategy.doc_status[name] = true
+      @builder.doc_status[name] = true
       lines = block_open?(line) ? read_block(f, ignore_inline) : nil
-      @strategy.doc_status[name] = nil
+      @builder.doc_status[name] = nil
       [name, args, lines]
     end
 
@@ -496,8 +574,8 @@ module ReVIEW
     end
 
     def compile_command(syntax, args, lines)
-      unless @strategy.respond_to?(syntax.name)
-        error "strategy does not support command: //#{syntax.name}"
+      unless @builder.respond_to?(syntax.name)
+        error "builder does not support command: //#{syntax.name}"
         compile_unknown_command(args, lines)
         return
       end
@@ -518,11 +596,11 @@ module ReVIEW
     end
 
     def compile_unknown_command(args, lines)
-      @strategy.unknown_command(args, lines)
+      @builder.unknown_command(args, lines)
     end
 
     def compile_block(syntax, args, lines)
-      @strategy.__send__(syntax.name, (lines || default_block(syntax)), *args)
+      @builder.__send__(syntax.name, (lines || default_block(syntax)), *args)
     end
 
     def default_block(syntax)
@@ -533,7 +611,7 @@ module ReVIEW
     end
 
     def compile_single(syntax, args)
-      @strategy.__send__(syntax.name, *args)
+      @builder.__send__(syntax.name, *args)
     end
 
     def replace_fence(str)
@@ -559,7 +637,7 @@ module ReVIEW
 
     def text(str, block_mode = false)
       return '' if str.empty?
-      words = replace_fence(str).split(/(@<\w+>\{(?:[^\}\\]|\\.)*?\})/, -1)
+      words = replace_fence(str).split(/(@<\w+>\{(?:[^}\\]|\\.)*?\})/, -1)
       words.each do |w|
         if w.scan(/@<\w+>/).size > 1 && !/\A@<raw>/.match(w)
           error "`@<xxx>' seen but is not valid inline op: #{w}"
@@ -570,7 +648,7 @@ module ReVIEW
         if in_non_escaped_command? && block_mode
           result << revert_replace_fence(words.shift)
         else
-          result << @strategy.nofunc_text(revert_replace_fence(words.shift))
+          result << @builder.nofunc_text(revert_replace_fence(words.shift))
         end
         break if words.empty?
         result << compile_inline(revert_replace_fence(words.shift.gsub(/\\\}/, '}').gsub(/\\\\/, '\\')))
@@ -579,28 +657,36 @@ module ReVIEW
     rescue => e
       error e.message
     end
-    public :text # called from strategy
+    public :text # called from builder
 
     def compile_inline(str)
       op, arg = /\A@<(\w+)>\{(.*?)\}\z/.match(str).captures
       unless inline_defined?(op)
         raise CompileError, "no such inline op: #{op}"
       end
-      unless @strategy.respond_to?("inline_#{op}")
-        raise "strategy does not support inline op: @<#{op}>"
+      unless @builder.respond_to?("inline_#{op}")
+        raise "builder does not support inline op: @<#{op}>"
       end
-      @strategy.__send__("inline_#{op}", arg)
+      @builder.__send__("inline_#{op}", arg)
     rescue => e
       error e.message
-      @strategy.nofunc_text(str)
+      @builder.nofunc_text(str)
+    end
+
+    def in_minicolumn?
+      @builder.in_minicolumn?
+    end
+
+    def minicolumn_block_name?(name)
+      @builder.minicolumn_block_name?(name)
     end
 
     def warn(msg)
-      @strategy.warn msg
+      @builder.warn msg
     end
 
     def error(msg)
-      @strategy.error msg
+      @builder.error msg
     end
   end
 end # module ReVIEW