review-peg 0.1.0

data/lib/review/book/chapter.rb

@@ -0,0 +1,100 @@
+#
+# $Id: book.rb 4315 2009-09-02 04:15:24Z kmuto $
+#
+# Copyright (c) 2002-2008 Minero Aoki
+#               2009 Minero Aoki, Kenshi Muto
+#
+# 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/book/compilable'
+module ReVIEW
+  module Book
+    ROMAN = %w[0 I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI XVII XVIII XIX XX XXI XXII XXIII XXIV XXV XXVI XXVII]
+    ALPHA = %w[0 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z]
+    
+    class Chapter
+      include Compilable
+
+      attr_reader :number, :book
+
+      def initialize(book, number, name, path, io = nil)
+        @book = book
+        @number = number
+        @name = name
+        @path = path
+        @io = io
+        @title = nil
+        @content = nil
+        @list_index = nil
+        @table_index = nil
+        @footnote_index = nil
+        @image_index = nil
+        @icon_index = nil
+        @numberless_image_index = nil
+        @indepimage_index = nil
+        @headline_index = nil
+        @column_index = nil
+      end
+
+      def inspect
+        "\#<#{self.class} #{@number} #{@path}>"
+      end
+
+      def format_number(heading = true)
+        if on_PREDEF?
+          return "#{@number}"
+        end
+
+        if on_APPENDIX?
+          return "#{@number}" if @number < 1 || @number > 27
+
+          type = @book.config["appendix_format"].blank? ? "arabic" : @book.config["appendix_format"].downcase.strip
+          appendix = case type
+                       when "roman"
+                         ROMAN[@number]
+                       when "alphabet", "alpha"
+                         ALPHA[@number]
+                       else
+                         # nil, "arabic", etc...
+                         "#{@number}"
+                     end
+          if heading
+            return "#{I18n.t("appendix", appendix)}"
+          else
+            return "#{appendix}"
+          end
+        end
+
+        if heading
+          "#{I18n.t("chapter", @number)}"
+        else
+          "#{@number}"
+        end
+      end
+
+      def on_CHAPS?
+        on_FILE?(@book.read_CHAPS)
+      end
+
+      def on_PREDEF?
+        on_FILE?(@book.read_PREDEF)
+      end
+
+      def on_APPENDIX?
+        on_FILE?(@book.read_APPENDIX)
+      end
+
+      def on_POSTDEF?
+        on_FILE?(@book.read_POSTDEF)
+      end
+
+      private
+      def on_FILE?(contents)
+        contents.lines.map(&:strip).include?("#{id()}#{@book.ext()}")
+      end
+    end
+  end
+end

data/lib/review/book/compilable.rb

@@ -0,0 +1,184 @@
+#
+# $Id: book.rb 4315 2009-09-02 04:15:24Z kmuto $
+#
+# Copyright (c) 2002-2008 Minero Aoki
+#               2009 Minero Aoki, Kenshi Muto
+#
+# 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
+
+      def env
+        @book
+      end
+
+      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 = ''
+        open {|f|
+          f.each_line {|l|
+            if l =~ /\A=+/
+              @title = l.sub(/\A=+(\[.+?\])?(\{.+?\})?/, '').strip
+              break
+            end
+          }
+        }
+        @title
+      end
+
+      def size
+        File.size(path())
+      end
+
+      def volume
+        if !@volume
+          @volume = Volume.count_file(path())
+          @volume.page_per_kbyte = @book.page_metric.page_per_kbyte
+        end
+        @volume
+      end
+
+      def open(&block)
+        return (block_given?() ? yield(@io) : @io) if @io
+        File.open(path(), &block)
+      end
+
+      attr_writer :content
+
+      def content
+        @content = File.read(path())
+      rescue
+        @content
+      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 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().has_key?(id)
+        return icon_index()[id] if icon_index().has_key?(id)
+        return numberless_image_index()[id] if numberless_image_index().has_key?(id)
+        indepimage_index()[id]
+      end
+
+      def numberless_image_index
+        @numberless_image_index ||=
+          NumberlessImageIndex.parse(lines(), id(),
+          "#{book.basedir}/#{@book.image_dir}",
+          @book.image_types, @book.config['builder'])
+      end
+
+      def image_index
+        @image_index ||= ImageIndex.parse(lines(), id(),
+          "#{book.basedir}/#{@book.image_dir}",
+          @book.image_types, @book.config['builder'])
+        @image_index
+      end
+
+      def icon_index
+        @icon_index ||= IconIndex.parse(lines(), id(),
+          "#{book.basedir}/#{@book.image_dir}",
+          @book.image_types, @book.config['builder'])
+        @icon_index
+      end
+
+      def indepimage_index
+        @indepimage_index ||=
+          IndepImageIndex.parse(lines(), id(),
+          "#{book.basedir}/#{@book.image_dir}",
+          @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
+    end
+  end
+end
+

data/lib/review/book/image_finder.rb

@@ -0,0 +1,71 @@
+#
+# Copyright (c) 2014 Minero Aoki, Kenshi Muto, 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 LGPL, see the file "COPYING".
+#
+
+require 'review/extentions'
+require 'review/exception'
+
+module ReVIEW
+  module Book
+    class ImageFinder
+      def initialize(basedir, chapid, builder, exts)
+        @basedir = basedir
+        @chapid = chapid
+        @builder = builder
+        @exts = exts
+        @entries = get_entries()
+      end
+
+      def get_entries
+        Dir.glob(File.join(@basedir, "**/*.*"))
+      end
+
+      def add_entry(path)
+        unless @entries.include?(path)
+          @entries << path
+        end
+        @entries
+      end
+
+      def find_path(id)
+        targets = target_list(id)
+        targets.each do |target|
+          @exts.each do |ext|
+            if @entries.include?("#{target}#{ext}")
+              return "#{target}#{ext}"
+            end
+          end
+        end
+        nil
+      end
+
+      def target_list(id)
+        [
+         # 1. <basedir>/<builder>/<chapid>/<id>.<ext>
+         "#{@basedir}/#{@builder}/#{@chapid}/#{id}",
+
+         # 2. <basedir>/<builder>/<chapid>-<id>.<ext>
+         "#{@basedir}/#{@builder}/#{@chapid}-#{id}",
+
+         # 3. <basedir>/<builder>/<id>.<ext>
+         "#{@basedir}/#{@builder}/#{id}",
+
+         # 4. <basedir>/<chapid>/<id>.<ext>
+         "#{@basedir}/#{@chapid}/#{id}",
+
+         # 5. <basedir>/<chapid>-<id>.<ext>
+         "#{@basedir}/#{@chapid}-#{id}",
+
+         # 6. <basedir>/<id>.<ext>
+         "#{@basedir}/#{id}"
+        ]
+      end
+
+    end
+  end
+end

data/lib/review/book/index.rb

@@ -0,0 +1,413 @@
+# encoding: utf-8
+#
+# Copyright (c) 2002-2007 Minero Aoki
+#               2008-2009 Minero Aoki, Kenshi Muto
+#
+# 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".
+#
+
+require 'review/extentions'
+require 'review/exception'
+require 'review/book/image_finder'
+require 'review/i18n'
+
+module ReVIEW
+  module Book
+    class Index
+      def Index.parse(src, *args)
+        items = []
+        seq = 1
+        src.grep(%r<^//#{item_type()}>) do |line|
+          if id = line.slice(/\[(.*?)\]/, 1)
+            items.push item_class().new(id, seq)
+            seq += 1
+            if id == ""
+              warn "warning: no ID of #{item_type()} in #{line}"
+            end
+          end
+        end
+        new(items, *args)
+      end
+
+      Item = Struct.new(:id, :number)
+
+      def Index.item_class
+        self::Item
+      end
+
+      include Enumerable
+
+      def item_type
+        self.class.item_type
+      end
+
+      def initialize(items)
+        @items = items
+        @index = {}
+        items.each do |i|
+          warn "warning: duplicate ID: #{i.id} (#{i})" unless @index[i.id].nil?
+          @index[i.id] = i
+        end
+        @image_finder = nil
+      end
+
+      def [](id)
+        @index.fetch(id)
+      rescue
+        if @index.keys.map{|i| i.split(/\|/).last }.flatten. # unfold all ids
+            reduce(Hash.new(0)){|h, i| h[i] += 1; h}. # number of occurrences
+            select{|k, v| k == id && v > 1 }.present? # detect duplicated
+          raise KeyError, "key '#{id}' is ambiguous for #{self.class}"
+        end
+
+        @items.each do |i|
+          if i.id.split(/\|/).include?(id)
+            return i
+          end
+        end
+        raise KeyError, "not found key '#{id}' for #{self.class}"
+      end
+
+      def number(id)
+        self[id].number.to_s
+      end
+
+      def each(&block)
+        @items.each(&block)
+      end
+
+      def has_key?(id)
+        return @index.has_key?(id)
+      end
+    end
+
+
+    class ChapterIndex < Index
+      def item_type
+        'chapter'
+      end
+
+      def number(id)
+        chapter = @index.fetch(id, nil)
+        if chapter
+          return chapter.format_number
+        else
+          return "#{I18n.t("part", chapter.number)}"
+        end
+      rescue # part
+        raise "invalid number error: id:#{id}, capter:#{chapter}"
+      end
+
+      def title(id)
+        @index.fetch(id).title
+      rescue # non-file part
+        @index.fetch(id).name
+      end
+
+      def display_string(id)
+        "#{number(id)}#{I18n.t("chapter_quote", title(id))}"
+      end
+    end
+
+
+    class ListIndex < Index
+      def ListIndex.item_type
+        '(list|listnum)'
+      end
+    end
+
+
+    class TableIndex < Index
+      def TableIndex.item_type
+        'table'
+      end
+    end
+
+
+    class FootnoteIndex < Index
+      Item = Struct.new(:id, :number, :content)
+
+      def FootnoteIndex.parse(src)
+        items = []
+        seq = 1
+        src.grep(%r<^//footnote>) do |line|
+          if m = /\[(.*?)\]\[(.*)\]/.match(line)
+            m1 = m[1].gsub(/\\(\])/){$1}
+            m2 = m[2].gsub(/\\(\])/){$1}
+            items.push Item.new(m1, seq, m2)
+          end
+          seq += 1
+        end
+        new(items)
+      end
+    end
+
+
+    class ImageIndex < Index
+      def self.parse(src, *args)
+        items = []
+        seq = 1
+        src.grep(%r<^//#{item_type()}>) do |line|
+          # ex. ["//image", "id", "", "caption"]
+          elements = line.split(/\[(.*?)\]/)
+          if elements[1].present?
+            items.push item_class().new(elements[1], seq, elements[3])
+            seq += 1
+            if elements[1] == ""
+              warn "warning: no ID of #{item_type()} in #{line}"
+            end
+          end
+        end
+        new(items, *args)
+      end
+
+      class Item
+
+        def initialize(id, number, caption = nil)
+          @id = id
+          @number = number
+          @caption = caption
+          @path = nil
+        end
+
+        attr_reader :id
+        attr_reader :number
+        attr_reader :caption
+        attr_writer :index # internal use only
+
+        def bound?
+          path
+        end
+
+        def path
+          @path ||= @index.find_path(id)
+        end
+      end
+
+      def ImageIndex.item_type
+        '(image|graph)'
+      end
+
+      attr_reader :image_finder
+
+      def initialize(items, chapid, basedir, types, builder)
+        super items
+        items.each do |i|
+          i.index = self
+        end
+        @chapid = chapid
+        @basedir = basedir
+        @types = types
+
+        @image_finder = ReVIEW::Book::ImageFinder.new(basedir, chapid,
+                                                      builder, types)
+      end
+
+      def find_path(id)
+        @image_finder.find_path(id)
+      end
+    end
+
+    class IconIndex < ImageIndex
+      def initialize(items, chapid, basedir, types, builder)
+        @items = items
+        @index = {}
+        items.each do |i|
+          ## warn "warning: duplicate ID: #{i.id} (#{i})" unless @index[i.id].nil?
+          @index[i.id] = i
+        end
+        items.each do |i|
+          i.index = self
+        end
+        @chapid = chapid
+        @basedir = basedir
+        @types = types
+
+        @image_finder = ImageFinder.new(basedir, chapid, builder, types)
+      end
+
+      def IconIndex.parse(src, *args)
+        items = []
+        seq = 1
+        src.grep(%r!@<icon>!) do |line|
+          line.gsub(/@<icon>\{(.+?)\}/) do |m|
+            items.push item_class().new($1, seq)
+            seq += 1
+          end
+        end
+        new(items, *args)
+      end
+    end
+
+    class FormatRef
+      def initialize(locale, index)
+        @locale = locale
+        @index = index
+      end
+
+      def title(id)
+        sprintf(@locale["#{@index.item_type}_caption_format".to_sym],
+          @index.title(id))
+      end
+
+      def number(id)
+        sprintf(@locale["#{@index.item_type}_number_format".to_sym],
+          @index.number(id))
+      end
+
+      def method_missing(mid, *args, &block)
+        super unless @index.respond_to?(mid)
+        @index.__send__(mid, *args, &block)
+      end
+    end
+
+    class BibpaperIndex < Index
+      Item = Struct.new(:id, :number, :caption)
+
+      def BibpaperIndex.parse(src)
+        items = []
+        seq = 1
+        src.grep(%r<^//bibpaper>) do |line|
+          if m = /\[(.*?)\]\[(.*)\]/.match(line)
+            m1 = m[1].gsub(/\\(.)/){$1}
+            m2 = m[2].gsub(/\\(.)/){$1}
+            items.push Item.new(m1, seq, m2)
+          end
+          seq += 1
+        end
+        new(items)
+      end
+    end
+
+    class NumberlessImageIndex < ImageIndex
+      class Item < ImageIndex::Item
+      end
+
+      def NumberlessImageIndex.item_type
+        'numberlessimage'
+      end
+
+      def number(id)
+        ""
+      end
+    end
+
+    class IndepImageIndex < ImageIndex
+      class Item < ImageIndex::Item
+      end
+
+      def IndepImageIndex.item_type
+        'indepimage'
+      end
+
+      def number(id)
+        ""
+      end
+    end
+
+    class HeadlineIndex < Index
+      HEADLINE_PATTERN = /\A(=+)(?:\[(.+?)\])?(?:\{(.+?)\})?(.*)/
+      Item = Struct.new(:id, :number, :caption)
+      attr_reader :items
+
+      def HeadlineIndex.parse(src, chap)
+        items = []
+        indexs = []
+        headlines = []
+        inside_column = false
+        src.each do |line|
+          if m = HEADLINE_PATTERN.match(line)
+            next if m[1].size > 10 # Ignore too deep index
+            index = m[1].size - 2
+
+            # column
+            if m[2] == 'column'
+              inside_column = true
+              next
+            end
+            if m[2] == '/column'
+              inside_column = false
+              next
+            end
+            if indexs.blank? || index <= indexs[-1]
+              inside_column = false
+            end
+            if inside_column
+              next
+            end
+
+            if index >= 0
+              if indexs.size > (index + 1)
+                indexs = indexs.take(index + 1)
+                headlines = headlines.take(index + 1)
+              end
+              if indexs[index].nil?
+                (0..index).each{|i| indexs[i] = 0 if indexs[i].nil?}
+              end
+              indexs[index] += 1
+              headlines[index] = m[3].present? ? m[3].strip : m[4].strip
+              items.push Item.new(headlines.join("|"), indexs.dup, m[4].strip)
+            end
+          end
+        end
+        new(items, chap)
+      end
+
+      def initialize(items, chap)
+        @items = items
+        @chap = chap
+        @index = {}
+        items.each do |i|
+          warn "warning: duplicate ID: #{i.id}" unless @index[i.id].nil?
+          @index[i.id] = i
+        end
+      end
+
+      def number(id)
+        n = @chap.number
+        if @chap.on_APPENDIX? && @chap.number > 0 && @chap.number < 28
+          type = @chap.book.config["appendix_format"].blank? ? "arabic" : @chap.book.config["appendix_format"].downcase.strip
+          n = case type
+              when "roman"
+                ROMAN[@chap.number]
+              when "alphabet", "alpha"
+                ALPHA[@chap.number]
+              else
+                # nil, "arabic", etc...
+                "#{@chap.number}"
+              end
+        end
+        return ([n] + self[id].number).join(".")
+      end
+    end
+
+    class ColumnIndex < Index
+      COLUMN_PATTERN = /\A(=+)\[column\](?:\{(.+?)\})?(.*)/
+      Item = Struct.new(:id, :number, :caption)
+
+      def ColumnIndex.parse(src, *args)
+        items = []
+        seq = 1
+        src.each do |line|
+          if m = COLUMN_PATTERN.match(line)
+            level = m[1] ## not use it yet
+            id = m[2]
+            caption = m[3].strip
+            if !id || id == ""
+              id = caption
+            end
+
+            items.push item_class().new(id, seq, caption)
+            seq += 1
+          end
+        end
+        new(items)
+      end
+
+    end
+
+  end
+end