review 3.2.0 → 5.1.0

data/lib/review/textmaker.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Kenshi Muto
+# Copyright (c) 2018-2021 Kenshi Muto
 #
 # This program is free software.
 # You can distribute or modify this program under the terms of
@@ -15,24 +15,29 @@ require 'review/book'
 require 'review/yamlloader'
 require 'review/topbuilder'
 require 'review/version'
+require 'review/makerhelper'
+require 'review/img_math'
 
 module ReVIEW
   class TEXTMaker
+    include MakerHelper
+
     attr_accessor :config, :basedir
 
     def initialize
       @basedir = nil
       @logger = ReVIEW.logger
       @plaintext = nil
+      @img_math = nil
     end
 
     def error(msg)
-      @logger.error "#{File.basename($PROGRAM_NAME, '.*')}: #{msg}"
+      @logger.error msg
       exit 1
     end
 
     def warn(msg)
-      @logger.warn "#{File.basename($PROGRAM_NAME, '.*')}: #{msg}"
+      @logger.warn msg
     end
 
     def self.execute(*args)
@@ -42,10 +47,12 @@ module ReVIEW
     def parse_opts(args)
       cmd_config = {}
       opts = OptionParser.new
+      @buildonly = nil
 
       opts.banner = 'Usage: review-textmaker [-n] configfile'
       opts.version = ReVIEW::VERSION
       opts.on('-n', 'No decoration.') { @plaintext = true }
+      opts.on('-y', '--only file1,file2,...', 'Build only specified files.') { |v| @buildonly = v.split(/\s*,\s*/).map { |m| m.strip.sub(/\.re\Z/, '') } }
       opts.on('--help', 'Prints this message and quit.') do
         puts opts.help
         exit 0
@@ -65,30 +72,32 @@ module ReVIEW
     end
 
     def remove_old_files(path)
+      @img_math.cleanup_mathimg
       FileUtils.rm_rf(path)
     end
 
     def execute(*args)
-      @config = ReVIEW::Configure.values
-      @config.maker = 'textmaker'
       cmd_config, yamlfile = parse_opts(args)
       error "#{yamlfile} not found." unless File.exist?(yamlfile)
 
-      begin
-        loader = ReVIEW::YAMLLoader.new
-        @config.deep_merge!(loader.load_file(yamlfile))
-      rescue => e
-        error "yaml error #{e.message}"
-      end
-      # YAML configs will be overridden by command line options.
-      @config.deep_merge!(cmd_config)
+      @config = ReVIEW::Configure.create(maker: 'textmaker',
+                                         yamlfile: yamlfile,
+                                         config: cmd_config)
+      @img_math = ReVIEW::ImgMath.new(@config, path_name: '_review_math_text')
+
       I18n.setup(@config['language'])
       begin
         generate_text_files(yamlfile)
+        @logger.success("built #{build_path}")
       rescue ApplicationError => e
         raise if @config['debug']
+
         error(e.message)
       end
+
+      if @config['math_format'] == 'imgmath'
+        @img_math.make_math_images
+      end
     end
 
     def generate_text_files(yamlfile)
@@ -97,8 +106,7 @@ module ReVIEW
       remove_old_files(@path)
       Dir.mkdir(@path)
 
-      @book = ReVIEW::Book.load(@basedir)
-      @book.config = @config
+      @book = ReVIEW::Book::Base.new(@basedir, config: @config)
 
       build_body(@path, yamlfile)
     end
@@ -107,9 +115,9 @@ module ReVIEW
       base_path = Pathname.new(@basedir)
       builder = nil
       if @plaintext
-        builder = ReVIEW::PLAINTEXTBuilder.new
+        builder = ReVIEW::PLAINTEXTBuilder.new(img_math: @img_math)
       else
-        builder = ReVIEW::TOPBuilder.new
+        builder = ReVIEW::TOPBuilder.new(img_math: @img_math)
       end
       @converter = ReVIEW::Converter.new(@book, builder)
       @book.parts.each do |part|
@@ -144,6 +152,10 @@ module ReVIEW
         filename = Pathname.new(chap.path).relative_path_from(base_path).to_s
       end
       id = File.basename(filename).sub(/\.re\Z/, '')
+      if @buildonly && !@buildonly.include?(id)
+        warn "skip #{id}.re"
+        return
+      end
 
       textfile = "#{id}.txt"
 

data/lib/review/textutils.rb

@@ -1,4 +1,13 @@
+# Copyright (c) 2008-2020 Minero Aoki, Kenshi Muto, Masayoshi Takahashi,
+#                         KADO Masanori
+#               2002-2007 Minero Aoki
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+#
 require 'nkf'
+require 'digest'
 
 module ReVIEW
   module TextUtils
@@ -26,10 +35,67 @@ module ReVIEW
         end
       end
 
+      blocked_lines.map! { |i| join_lines_to_paragraph(i) }
+
       if pre && post
-        blocked_lines.map! { |i| [pre] + i + [post] }
+        blocked_lines.map! { |i| pre + i + post }
+      end
+
+      blocked_lines
+    end
+
+    def add_space?(line1, line2, lang, lazy = nil)
+      # https://drafts.csswg.org/css-text-3/#line-break-transform
+      tail = line1[-1]
+      head = line2[0]
+      if tail.nil? || head.nil?
+        return nil
+      end
+
+      space = true
+      # rule 2
+      if %i[F W H].include?(Unicode::Eaw.property(tail)) &&
+         %i[F W H].include?(Unicode::Eaw.property(head)) &&
+         tail !~ /\p{Hangul}/ && head !~ /\p{Hangul}/
+        space = nil
+      end
+
+      if %w[ja zh zh_CN zh_TW yi].include?(lang)
+        # rule 3
+        if (%i[F W H].include?(Unicode::Eaw.property(tail)) &&
+            tail !~ /\p{Hangul}/ &&
+            (head =~ /\p{P}/ || head =~ /\p{S}/ || Unicode::Eaw.property(head) == :A)) ||
+           (%i[F W H].include?(Unicode::Eaw.property(head)) &&
+            head !~ /\p{Hangul}/ &&
+            (tail =~ /\p{P}/ || head =~ /\p{S}/ || Unicode::Eaw.property(tail) == :A))
+          space = nil
+        end
+
+        # lazy than rule 3, but it looks better
+        if lazy &&
+           (%i[F W H].include?(Unicode::Eaw.property(tail)) &&
+            tail !~ /\p{Hangul}/) ||
+           (%i[F W H].include?(Unicode::Eaw.property(head)) &&
+            head !~ /\p{Hangul}/)
+          space = nil
+        end
+      end
+      space
+    end
+
+    def join_lines_to_paragraph(lines)
+      unless @book.config['join_lines_by_lang']
+        return lines.join
+      end
+
+      lazy = true
+      lang = 'ja'
+      0.upto(lines.size - 2) do |n|
+        if add_space?(lines[n], lines[n + 1], lang, lazy)
+          lines[n] += ' '
+        end
       end
-      blocked_lines.map(&:join)
+      lines.join
     end
 
     private

data/lib/review/tocprinter.rb

@@ -1,148 +1,293 @@
-# Copyright (c) 2008-2017 Minero Aoki, Kenshi Muto
-#               2002-2007 Minero Aoki
+# Copyright (c) 2008-2021 Minero Aoki, Kenshi Muto
+#               1999-2007 Minero Aoki
 #
 # This program is free software.
 # You can distribute or modify this program under the terms of
 # the GNU LGPL, Lesser General Public License version 2.1.
-# For details of LGPL, see the file "COPYING".
+# For details of the GNU LGPL, see the file "COPYING".
 #
 
-require 'review/htmlutils'
-require 'review/tocparser'
+require 'review/book'
+require 'review/version'
+require 'optparse'
+require 'review/plaintextbuilder'
 
 module ReVIEW
-  class TOCPrinter
-    def self.default_upper_level
-      99 # no one use 99 level nest
+  class PLAINTEXTTocBuilder < PLAINTEXTBuilder
+    def headline(level, label, caption)
+      if @chapter.is_a?(ReVIEW::Book::Part)
+        print "\x01H0\x01" # XXX: don't modify level value. level value will be handled in sec_counter#prefix()
+      else
+        print "\x01H#{level}\x01"
+      end
+      # embed header information for tocparser
+      super(level, label, caption)
     end
 
-    def initialize(print_upper, param, out = $stdout)
-      @print_upper = print_upper
-      @config = param
-      @out = out
+    def base_block(type, lines, caption = nil)
+      puts "\x01STARTLIST\x01"
+      super(type, lines, caption)
+      puts "\x01ENDLIST\x01"
     end
 
-    def print_book(book)
-      book.each_part { |part| print_part(part) }
+    def blank
+      @blank_seen = true
     end
+  end
 
-    def print_part(part)
-      part.each_chapter { |chap| print_chapter(chap) }
+  class TOCPrinter
+    class Counter
+      def initialize(name: nil, level: nil, headline: nil, lines: nil, chars: nil, list_lines: nil, text_lines: nil, part: nil)
+        @name = name
+        @level = level
+        @headline = headline
+        @lines = lines
+        @chars = chars
+        @list_lines = list_lines
+        @text_lines = text_lines
+        @part = part
+      end
+
+      attr_accessor :name, :level, :headline, :lines, :chars, :list_lines, :text_lines, :part
     end
 
-    def print_chapter(chap)
-      chap_node = TOCParser.chapter_node(chap)
-      print_node 1, chap_node
-      print_children chap_node
+    def self.execute(*args)
+      new.execute(*args)
     end
 
-    def print?(level)
-      level <= @print_upper
+    def initialize
+      @logger = ReVIEW.logger
+      @yamlfile = 'config.yml'
+      @upper = 4
+      @indent = true
+      @buildonly = nil
+      @detail = nil
+      @calc_char_width = nil
     end
-  end
 
-  class TextTOCPrinter < TOCPrinter
-    private
+    attr_accessor :calc_char_width
 
-    def print_children(node)
-      return unless print?(node.level + 1)
-      node.each_section_with_index do |section, idx|
-        unless section.blank?
-          print_node idx + 1, section
-          print_children section
+    def execute(*args)
+      parse_options(args)
+      @config = ReVIEW::Configure.create(yamlfile: @yamlfile)
+      @book = ReVIEW::Book::Base.new('.', config: @config)
+      unless File.readable?(@yamlfile)
+        @logger.error("No such fiile or can't open #{@yamlfile}.")
+        exit 1
+      end
+      I18n.setup(@config['language'])
+
+      if @detail
+        begin
+          require 'unicode/eaw'
+          @calc_char_width = true
+        rescue LoadError
+          @logger.warn('not found unicode/eaw library. page volume may be unreliable.')
+          @calc_char_width = nil
         end
       end
+
+      print_result(build_result_array)
     end
 
-    def print_node(number, node)
-      if node.chapter?
-        vol = node.volume
-        @out.printf "%3s %3dKB %6dC %5dL  %s (%s)\n",
-                    chapnumstr(node.number),
-                    vol.kbytes, vol.chars, vol.lines,
-                    node.label, node.chapter_id
-      else ## for section node
-        @out.printf "%17s %5dL  %s\n",
-                    '', node.estimated_lines,
-                    "  #{'   ' * (node.level - 1)}#{number} #{node.label}"
+    def build_result_array
+      result_array = []
+      begin
+        @book.parts.each do |part|
+          if part.name.present? && (@buildonly.nil? || @buildonly.include?(part.name))
+            result_array.push(Counter.new(part: 'start'))
+            if part.file?
+              content = build_chap(part)
+              result_array.concat(parse_contents(part.name, @upper, content))
+            else
+              title = part.format_number + I18n.t('chapter_postfix') + part.title
+              result_array.push(
+                Counter.new(name: '', lines: 1, chars: title.size, list_lines: 0, text_lines: 1),
+                Counter.new(level: 0, headline: title, lines: 1, chars: title.size, list_lines: 0, text_lines: 1)
+              )
+            end
+          end
+
+          part.chapters.each do |chap|
+            if @buildonly.nil? || @buildonly.include?(chap.name)
+              content = build_chap(chap)
+              result_array.concat(parse_contents(chap.name, @upper, content))
+            end
+          end
+          if part.name.present? && (@buildonly.nil? || @buildonly.include?(part.name))
+            result_array.push(Counter.new(part: 'end'))
+          end
+        end
+      rescue ReVIEW::FileNotFound, ReVIEW::CompileError => e
+        @logger.error e
+        exit 1
       end
+
+      result_array
     end
 
-    def chapnumstr(n)
-      n ? sprintf('%2d.', n) : '   '
+    def print_result(result_array)
+      result_array.each do |result|
+        if result.part
+          next
+        end
+
+        if result.name
+          # file information
+          if @detail
+            puts '============================='
+            printf("%6dC %5dL %5dP  %s\n", result.chars, result.lines, calc_pages(result).ceil, result.name)
+            puts '-----------------------------'
+          end
+          next
+        end
+
+        # section information
+        if @detail
+          printf('%6dC %5dL %5.1fP  ', result.chars, result.lines, calc_pages(result))
+        end
+        if @indent && result.level
+          print '  ' * (result.level == 0 ? 0 : result.level - 1)
+        end
+        puts result.headline
+      end
     end
 
-    def volume_columns(level, volstr)
-      cols = ['', '', '', nil]
-      cols[level - 1] = volstr
-      cols[0, 3] # does not display volume of level-4 section
+    def calc_pages(result)
+      (result.list_lines.to_f / @book.page_metric.list.n_lines) +
+        (result.text_lines.to_f / @book.page_metric.text.n_lines)
     end
-  end
 
-  class HTMLTOCPrinter < TOCPrinter
-    include HTMLUtils
+    def calc_linesize(line)
+      return line.size unless @calc_char_width
 
-    def print_book(book)
-      @out.puts '<ul class="book-toc">'
-      book.each_part { |part| print_part(part) }
-      @out.puts '</ul>'
+      line.each_char.inject(0) do |result, char|
+        # XXX: should include A also?
+        if %i[Na H N].include?(Unicode::Eaw.property(char))
+          result + 0.5 # halfwidth
+        else
+          result + 1
+        end
+      end
     end
 
-    def print_part(part)
-      if part.number
-        @out.puts li(part.title)
+    def parse_contents(name, upper, content)
+      headline_array = []
+      counter = Counter.new(lines: 0, chars: 0, list_lines: 0, text_lines: 0)
+      listmode = nil
+
+      content.each_line(chomp: true) do |l|
+        if l.start_with?("\x01STARTLIST\x01")
+          listmode = true
+          next
+        elsif l.start_with?("\x01ENDLIST\x01")
+          listmode = nil
+          next
+        elsif l =~ /\A\x01H(\d)\x01/
+          # headline
+          level = $1.to_i
+          l = $'
+          if level <= upper
+            if counter.chars > 0
+              headline_array.push(counter)
+            end
+            headline = l
+            counter = Counter.new(
+              level: level,
+              headline: headline,
+              lines: 1,
+              chars: headline.size,
+              list_lines: 0,
+              text_lines: 1
+            )
+            next
+          end
+        end
+
+        counter.lines += 1
+        counter.chars += l.size
+
+        if listmode
+          # code list: calculate line wrapping
+          counter.list_lines += calc_line_wrapping(l, mode: :list)
+        else
+          # normal paragraph: calculate line wrapping
+          counter.text_lines += calc_line_wrapping(l, mode: :text)
+        end
       end
-      super
+      headline_array.push(counter)
+
+      total = calc_total_count(name, headline_array)
+      headline_array.unshift(total)
     end
 
-    def print_chapter(chap)
-      chap_node = TOCParser.chapter_node(chap)
-      ext = chap.book.config['htmlext'] || 'html'
-      path = chap.path.sub(/\.re/, '.' + ext)
-      label = if chap_node.number && chap.on_chaps?
-                "#{chap.number} #{chap.title}"
-              else
-                chap.title
-              end
-      @out.puts li(a_name(path, escape_html(label)))
-      return unless print?(2)
-      if print?(3)
-        @out.puts chap_sections_to_s(chap_node)
-      else
-        @out.puts chapter_to_s(chap_node)
+    def calc_line_wrapping(line, mode:)
+      return 1 if line.size == 0
+
+      case mode
+      when :list
+        (calc_linesize(line) - 1) / @book.page_metric.list.n_columns + 1
+      else # mode == :text
+        (calc_linesize(line) - 1) / @book.page_metric.text.n_columns + 1
       end
     end
 
-    private
+    def calc_total_count(name, headline_array)
+      total = Counter.new(name: name,
+                          lines: 0,
+                          chars: 0,
+                          list_lines: 0,
+                          text_lines: 0)
 
-    def chap_sections_to_s(chap)
-      return '' if chap.section_size < 1
-      res = []
-      res << '<ol>'
-      chap.each_section { |sec| res << li(escape_html(sec.label)) }
-      res << '</ol>'
-      res.join("\n")
-    end
+      headline_array.each do |h|
+        next unless h.lines
 
-    def chapter_to_s(chap)
-      res = []
-      chap.each_section do |sec|
-        res << li(escape_html(sec.label))
-        next unless print?(4)
-        next unless sec.section_size > 0
-        res << '<ul>'
-        sec.each_section { |node| res << li(escape_html(node.label)) }
-        res << '</ul>'
+        total.lines += h.lines
+        total.chars += h.chars
+        total.list_lines += h.list_lines
+        total.text_lines += h.text_lines
       end
-      res.join("\n")
+
+      total
     end
 
-    def li(content)
-      "<li>#{content}</li>"
+    def build_chap(chap)
+      compiler = ReVIEW::Compiler.new(ReVIEW::PLAINTEXTTocBuilder.new)
+      begin
+        compiler.compile(@book.chapter(chap.name))
+      rescue ReVIEW::ApplicationError => e
+        @logger.error e.message
+        exit 1
+      end
     end
 
-    def a_name(name, label)
-      %Q(<a name="#{name}">#{label}</a>)
+    def parse_options(args)
+      opts = OptionParser.new
+      opts.version = ReVIEW::VERSION
+      opts.on('--yaml=YAML', 'Read configurations from YAML file.') { |yaml| @yamlfile = yaml }
+      opts.on('-y', '--only file1,file2,...', 'list only specified files.') do |v|
+        @buildonly = v.split(/\s*,\s*/).map { |m| m.strip.sub(/\.re\Z/, '') }
+      end
+      opts.on('-l', '--level N', 'list upto N level (default=4)') do |n|
+        @upper = n.to_i
+      end
+      opts.on('-d', '--detail', 'show characters and lines of each section.') do
+        @detail = true
+      end
+      opts.on('--noindent', "don't indent headlines.") do
+        @indent = nil
+      end
+      opts.on('--help', 'print this message and quit.') do
+        puts opts.help
+        exit 0
+      end
+      begin
+        opts.parse!(args)
+      rescue OptionParser::ParseError => e
+        @logger.error e.message
+        $stderr.puts opts.help
+        exit 1
+      end
     end
   end
 end