review 3.2.0 → 5.1.0

data/lib/review/call_hook.rb

@@ -0,0 +1,20 @@
+module ReVIEW
+  module CallHook
+    def call_hook(hook_name, *params, base_dir: nil)
+      maker = @config.maker
+      filename = @config.dig(maker, hook_name)
+      return unless filename
+
+      hook = File.absolute_path(filename, base_dir)
+      @logger.debug("Call #{hook_name}. (#{hook})")
+
+      return if !File.exist?(hook) || !FileTest.executable?(hook)
+
+      if ENV['REVIEW_SAFE_MODE'].to_i & 1 > 0
+        warn 'hook configuration is prohibited in safe mode. ignored.'
+      else
+        system(hook, *params)
+      end
+    end
+  end
+end

data/lib/review/catalog.rb

@@ -3,8 +3,8 @@ require 'yaml'
 module ReVIEW
   class Catalog
     def initialize(file)
-      if file.respond_to? :read
-        @yaml = YAML.load(file.read)
+      if file.respond_to?(:read)
+        @yaml = YAML.safe_load(file.read, [Date])
       else ## as Object
         @yaml = file
       end
@@ -12,12 +12,11 @@ module ReVIEW
     end
 
     def predef
-      return '' unless @yaml['PREDEF']
-      @yaml['PREDEF'].join("\n")
+      @yaml['PREDEF'] || []
     end
 
     def chaps
-      return '' unless @yaml['CHAPS']
+      return [] unless @yaml['CHAPS']
 
       @yaml['CHAPS'].map do |entry|
         if entry.is_a?(String)
@@ -25,11 +24,11 @@ module ReVIEW
         elsif entry.is_a?(Hash)
           entry.values # chaps in a part
         end
-      end.flatten.join("\n")
+      end.flatten
     end
 
     def parts
-      return '' unless @yaml['CHAPS']
+      return [] unless @yaml['CHAPS']
 
       part_list = @yaml['CHAPS'].map do |entry|
         if entry.is_a?(Hash)
@@ -37,12 +36,12 @@ module ReVIEW
         end
       end
 
-      part_list.flatten.compact.join("\n")
+      part_list.flatten.compact
     end
 
     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
@@ -51,17 +50,16 @@ module ReVIEW
 
     def parts_with_chaps
       return [] unless @yaml['CHAPS']
+
       @yaml['CHAPS'].flatten.compact
     end
 
     def appendix
-      return '' unless @yaml['APPENDIX']
-      @yaml['APPENDIX'].join("\n")
+      @yaml['APPENDIX'] || []
     end
 
     def postdef
-      return '' unless @yaml['POSTDEF']
-      @yaml['POSTDEF'].join("\n")
+      @yaml['POSTDEF'] || []
     end
 
     def to_s
@@ -71,7 +69,7 @@ module ReVIEW
     def validate!(config, basedir)
       filenames = []
       if predef.present?
-        filenames.concat(predef.split(/\n/))
+        filenames.concat(predef)
       end
       parts_with_chaps.each do |chap|
         if chap.is_a?(Hash)
@@ -86,13 +84,13 @@ module ReVIEW
         end
       end
       if appendix.present?
-        filenames.concat(appendix.split(/\n/))
+        filenames.concat(appendix)
       end
       if postdef.present?
-        filenames.concat(postdef.split(/\n/))
+        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

@@ -1,4 +1,4 @@
-# Copyright (c) 2009-2019 Minero Aoki, Kenshi Muto
+# Copyright (c) 2009-2020 Minero Aoki, Kenshi Muto
 # Copyright (c) 2002-2007 Minero Aoki
 #
 # This program is free software.
@@ -14,16 +14,37 @@ require 'strscan'
 
 module ReVIEW
   class Compiler
-    def initialize(strategy)
-      @strategy = strategy
+    MAX_HEADLINE_LEVEL = 6
+
+    def initialize(builder)
+      @builder = builder
+
+      ## commands which do not parse block lines in compiler
+      @non_parsed_commands = %i[embed texequation graph]
+
+      ## to decide escaping/non-escaping for text
+      @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 @builder.highlight?
+        %i[list emlist listnum emlistnum cmd]
+      else
+        []
+      end
+    end
 
     def compile(chap)
       @chapter = chap
       do_compile
-      @strategy.result
+      @builder.result
     end
 
     class SyntaxElement
@@ -40,6 +61,7 @@ module ReVIEW
         unless @argc_spec === args.size
           raise CompileError, "wrong # of parameters (block command //#{@name}, expect #{@argc_spec} but #{args.size})"
         end
+
         if @checker
           @checker.call(*args)
         end
@@ -54,23 +76,31 @@ 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
 
     SYNTAX = {}
 
     def self.defblock(name, argc, optional = false, &block)
-      defsyntax name, (optional ? :optional : :block), argc, &block
+      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
+      defsyntax(name, :line, argc, &block)
     end
 
     def self.defsyntax(name, type, argc, &block)
@@ -81,6 +111,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
@@ -109,7 +149,7 @@ module ReVIEW
     defblock :emlist, 0..2
     defblock :cmd, 0..1
     defblock :table, 0..2
-    defblock :imgtable, 0..2
+    defblock :imgtable, 0..3
     defblock :emtable, 0..1
     defblock :quote, 0
     defblock :image, 2..3, true
@@ -129,18 +169,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
@@ -153,6 +194,8 @@ module ReVIEW
     defsingle :include, 1
     defsingle :olnum, 1
     defsingle :firstlinenum, 1
+    defsingle :beginchild, 0
+    defsingle :endchild, 0
 
     definline :chapref
     definline :chap
@@ -217,32 +260,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\{]/
-          compile_headline f.gets
+        when /\A=+[\[\s{]/
+          compile_headline(f.gets)
+          @builder.previous_list_type = nil
         when /\A\s+\*/
-          compile_ulist f
+          compile_ulist(f)
+          @builder.previous_list_type = 'ul'
         when /\A\s+\d+\./
-          compile_olist f
+          compile_olist(f)
+          @builder.previous_list_type = 'ol'
+        when /\A\s+:\s/
+          compile_dlist(f)
+          @builder.previous_list_type = 'dl'
         when /\A\s*:\s/
-          compile_dlist f
+          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]+}
-          name, args, lines = read_command(f)
-          syntax = syntax_descriptor(name)
-          unless syntax
-            error "unknown command: //#{name}"
-            compile_unknown_command args, lines
-            next
+          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
           end
-          compile_command syntax, args, lines
+          @builder.previous_list_type = nil
         when %r{\A//}
           line = f.gets
           warn "`//' seen but is not valid command: #{line.strip.inspect}"
@@ -250,39 +323,74 @@ 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
+          compile_paragraph(f)
+          @builder.previous_list_type = nil
         end
       end
       close_all_tagged_section
+    rescue SyntaxError => e
+      error e
+    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)
       level = m[1].size
+      if level > MAX_HEADLINE_LEVEL
+        raise CompileError, "Invalid header: max headline level is #{MAX_HEADLINE_LEVEL}"
+      end
+
       tag = m[2]
       label = m[3]
       caption = m[4].strip
       index = level - 1
       if tag
-        if tag !~ %r{\A/}
-          if caption.empty?
-            warn 'headline is empty.'
-          end
-          close_current_tagged_section(level)
-          open_tagged_section(tag, level, label, caption)
-        else
+        if tag.start_with?('/')
           open_tag = tag[1..-1]
           prev_tag_info = @tagged_section.pop
           if prev_tag_info.nil? || prev_tag_info.first != open_tag
             error "#{open_tag} is not opened."
           end
           close_tagged_section(*prev_tag_info)
+        else
+          if caption.empty?
+            warn 'headline is empty.'
+          end
+          close_current_tagged_section(level)
+          open_tagged_section(tag, level, label, caption)
         end
       else
         if caption.empty?
@@ -296,18 +404,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
@@ -316,21 +424,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}"
-        headline level, label, caption
+      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
+      @tagged_section.push([tag, level])
+      @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
 
@@ -347,86 +455,94 @@ module ReVIEW
 
         buf = [text(line.sub(/\*+/, '').strip)]
         f.while_match(/\A\s+(?!\*)\S/) do |cont|
-          buf.push text(cont.strip)
+          buf.push(text(cont.strip))
         end
 
         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\#@/
 
         num = line.match(/(\d+)\./)[1]
         buf = [text(line.sub(/\d+\./, '').strip)]
         f.while_match(/\A\s+(?!\d+\.)\S/) do |cont|
-          buf.push text(cont.strip)
+          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
-        @strategy.dt text(f.gets.sub(/\A\s*:/, '').strip)
-        desc = f.break(/\A(\S|\s*:|\s+\d+\.\s|\s+\*\s)/).map { |line| text(line.strip) }
-        @strategy.dd(desc)
+        # defer compile_inline to handle footnotes
+        @builder.doc_status[:dt] = true
+        @builder.dt(text(f.gets.sub(/\A\s*:/, '').strip))
+        @builder.doc_status[:dt] = nil
+        desc = []
+        f.until_match(/\A(\S|\s*:|\s+\d+\.\s|\s+\*\s)/) do |line|
+          desc << text(line.strip)
+        end
+        @builder.dd(desc)
         f.skip_blank_lines
         f.skip_comment_lines
       end
-      @strategy.dl_end
+      @builder.dl_end
     end
 
     def compile_paragraph(f)
       buf = []
       f.until_match(%r{\A//|\A\#@}) do |line|
         break if line.strip.empty?
-        buf.push text(line.sub(/^(\t+)\s*/) { |m| '<!ESCAPETAB!>' * m.size }.strip.gsub('<!ESCAPETAB!>', "\t"))
+
+        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)
       line = f.gets
       name = line.slice(/[a-z]+/).to_sym
-      ignore_inline = (name == :embed)
+      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
 
@@ -439,12 +555,12 @@ module ReVIEW
       buf = []
       f.until_match(%r{\A//\}}) do |line|
         if ignore_inline
-          buf.push line
+          buf.push(line.chomp)
         elsif line !~ /\A\#@/
-          buf.push text(line.rstrip)
+          buf.push(text(line.rstrip, true))
         end
       end
-      unless %r{\A//\}} =~ f.peek
+      unless f.peek.to_s.start_with?('//}')
         error "unexpected EOF (block begins at: #{head})"
         return buf
       end
@@ -454,6 +570,7 @@ module ReVIEW
 
     def parse_args(str, _name = nil)
       return [] if str.empty?
+
       scanner = StringScanner.new(str)
       words = []
       while word = scanner.scan(/(\[\]|\[.*?[^\\]\])/)
@@ -471,33 +588,33 @@ module ReVIEW
     end
 
     def compile_command(syntax, args, lines)
-      unless @strategy.respond_to?(syntax.name)
-        error "strategy does not support command: //#{syntax.name}"
-        compile_unknown_command args, lines
+      unless @builder.respond_to?(syntax.name)
+        error "builder does not support command: //#{syntax.name}"
+        compile_unknown_command(args, lines)
         return
       end
       begin
-        syntax.check_args args
+        syntax.check_args(args)
       rescue CompileError => e
         error e.message
         args = ['(NoArgument)'] * syntax.min_argc
       end
       if syntax.block_allowed?
-        compile_block syntax, args, lines
+        compile_block(syntax, args, lines)
       else
         if lines
           error "block is not allowed for command //#{syntax.name}; ignore"
         end
-        compile_single syntax, args
+        compile_single(syntax, args)
       end
     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)
@@ -508,7 +625,7 @@ module ReVIEW
     end
 
     def compile_single(syntax, args)
-      @strategy.__send__(syntax.name, *args)
+      @builder.__send__(syntax.name, *args)
     end
 
     def replace_fence(str)
@@ -518,54 +635,75 @@ module ReVIEW
         if arg =~ /[\x01\x02\x03\x04]/
           error "invalid character in '#{str}'"
         end
-        replaced = arg.gsub('@', "\x01").gsub('\\', "\x02").gsub('{', "\x03").gsub('}', "\x04")
+        replaced = arg.tr('@', "\x01").tr('\\', "\x02").tr('{', "\x03").tr('}', "\x04")
         "@<#{op}>{#{replaced}}"
       end
     end
 
     def revert_replace_fence(str)
-      str.gsub("\x01", '@').gsub("\x02", '\\').gsub("\x03", '{').gsub("\x04", '}')
+      str.tr("\x01", '@').tr("\x02", '\\').tr("\x03", '{').tr("\x04", '}')
+    end
+
+    def in_non_escaped_command?
+      current_command = @command_name_stack.last
+      current_command && non_escaped_commands.include?(current_command)
     end
 
-    def text(str)
+    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}"
         end
       end
-      result = @strategy.nofunc_text(revert_replace_fence(words.shift))
+      result = ''
       until words.empty?
+        if in_non_escaped_command? && block_mode
+          result << revert_replace_fence(words.shift)
+        else
+          result << @builder.nofunc_text(revert_replace_fence(words.shift))
+        end
+        break if words.empty?
+
         result << compile_inline(revert_replace_fence(words.shift.gsub(/\\\}/, '}').gsub(/\\\\/, '\\')))
-        result << @strategy.nofunc_text(revert_replace_fence(words.shift))
       end
       result
     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