review-peg 0.1.0

data/lib/lineinput.rb

@@ -0,0 +1,107 @@
+#
+# $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 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
+
+end

data/lib/review.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/review/*.rb"].sort.each do |path|
+  require "review/#{File.basename(path, '.rb')}"
+end

data/lib/review/book.rb

@@ -0,0 +1,43 @@
+#
+# $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/exception'
+require 'review/extentions'
+
+require 'review/book/base'
+require 'review/book/chapter'
+require 'review/book/part'
+require 'review/book/page_metric'
+require 'review/book/volume'
+require 'review/book/index'
+
+module ReVIEW
+  @default_book = nil
+
+  def ReVIEW.book
+    @default_book ||= Book::Base.load
+  end
+
+  module Book
+    def self.load_default
+      Base.load_default
+    end
+
+    def self.load(dir)
+      Base.load dir
+    end
+
+    def self.update_rubyenv(dir)
+      Base.update_rubyenv dir
+    end
+  end
+end

data/lib/review/book/base.rb

@@ -0,0 +1,401 @@
+#
+# $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/configure'
+require 'review/catalog'
+
+module ReVIEW
+  module Book
+    class Base
+
+      attr_writer :config
+
+      def self.load_default
+        warn 'Book::Base.load_default() is obsoleted. Use Book::Base.load().'
+        load()
+      end
+
+      def self.load(dir = ".")
+        update_rubyenv dir
+        new(dir)
+      end
+
+      @basedir_seen = {}
+
+      def self.update_rubyenv(dir)
+        return if @basedir_seen.key?(dir)
+        if File.file?("#{dir}/review-ext.rb")
+          if ENV["REVIEW_SAFE_MODE"].to_i & 2 > 0
+            warn "review-ext.rb is prohibited in safe mode. ignored."
+          else
+            Kernel.load File.expand_path("#{dir}/review-ext.rb")
+          end
+        end
+        @basedir_seen[dir] = true
+      end
+
+      def initialize(basedir)
+        @basedir = basedir
+        @parts = nil
+        @chapter_index = nil
+        @config = ReVIEW::Configure.values
+        @catalog = nil
+      end
+
+      def bib_file
+        config["bib_file"]
+      end
+
+      def reject_file
+        config["reject_file"]
+      end
+
+      def ext
+        config["ext"]
+      end
+
+      def image_dir
+        config["image_dir"]
+      end
+
+      def image_types
+        config["image_types"]
+      end
+
+      def image_types=(types)
+        config["image_types"] = types
+      end
+
+      def page_metric
+        if config["page_metric"].respond_to?(:downcase) && config["page_metric"].upcase =~ /^[A-Z0-9_]+$/
+          ReVIEW::Book::PageMetric.const_get(config["page_metric"].upcase)
+        elsif config["page_metric"].kind_of?(Array) && config["page_metric"].size == 5
+          ReVIEW::Book::PageMetric.new(*config["page_metric"])
+        else
+          config["page_metric"]
+        end
+      end
+
+      def htmlversion
+        if config["htmlversion"].blank?
+          nil
+        else
+          config["htmlversion"].to_i
+        end
+      end
+
+      def parts
+        @parts ||= read_parts()
+      end
+
+      def parts_in_file
+        parts.find_all{|part|
+          part if part.present? and part.file?
+        }
+      end
+
+      def part(n)
+        parts.detect {|part| part.number == n }
+      end
+
+      def each_part(&block)
+        parts.each(&block)
+      end
+
+      def chapters
+        parts().map {|p| p.chapters }.flatten
+      end
+
+      def each_chapter(&block)
+        chapters.each(&block)
+      end
+
+      def each_chapter_r(&block)
+        chapters.reverse_each(&block)
+      end
+
+      def chapter_index
+        return @chapter_index if @chapter_index
+
+        contents = chapters()
+        parts().each do |prt|
+          if prt.id.present?
+            contents << prt
+          end
+        end
+        @chapter_index = ChapterIndex.new(contents)
+      end
+
+      def chapter(id)
+        chapter_index()[id]
+      end
+
+      def next_chapter(chapter)
+        finded = false
+        each_chapter do |c|
+          return c if finded
+          finded = true if c == chapter
+        end
+        nil # not found
+      end
+
+      def prev_chapter(chapter)
+        finded = false
+        each_chapter_r do |c|
+          return c if finded
+          finded = true if c == chapter
+        end
+        nil # not found
+      end
+
+      def volume
+        vol = Volume.sum(chapters.map {|chap| chap.volume })
+        vol.page_per_kbyte = page_metric.page_per_kbyte
+        vol
+      end
+
+      def config
+        @config ||= Configure.values
+      end
+
+      # backward compatible
+      def param=(param)
+        @config = param
+      end
+
+      def load_config(filename)
+        new_conf = YAML.load_file(filename)
+        @config.merge!(new_conf)
+      end
+
+      # backward compatible
+      def param
+        @config
+      end
+
+      def catalog
+        return @catalog if @catalog.present?
+
+        catalogfile_path = "#{basedir}/#{config["catalogfile"]}"
+        if File.file? catalogfile_path
+          @catalog = Catalog.new(File.open catalogfile_path)
+        end
+
+        @catalog
+      end
+
+      def read_CHAPS
+        if catalog
+          catalog.chaps
+        else
+          read_FILE(config["chapter_file"])
+        end
+      end
+
+      def read_PREDEF
+        if catalog
+          catalog.predef
+        else
+          read_FILE(config["predef_file"])
+        end
+      end
+
+      def read_APPENDIX
+        if catalog
+          catalog.appendix
+        else
+          read_FILE(config["postdef_file"]) # for backward compatibility
+        end
+      end
+
+      def read_POSTDEF
+        if catalog
+          catalog.postdef
+        else
+          ""
+        end
+      end
+
+      def read_PART
+        return @read_part if @read_part
+
+        if catalog
+          @read_part = catalog.parts
+        else
+          @read_part = File.read("#{@basedir}/#{config["part_file"]}")
+        end
+      end
+
+      def part_exist?
+        if catalog
+          catalog.parts.present?
+        else
+          File.exist?("#{@basedir}/#{config["part_file"]}")
+        end
+      end
+
+      def read_bib
+        File.read("#{@basedir}/#{bib_file}")
+      end
+
+      def bib_exist?
+        File.exist?("#{@basedir}/#{bib_file}")
+      end
+
+      def prefaces
+        if catalog
+          return mkpart_from_namelist(catalog.predef.split("\n"))
+        end
+
+        if File.file?("#{@basedir}/#{config["predef_file"]}")
+          begin
+            return mkpart_from_namelistfile("#{@basedir}/#{config["predef_file"]}")
+          rescue FileNotFound => err
+            raise FileNotFound, "preface #{err.message}"
+          end
+        end
+      end
+
+      def appendix
+        if catalog
+          names = catalog.appendix.split("\n")
+          chaps = names.each_with_index.map {|n, idx|
+            mkchap_ifexist(n, idx)
+          }.compact
+          return mkpart(chaps)
+        end
+
+        if File.file?("#{@basedir}/#{config["postdef_file"]}")
+          begin
+            return mkpart_from_namelistfile("#{@basedir}/#{config["postdef_file"]}")
+          rescue FileNotFound => err
+            raise FileNotFound, "postscript #{err.message}"
+          end
+        end
+      end
+
+      def postscripts
+        if catalog
+          mkpart_from_namelist(catalog.postdef.split("\n"))
+        end
+      end
+
+      def basedir
+        @basedir
+      end
+
+      private
+
+      def read_parts
+        list = parse_chapters
+        if pre = prefaces
+          list.unshift pre
+        end
+        if app = appendix
+          list.push app
+        end
+        if post = postscripts
+          list.push post
+        end
+        list
+      end
+
+      def parse_chapters
+        part = 0
+        num = 0
+
+        if catalog
+          return catalog.parts_with_chaps.map do |entry|
+            if entry.is_a? Hash
+              chaps = entry.values.first.map do |chap|
+                Chapter.new(self, (num += 1), chap, "#{@basedir}/#{chap}")
+              end
+              Part.new(self, (part += 1), chaps, read_PART.split("\n")[part - 1])
+            else
+              chap = Chapter.new(self, (num += 1), entry, "#{@basedir}/#{entry}")
+              Part.new(self, nil, [chap])
+            end
+          end
+        end
+
+        chap = read_CHAPS()\
+          .strip.lines.map {|line| line.strip }.join("\n").split(/\n{2,}/)\
+          .map {|part_chunk|
+          chaps = part_chunk.split.map {|chapid|
+            Chapter.new(self, (num += 1), chapid, "#{@basedir}/#{chapid}")
+          }
+          if part_exist? && read_PART.split("\n").size >= part
+            Part.new(self, (part += 1), chaps, read_PART.split("\n")[part-1])
+          else
+            Part.new(self, (part += 1), chaps)
+          end
+        }
+        return chap
+      end
+
+      def mkpart_from_namelistfile(path)
+        chaps = []
+        File.read(path).split.each_with_index do |name, idx|
+          name.sub!(/\A\xEF\xBB\xBF/u, '') # remove BOM
+          if path =~ /PREDEF/
+            chaps << mkchap(name)
+          else
+            chaps << mkchap(name, idx + 1)
+          end
+        end
+        mkpart(chaps)
+      end
+
+      def mkpart_from_namelist(names)
+        mkpart(names.map {|n| mkchap_ifexist(n) }.compact)
+      end
+
+      def mkpart(chaps)
+        chaps.empty? ? nil : Part.new(self, nil, chaps)
+      end
+
+      def mkchap(name, number = nil)
+        name += ext if File.extname(name) == ""
+        path = "#{@basedir}/#{name}"
+        raise FileNotFound, "file not exist: #{path}" unless File.file?(path)
+        Chapter.new(self, number, name, path)
+      end
+
+      def mkchap_ifexist(name, idx = nil)
+        name += ext if File.extname(name) == ""
+        path = "#{@basedir}/#{name}"
+        if File.file?(path)
+          idx += 1 if idx
+          Chapter.new(self, idx, name, path)
+        end
+      end
+
+      def read_FILE(filename)
+        res = ""
+        File.open("#{@basedir}/#{filename}") do |f|
+          while line = f.gets
+            line.sub!(/\A\xEF\xBB\xBF/u, '') # remove BOM
+            if /\A#/ =~ line
+              next
+            end
+            line.gsub!(/#.*$/, "")
+            res << line
+          end
+        end
+        res
+      rescue Errno::ENOENT
+        Dir.glob("#{@basedir}/*#{ext()}").sort.join("\n")
+      rescue Errno::EISDIR
+        ""
+      end
+    end
+  end
+end