review 4.1.0 → 5.2.0

data/lib/epubmaker/zip_exporter.rb

@@ -1,81 +0,0 @@
-# Copyright (c) 2010-2017 Kenshi Muto and Masayoshi Takahashi
-#
-# 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 the GNU LGPL, see the file "COPYING".
-#
-
-require 'pathname'
-begin
-  require 'zip'
-rescue LoadError
-  ## I cannot find rubyzip library, so I use external zip command.
-  warn 'rubyzip not found, so use external zip command'
-end
-
-module EPUBMaker
-  ##
-  # Export into zip file for EPUB producer.
-  #
-  class ZipExporter
-    attr_reader :tmpdir
-
-    def initialize(tmpdir, config)
-      @tmpdir = tmpdir
-      @config = config
-    end
-
-    def export_zip(epubfile)
-      if defined?(Zip)
-        export_zip_rubyzip(epubfile)
-      else
-        export_zip_extcmd(epubfile)
-      end
-    end
-
-    def export_zip_extcmd(epubfile)
-      stage1 = @config['epubmaker']['zip_stage1'].to_s.split
-      path1 = stage1[0] || 'zip'
-      opt1 = stage1[1] || '-0Xq'
-      stage2 = @config['epubmaker']['zip_stage2'].to_s.split
-      path2 = stage2[0] || 'zip'
-      opt2 = stage2[1] || '-Xr9Dq'
-
-      Dir.chdir(tmpdir) do
-        system(path1, opt1, epubfile, 'mimetype')
-        addpath = @config['epubmaker']['zip_addpath']
-        if addpath
-          system(path2, opt2, epubfile, 'META-INF', 'OEBPS', addpath)
-        else
-          system(path2, opt2, epubfile, 'META-INF', 'OEBPS')
-        end
-      end
-    end
-
-    def export_zip_rubyzip(epubfile)
-      Dir.chdir(tmpdir) do
-        Zip::OutputStream.open(epubfile) do |epub|
-          root_pathname = Pathname.new(tmpdir)
-          epub.put_next_entry('mimetype', nil, nil, Zip::Entry::STORED)
-          epub << 'application/epub+zip'
-
-          export_zip_rubyzip_addpath(epub, File.join(tmpdir, 'META-INF'), root_pathname)
-          export_zip_rubyzip_addpath(epub, File.join(tmpdir, 'OEBPS'), root_pathname)
-          if @config['zip_addpath'].present?
-            export_zip_rubyzip_addpath(epub, File.join(tmpdir, @config['zip_addpath']), root_pathname)
-          end
-        end
-      end
-    end
-
-    def export_zip_rubyzip_addpath(epub, dirname, rootdir)
-      Dir[File.join(dirname, '**', '**')].each do |path|
-        next if File.directory?(path)
-        relpath = Pathname.new(path).relative_path_from(rootdir)
-        epub.put_next_entry(relpath)
-        epub << File.binread(path)
-      end
-    end
-  end
-end

data/lib/lineinput.rb

@@ -1,155 +0,0 @@
-#
-# $Id: lineinput.rb 2226 2006-04-15 03:05:09Z aamine $
-#
-# Copyright (c) 2002-2005 Minero Aoki
-#
-# This program is free software.
-# You can distribute/modify this program under the terms of
-# the GNU LGPL, Lesser General Public License version 2.1.
-#
-
-class LineInput
-
-  def initialize(f)
-    @input = f
-    @buf = []
-    @lineno = 0
-    @eof_p = false
-  end
-
-  def inspect
-    "\#<#{self.class} file=#{@input.inspect} line=#{lineno()}>"
-  end
-
-  def eof?
-    @eof_p
-  end
-
-  def lineno
-    @lineno
-  end
-
-  def gets
-    unless @buf.empty?
-      @lineno += 1
-      return @buf.pop
-    end
-    return nil if @eof_p # to avoid ARGF blocking.
-    line = @input.gets
-    @eof_p = true unless line
-    @lineno += 1
-    line
-  end
-
-  def ungets(line)
-    return unless line
-    @lineno -= 1
-    @buf.push line
-    line
-  end
-
-  def peek
-    line = gets()
-    ungets line if line
-    line
-  end
-
-  def next?
-    peek() ? true : false
-  end
-
-  def skip_blank_lines
-    n = 0
-    while line = gets()
-      unless line.strip.empty?
-        ungets line
-        return n
-      end
-      n += 1
-    end
-    n
-  end
-
-  def gets_if(re)
-    line = gets()
-    if not line or not (re =~ line)
-      ungets line
-      return nil
-    end
-    line
-  end
-
-  def gets_unless(re)
-    line = gets()
-    if not line or re =~ line
-      ungets line
-      return nil
-    end
-    line
-  end
-
-  def each
-    while line = gets()
-      yield line
-    end
-  end
-
-  def while_match(re)
-    while line = gets()
-      unless re =~ line
-        ungets line
-        return
-      end
-      yield line
-    end
-    nil
-  end
-
-  def getlines_while(re)
-    buf = []
-    while_match(re) do |line|
-      buf.push line
-    end
-    buf
-  end
-
-  alias_method :span, :getlines_while # from Haskell
-
-  def until_match(re)
-    while line = gets()
-      if re =~ line
-        ungets line
-        return
-      end
-      yield line
-    end
-    nil
-  end
-
-  def getlines_until(re)
-    buf = []
-    until_match(re) do |line|
-      buf.push line
-    end
-    buf
-  end
-
-  alias_method :break, :getlines_until # from Haskell
-
-  def until_terminator(re)
-    while line = gets()
-      return if re =~ line # discard terminal line
-      yield line
-    end
-    nil
-  end
-
-  def getblock(term_re)
-    buf = []
-    until_terminator(term_re) do |line|
-      buf.push line
-    end
-    buf
-  end
-
-end

data/lib/review/book/compilable.rb

@@ -1,178 +0,0 @@
-# Copyright (c) 2009-2017 Minero Aoki, Kenshi Muto
-#               2002-2008 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 the GNU LGPL, see the file "COPYING".
-#
-require 'review/textutils'
-
-module ReVIEW
-  module Book
-    module Compilable
-      include TextUtils
-      attr_reader :book
-      attr_reader :path
-      attr_accessor :content
-
-      def dirname
-        return nil unless @path
-        File.dirname(@path)
-      end
-
-      def basename
-        return nil unless @path
-        File.basename(@path)
-      end
-
-      def name
-        return nil unless @name
-        File.basename(@name, '.*')
-      end
-
-      alias_method :id, :name
-
-      def title
-        return @title if @title
-
-        @title = ''
-        return @title unless content
-        content.each_line do |line|
-          if line =~ /\A=+/
-            @title = line.sub(/\A=+(\[.+?\])?(\{.+?\})?/, '').strip
-            break
-          end
-        end
-        @title
-      end
-
-      def size
-        content.size
-      end
-
-      def volume
-        unless @volume
-          @volume = Volume.count_file(path)
-          @volume.page_per_kbyte = @book.page_metric.page_per_kbyte
-        end
-        @volume
-      end
-
-      def lines
-        # FIXME: we cannot duplicate Enumerator on ruby 1.9 HEAD
-        (@lines ||= content.lines.to_a).dup
-      end
-
-      def list(id)
-        list_index[id]
-      end
-
-      def list_index
-        @list_index ||= ListIndex.parse(lines)
-        @list_index
-      end
-
-      def table(id)
-        table_index[id]
-      end
-
-      def table_index
-        @table_index ||= TableIndex.parse(lines)
-        @table_index
-      end
-
-      def equation(id)
-        equation_index[id]
-      end
-
-      def equation_index
-        @equation_index ||= EquationIndex.parse(lines)
-        @equation_index
-      end
-
-      def footnote(id)
-        footnote_index[id]
-      end
-
-      def footnote_index
-        @footnote_index ||= FootnoteIndex.parse(lines)
-        @footnote_index
-      end
-
-      def image(id)
-        return image_index[id] if image_index.key?(id)
-        return icon_index[id] if icon_index.key?(id)
-        return numberless_image_index[id] if numberless_image_index.key?(id)
-        indepimage_index[id]
-      end
-
-      def numberless_image_index
-        @numberless_image_index ||=
-          NumberlessImageIndex.parse(lines, id,
-                                     @book.imagedir,
-                                     @book.image_types, @book.config['builder'])
-      end
-
-      def image_index
-        @image_index ||= ImageIndex.parse(lines, id,
-                                          @book.imagedir,
-                                          @book.image_types, @book.config['builder'])
-        @image_index
-      end
-
-      def icon_index
-        @icon_index ||= IconIndex.parse(lines, id,
-                                        @book.imagedir,
-                                        @book.image_types, @book.config['builder'])
-        @icon_index
-      end
-
-      def indepimage_index
-        @indepimage_index ||=
-          IndepImageIndex.parse(lines, id,
-                                @book.imagedir,
-                                @book.image_types, @book.config['builder'])
-      end
-
-      def bibpaper(id)
-        bibpaper_index[id]
-      end
-
-      def bibpaper_index
-        raise FileNotFound, "no such bib file: #{@book.bib_file}" unless @book.bib_exist?
-        @bibpaper_index ||= BibpaperIndex.parse(@book.read_bib.lines.to_a)
-        @bibpaper_index
-      end
-
-      def headline(caption)
-        headline_index[caption]
-      end
-
-      def headline_index
-        @headline_index ||= HeadlineIndex.parse(lines, self)
-      end
-
-      def column(id)
-        column_index[id]
-      end
-
-      def column_index
-        @column_index ||= ColumnIndex.parse(lines)
-      end
-
-      def next_chapter
-        book.next_chapter(self)
-      end
-
-      def prev_chapter
-        book.prev_chapter(self)
-      end
-
-      def image_bound?(item_id)
-        item = self.image(item_id)
-        item.path
-      end
-    end
-  end
-end

data/lib/review/tocparser.rb

@@ -1,275 +0,0 @@
-#
-# Copyright (c) 2008-2019 Minero Aoki, Kenshi Muto
-#               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.
-# For details of the GNU LGPL, see the file "COPYING".
-#
-
-require 'review/preprocessor'
-require 'review/book'
-require 'review/textbuilder'
-
-module ReVIEW
-  class TOCParser
-    def self.parse(chap)
-      stream = StringIO.new(chap.content, 'rt:BOM|utf-8')
-      new.parse(stream, chap).map do |root|
-        root.number = chap.number
-        root
-      end
-    end
-
-    def self.chapter_node(chap)
-      toc = self.parse(chap)
-      $stderr.puts "warning: chapter #{toc.join} contains more than 1 chapter" unless toc.size == 1
-      toc.first
-    end
-
-    def parse(f, chap)
-      roots = [] # list of chapters
-      node_stack = []
-      @chap = chap
-      filename = chap.path
-      while line = f.gets
-        case line
-        when /\A\#@/
-          # do nothing
-          next
-        when /\A\s*\z/
-          # do nothing
-          next
-        when /\A(={2,})[\[\s\{]/
-          lev = $1.size
-          if lev > 5
-            error!(filename, f.lineno, "section level too deep: #{lev}")
-          end
-          label = get_label(line)
-          if node_stack.empty?
-            # missing chapter label
-            dummy_chapter = Chapter.new(label, chap)
-            node_stack.push(dummy_chapter)
-            roots.push(dummy_chapter)
-          end
-          next if label.start_with?('[/') # ex) "[/column]"
-          sec = Section.new(lev, label.gsub(/\A\{.*?\}\s?/, ''))
-          node_stack.pop until node_stack.last.level < sec.level
-          node_stack.last.add_child(sec)
-          node_stack.push(sec)
-
-        when /\A=[^=]/
-          label = get_label(line)
-          node_stack.clear
-          new_chapter = Chapter.new(label, chap)
-          node_stack.push(new_chapter)
-          roots.push(new_chapter)
-
-        when %r{\A//\w+(?:\[.*?\])*\{\s*\z}
-          if node_stack.empty?
-            error!(filename, f.lineno, 'list found before section label')
-          end
-          node_stack.last.add_child(list = List.new)
-          beg = f.lineno
-          list.add(line)
-          while line = f.gets
-            break if line.start_with?('//}')
-            list.add(line)
-          end
-          error!(filename, beg, 'unterminated list') unless line
-
-        when %r{\A//\w}
-          # do nothing
-          next
-        else
-          # if node_stack.empty?
-          #   error! filename, f.lineno, 'text found before section label'
-          # end
-          next if node_stack.empty?
-          node_stack.last.add_child(par = Paragraph.new(chap))
-          par.add(line)
-          while line = f.gets
-            break if /\A\s*\z/ =~ line
-            par.add(line)
-          end
-        end
-      end
-
-      roots
-    end
-
-    def get_label(line)
-      line = line.strip.sub(/\A=+\s*/, '')
-      compile_label(line)
-    end
-
-    def compile_label(line)
-      b = ReVIEW::TEXTBuilder.new
-      dummy_book = ReVIEW::Book::Base.load
-      dummy_chapter = ReVIEW::Book::Chapter.new(dummy_book, 1, '-', nil, StringIO.new)
-      if @chap
-        dummy_chapter = @chap
-      end
-      dummy_loc = Location.new('', StringIO.new)
-      b.bind(ReVIEW::Compiler.new(b), dummy_chapter, dummy_loc)
-      b.compile_inline(line)
-    end
-
-    def error!(filename, lineno, msg)
-      raise "#{filename}:#{lineno}: #{msg}"
-    end
-
-    class Node
-      def initialize(children = [])
-        @children = children
-      end
-
-      attr_reader :children
-
-      def add_child(c)
-        @children.push(c)
-      end
-
-      def each_node(&block)
-        @children.each do |c|
-          yield c
-          c.each(&block)
-        end
-      end
-
-      def each_child(&block)
-        @children.each(&block)
-      end
-
-      def chapter?
-        false
-      end
-
-      def each_section(&block)
-        @children.each { |n| n.yield_section(&block) }
-      end
-
-      def each_section_with_index
-        i = 0
-        each_section do |n|
-          yield n, i
-          i += 1
-        end
-      end
-
-      def section_size
-        cnt = 0
-        @children.each { |n| n.yield_section { cnt += 1 } }
-        cnt
-      end
-    end
-
-    class Section < Node
-      def initialize(level, label, path = nil)
-        super()
-        @level = level
-        @label = label
-        @filename = path ? real_filename(path) : nil
-      end
-
-      def real_filename(path)
-        if FileTest.symlink?(path)
-          File.basename(File.readlink(path))
-        else
-          File.basename(path)
-        end
-      end
-      private :real_filename
-
-      attr_reader :level
-      attr_reader :label
-
-      def estimated_lines
-        @children.inject(0) { |sum, n| sum + n.estimated_lines }
-      end
-
-      def yield_section
-        yield self
-      end
-
-      def inspect
-        "#<#{self.class} level=#{@level} #{@label}>"
-      end
-    end
-
-    class Chapter < Section
-      def initialize(label, chap)
-        super(1, label, chap.path)
-        @chapter = chap
-        @chapter_id = chap.id
-        @path = chap.path
-        @page_metric = chap.book.page_metric
-        @volume = nil
-        @number = nil
-      end
-
-      attr_accessor :number
-
-      def chapter?
-        true
-      end
-
-      attr_reader :chapter_id
-
-      def volume
-        return @volume if @volume
-        @volume = @chapter.volume
-        @volume.lines = estimated_lines
-        @volume
-      end
-
-      def inspect
-        "#<#{self.class} #{@filename}>"
-      end
-    end
-
-    class Paragraph < Node
-      def initialize(chap)
-        @bytes = 0
-        @page_metric = chap.book.page_metric
-      end
-
-      def inspect
-        "#<#{self.class}>"
-      end
-
-      def add(line)
-        @bytes += line.strip.bytesize
-      end
-
-      def estimated_lines
-        (@bytes + 2) / @page_metric.text.n_columns + 1
-      end
-
-      def yield_section
-      end
-    end
-
-    class List < Node
-      def initialize
-        @lines = 0
-      end
-
-      def inspect
-        "#<#{self.class}>"
-      end
-
-      def add(_line)
-        @lines += 1
-      end
-
-      def estimated_lines
-        @lines + 2
-      end
-
-      def yield_section
-      end
-    end
-  end
-end