rabbit 0.6.2

data/lib/rabbit/parser/ext/escape.rb

@@ -0,0 +1,18 @@
+require 'English'
+
+module Rabbit
+  module Parser
+    module Ext
+      module Escape
+        META_CHAR = {"<" => "&#60;", ">" => "&#62;", "&" => "&#38;"}
+
+        module_function
+        def escape_meta_character(str)
+          str.gsub(/[<>&]/) do
+            META_CHAR[$MATCH]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/ext/image.rb

@@ -0,0 +1,102 @@
+require 'uri'
+require 'cgi'
+require 'open-uri'
+require 'fileutils'
+
+require 'rabbit/element'
+
+module Rabbit
+  module Parser
+    module Ext
+      module Image
+        ALLOWED_IMG_URL_SCHEME = ['http', 'file', '']
+
+        module_function
+        def make_image(canvas, uri_str, prop={})
+          uri = URI.parse(uri_str)
+          scheme = uri.scheme
+          unless ALLOWED_IMG_URL_SCHEME.include?(scheme.to_s.downcase)
+            return nil
+          end
+          begin
+            Element::Image.new(Private.image_filename(canvas, uri), prop)
+          rescue Error
+            canvas.logger.warn($!.message)
+            nil
+          end
+        end
+
+        def make_image_from_file(canvas, source)
+          src_file = Tempfile.new("rabbit-image-source")
+          src_file.open
+          src_file.print(source)
+          src_file.close
+          image_file = prop = nil
+          begin
+            image_file, prop = yield(src_file.path)
+          rescue ImageLoadError
+            canvas.logger.warn($!.message)
+          end
+          return nil if image_file.nil?
+          image = make_image(canvas, %Q[file://#{image_file.path}], prop)
+          return nil if image.nil?
+          image["_src"] = image_file # for protecting from GC
+          image
+        end
+
+        module Private
+          module_function
+          def image_filename(canvas, uri)
+            case uri.scheme
+            when /file/i
+              GLib.filename_from_utf8(uri.path)
+            when /http|ftp/i
+              other_uri_filename(canvas, uri)
+            else
+              related_path_filename(canvas, uri)
+            end
+          end
+
+          def tmp_filename(canvas, key)
+            dir = canvas.tmp_dir_name
+            FileUtils.mkdir_p(dir)
+            File.join(dir, CGI.escape(key))
+          end
+
+          def related_path_filename(canvas, uri)
+            image_uri = canvas.full_path(GLib.filename_from_utf8(uri.to_s))
+            filename = nil
+
+            begin
+              raise URI::InvalidURIError if URI.parse(image_uri).scheme.nil?
+              filename = tmp_filename(canvas, image_uri)
+              setup_image_file(canvas, image_uri, filename)
+            rescue URI::InvalidURIError
+              filename = image_uri
+            end
+
+            filename
+          end
+
+          def other_uri_filename(canvas, uri)
+            filename = tmp_filename(canvas, uri.to_s)
+            setup_image_file(canvas, uri, filename)
+            filename
+          end
+
+          def setup_image_file(canvas, uri, filename)
+            begin
+              open(uri, "rb") do |in_file|
+                File.open(filename, "wb") do |out|
+                  out.print(in_file.read)
+                end
+              end
+            rescue SocketError, OpenURI::HTTPError
+              canvas.logger.warn("#{$!.message}: #{uri}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/ext/inline.rb

@@ -0,0 +1,29 @@
+require 'rabbit/element'
+
+module Rabbit
+  module Parser
+    module Ext
+      module Inline
+        include Element
+
+        module_function
+        def sub(text)
+          Subscript.new(text)
+        end
+
+        def sup(text)
+          Superscript.new(text)
+        end
+
+        def note(text)
+          Note.new(text)
+        end
+
+        def lang(lang, text)
+          text.add_default_prop("lang", lang)
+          text
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/ext/tex.rb

@@ -0,0 +1,77 @@
+module Rabbit
+  module Parser
+    module Ext
+      module TeX
+        module_function
+        def make_image_by_LaTeX(path, prop, logger)
+          image_file = Tempfile.new("rabbit-image")
+          latex_file = Tempfile.new("rabbit-image-latex")
+          dir = File.dirname(latex_file.path)
+          base = latex_file.path.sub(/\.[^.]+$/, '')
+          dvi_path = "#{base}.dvi"
+          eps_path = "#{base}.eps"
+          log_path = "#{base}.log"
+          aux_path = "#{base}.aux"
+          File.open(path) do |f|
+            src = []
+            f.each_line do |line|
+              src << line.chomp
+            end
+            latex_file.open
+            latex_file.puts(make_latex_source(src.join("\n"), prop))
+            latex_file.close
+            begin
+              latex_command = ["latex", "-halt-on-error",
+                               "-output-directory=#{dir}", latex_file.path]
+              dvips_command = ["dvips", "-q", "-E", dvi_path, "-o", eps_path]
+              unless SystemRunner.run(*latex_command)
+                raise TeXCanNotHandleError.new(latex_command.join(" "))
+              end
+              unless SystemRunner.run(*dvips_command)
+                raise TeXCanNotHandleError.new(dvips_command.join(" "))
+              end
+              FileUtils.mv(eps_path, image_file.path)
+              image_file
+            ensure
+              FileUtils.rm_f(dvi_path)
+              FileUtils.rm_f(eps_path)
+              FileUtils.rm_f(log_path)
+              FileUtils.rm_f(aux_path)
+            end
+          end
+        end
+
+        def make_image_by_mimeTeX(path, prop, logger)
+          image_file = Tempfile.new("rabbit-image-mimetex")
+          args = ["-e", image_file.path, "-f", path]
+          commands = ["mimetex", "mimetex.cgi"]
+          if commands.any? {|command| SystemRunner.run(command, *args)}
+            image_file
+          else
+            format = _("tried mimeTeX commands: %s")
+            additional_info = format % commands.inspect
+            raise TeXCanNotHandleError.new("mimetex #{args.join(' ')}",
+                                           additional_info)
+          end
+        end
+
+        def make_latex_source(src, prop)
+          latex = "\\documentclass[fleqn]{article}\n"
+          latex << "\\usepackage[latin1]{inputenc}\n"
+          (prop["style"] || "").split.each do |style|
+            latex << "\\usepackage[#{style}]\n"
+          end
+          latex << <<-PREAMBLE
+\\begin{document}
+\\thispagestyle{empty}
+\\mathindent0cm
+\\parindent0cm
+PREAMBLE
+          latex << src
+          latex << "\n\\end{document}\n"
+          latex
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/image.rb

@@ -0,0 +1,34 @@
+require "rabbit/utils"
+
+require "rabbit/image"
+require "rabbit/element"
+require "rabbit/parser/base"
+
+module Rabbit
+  module Parser
+    class Image < Base
+      push_loader(self)
+
+      class << self
+        def match?(source)
+          begin
+            Rabbit::TemporaryFile.make(source.read, "image") do |input|
+              Rabbit::ImageLoader.new(input.path)
+            end
+            true
+          rescue Rabbit::ImageLoadError
+            false
+          end
+        end
+      end
+
+      include Element
+      def parse
+        TemporaryFile.make(@source.read, "image") do |image|
+          @image = image
+          @canvas << ImageTitleSlide.new(@image.path)
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/pause-support.rb

@@ -0,0 +1,32 @@
+module Rabbit
+  module Parser
+    module PauseSupport
+      def pause_targets
+        @pause_targets ||= {}
+      end
+
+      def register_pause(target)
+        pause_targets[@slides.last] ||= []
+        pause_targets[@slides.last] << target
+      end
+
+      def unregister_pause(target)
+        pause_targets[@slides.last] ||= []
+        pause_targets[@slides.last].delete(target)
+      end
+
+      def burn_out_pause_targets
+        @slides.each do |slide|
+          (pause_targets[slide] || []).each do |target|
+            slide.register_default_wait_proc(target.parent) do |*args|
+              target.show do
+                next_proc = args.pop
+                next_proc.call(*args)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/pdf.rb

@@ -0,0 +1,35 @@
+require "tempfile"
+
+require "poppler"
+
+require "rabbit/element"
+require "rabbit/parser/base"
+
+module Rabbit
+  module Parser
+    class PDF < Base
+      unshift_loader(self)
+      class << self
+        def match?(source)
+          /\A%PDF-1\.\d\z/ =~ source.read.split(/\r?\n/, 2)[0]
+        end
+      end
+
+      include Element
+      def parse
+        @pdf = Tempfile.new("rabbit-pdf")
+        @pdf.binmode
+        @pdf.print(@source.read)
+        @pdf.close
+        doc = Poppler::Document.new("file://#{@pdf.path}")
+
+        title_page, *rest = doc.to_a
+
+        @canvas << PopplerTitleSlide.new(title_page, doc)
+        rest.each do |page|
+          @canvas << PopplerSlide.new(page)
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/rd.rb

@@ -0,0 +1,54 @@
+require "rabbit/parser/base"
+
+module Rabbit
+  module Parser
+    class RD < Base
+
+      push_loader(self)
+      class << self
+        def match?(source)
+          /^= /.match(source.read)
+        end
+      end
+
+      def parse
+        source = "=begin\n#{@source.read}\n=end\n"
+        tree = ::RD::RDTree.new(source)
+        visitor = RD2RabbitVisitor.new(@canvas)
+        visitor.visit(tree)
+      rescue Racc::ParseError
+        message = format_parse_error_message($!.message, source)
+        raise ParseError.new, message, $@
+      end
+
+      private
+      def format_parse_error_message(message, source)
+        if /line (\d+):/.match(message)
+          numbered_source = add_number(source, $1.to_i)
+        else
+          numbered_source = add_number(source)
+        end
+        "#{message}\n--\n#{numbered_source}"
+      end
+
+      SNIPPET_SIZE = 10
+      def add_number(source, around=nil)
+        i = 1
+        puts source
+        lines = source.to_a[0..-2]
+        if around
+          i = [1, around - SNIPPET_SIZE].max
+          lines = lines[i, 2 * SNIPPET_SIZE]
+        end
+        format = "%#{Math.log10(lines.size).truncate + 1}d %s"
+
+        lines.collect do |line|
+          i += 1
+          format % [i, line]
+        end.join
+      end
+    end
+  end
+end
+
+require "rabbit/parser/rd/rd2rabbit-lib"

data/lib/rabbit/parser/rd/ext/anthy.rb

@@ -0,0 +1,29 @@
+require 'rabbit/parser/ext/anthy'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        module Anthy
+          include Element
+          include GetText
+
+          def anthy_hiragana_to_kanji(label, source, content, visitor)
+            unless Parser::Ext::Anthy.available?
+              visitor.logger.warn(_("Anthy isn't available"))
+              return nil
+            end
+            src, prop = parse_source(source)
+
+            converted_src = Parser::Ext::Anthy.hiragana_to_kanji(src)
+            tree = ::RD::RDTree.new("=begin\n#{converted_src}\n=end\n")
+            elems = tree.root.children.collect do |child|
+              child.accept(visitor)
+            end
+            Container.new(elems)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/rd/ext/base.rb

@@ -0,0 +1,79 @@
+require 'English'
+require 'erb'
+
+require 'rabbit/element'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        class Base
+          include ERB::Util
+          extend ERB::Util
+
+          include Element
+
+          class << self
+            def inherited(klass)
+              klass.const_set("EXTENSIONS", [])
+            end
+
+            def add_extension(name)
+              extensions.push(name)
+            end
+
+            def extensions
+              self::EXTENSIONS
+            end
+
+            def method_added(name)
+              if /^ext_/ =~ name.to_s
+                add_extension(name.to_s)
+              end
+            end
+          end
+
+          def apply(label, source, content, visitor)
+            result = nil
+            extensions.find do |entry|
+              begin
+                result = __send__(entry, label, source, content, visitor)
+              rescue NameError
+                visitor.logger.error($!)
+                raise
+              end
+            end
+            result
+          end
+
+          def extensions
+            self.class.extensions
+          end
+
+          private
+          def parse_source(source)
+            prop = {}
+            in_src = false
+            src = ""
+            source.each_line do |line|
+              if in_src
+                src << line
+              else
+                case line
+                when /^\s*$/
+                  in_src = true
+                when /^(?:#\s*)?(\S+)\s*=\s*(.+)\s*$/
+                  prop[$1] = $2
+                else
+                  in_src = true
+                  src << line
+                end
+              end
+            end
+            [src, prop]
+          end
+        end
+      end
+    end
+  end
+end