rabbit 0.6.2

data/lib/rabbit/parser/rd/ext/block-verbatim.rb

@@ -0,0 +1,103 @@
+require "tempfile"
+
+require 'rabbit/rabbit'
+require 'rabbit/utils'
+begin
+  require 'rabbit/parser/rd/rt/rt2rabbit-lib'
+rescue LoadError
+end
+require 'rabbit/parser/rd/ext/base'
+require 'rabbit/parser/rd/ext/image'
+require 'rabbit/parser/rd/ext/enscript'
+require 'rabbit/parser/rd/ext/tex'
+require 'rabbit/parser/rd/ext/anthy'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        class BlockVerbatim < Base
+          include Image
+          include Enscript
+          include TeX
+          include Anthy
+          include GetText
+
+          def default_ext_block_verbatim(label, source, content, visitor)
+            content = visitor.apply_to_String(content.rstrip)
+            text = Text.new(content)
+            PreformattedBlock.new(PreformattedText.new(text))
+          end
+
+          def ext_block_verb_quote(label, source, content, visitor)
+            return nil unless /^_$/i =~ label
+            default_ext_block_verbatim("", source, source, visitor)
+          end
+
+          def ext_block_verb_img(label, source, content, visitor)
+            return nil unless /^(?:image|img)$/i =~ label
+            src, prop = parse_source(source)
+            return nil if prop['src'].nil?
+            make_image(visitor, prop['src'], prop)
+          end
+
+          def ext_block_verb_enscript(label, source, content, visitor)
+            return nil unless /^enscript (\w+)$/i =~ label
+            lang = $1.downcase.untaint
+            enscript_block(label, lang, source, content, visitor)
+          end
+
+          def ext_block_verb_anthy(label, source, content, visitor)
+            return nil unless /^anthy$/i =~ label
+            anthy_hiragana_to_kanji(label, source, content, visitor)
+          end
+
+          def ext_block_verb_LaTeX(label, source, content, visitor)
+            return nil unless /^LaTeX$/i =~ label
+            make_image_by_LaTeX(source, visitor)
+          end
+
+          def ext_block_verb_mimeTeX(label, source, content, visitor)
+            return nil unless /^mimeTeX$/i =~ label
+            make_image_by_mimeTeX(source, visitor)
+          end
+
+          def ext_block_verb_rt(label, source, content, visitor)
+            return nil unless /^rt$/i =~ label
+            unless defined?(RT2RabbitVisitor)
+              visitor.logger.warn(_("RTtool isn't available"))
+              return nil
+            end
+            rt_visitor = RT2RabbitVisitor.new(visitor)
+            rt_visitor.visit(RT::RTParser.parse(content))
+          end
+
+          def ext_block_verb_block_quote(label, source, content, visitor)
+            return nil unless /^blockquote$/i =~ label
+            src, prop = parse_source(source)
+            tree = ::RD::RDTree.new("=begin\n#{src}\n=end\n")
+            elems = tree.root.children.collect do |child|
+              child.accept(visitor)
+            end
+            BlockQuote.new(elems, prop)
+          end
+
+          def ext_block_verb_wait(label, source, content, visitor)
+            return nil unless /^wait$/i =~ label
+
+            src, prop = parse_source(source)
+            tree = ::RD::RDTree.new("=begin\n#{src}\n=end\n")
+
+            wait_block = WaitBlock.new
+            visitor.register_pause(wait_block)
+
+            tree.root.children.each do |child|
+              wait_block << child.accept(visitor)
+            end
+            wait_block
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'rabbit/parser/ext/enscript'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        module Enscript
+          include GetText
+
+          def enscript_block(label, lang, source, content, visitor)
+            src, prop = parse_source(source)
+            logger = visitor.logger
+
+            result = nil
+            if Parser::Ext::Enscript.check_availability(lang, logger)
+              result = Parser::Ext::Enscript.highlight(lang, src, logger)
+            end
+            result || default_ext_block_verbatim(label, src, src, visitor)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'rabbit/element'
+require 'rabbit/parser/ext/entity'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        module Entity
+          include Element
+
+          class << self
+            def included(mod)
+              self.instance_methods.each do |meth|
+                mod.method_added(meth)
+              end
+            end
+          end
+
+          TABLE = Parser::Ext::Entity::TABLE
+          def ext_inline_verb_entity_reference(label, source, content, visitor)
+            label = label.to_s
+            return nil unless /^&([^;]+);(.*)$/ =~ label
+            return nil unless TABLE.include?($1)
+
+            key = $1
+            rest = $2
+            if rest.empty?
+              Text.new(TABLE[key])
+            else
+              rest = visitor.apply_to_Verb(::RD::Verb.new(rest))
+              TextContainer.new([Text.new(TABLE[key]), rest])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'rabbit/element'
+require 'rabbit/parser/ext/image'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        module Image
+          include Parser::Ext::Image
+
+          def img(label, content, visitor)
+            label = label.to_s
+            return nil unless /^img:\s*(.+)$/ =~ label
+            make_image(visitor.canvas, $1)
+          end
+
+          def make_image_from_file(source, visitor)
+            src, prop = parse_source(source)
+            super(visitor.canvas, src) do |src_file_path|
+              [yield(src_file_path, prop), prop]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/rd/ext/inline-verbatim.rb

@@ -0,0 +1,89 @@
+require 'rabbit/utils'
+require 'rabbit/parser/ext/inline'
+require 'rabbit/parser/rd/ext/base'
+require 'rabbit/parser/rd/ext/image'
+require 'rabbit/parser/rd/ext/entity'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        class InlineVerbatim < Base
+          extend Utils
+          include Image
+          include Entity
+
+          Inline = Parser::Ext::Inline
+
+          def default_ext_inline_verbatim(label, source, content, visitor)
+            Verbatim.new(Text.new(source))
+          end
+
+#           def ext_inline_verb_img(label, content, visitor)
+#             img(label, content, visitor)
+#           end
+
+          def ext_inline_verb_quote(label, source, content, visitor)
+            label = label.to_s
+            return nil unless /^quote:(.*)$/ =~ label
+            default_ext_inline_verb($1, visitor.apply_to_String($1), $1, visitor)
+          end
+
+          def ext_inline_verb_del(label, source, content, visitor)
+            label = label.to_s
+            return nil unless /^del:(.*)$/ =~ label
+            DeletedText.new(Text.new(visitor.apply_to_String($1)))
+          end
+
+          def ext_inline_verb_sub(label, source, content, visitor)
+            label = label.to_s
+            return nil unless /^sub:(.*)$/ =~ label
+            sub_text = $1
+            if /\A\s*\z/ =~ sub_text
+              sub_text = Text.new(sub_text)
+            else
+              sub_text = visitor.apply_to_Verb(::RD::Verb.new(sub_text))
+            end
+            Inline.sub(sub_text)
+          end
+
+          def ext_inline_verb_sup(label, source, content, visitor)
+            label = label.to_s
+            return nil unless /^sup:(.*)$/ =~ label
+            sup_text = $1
+            if /\A\s*\z/ =~ sup_text
+              sup_text = Text.new(sup_text)
+            else
+              sup_text = visitor.apply_to_Verb(::RD::Verb.new(sup_text))
+            end
+            Inline.sup(sup_text)
+          end
+
+          def ext_inline_verb_note(label, source, content, visitor)
+            label = label.to_s
+            return nil unless /^note:(.*)$/ =~ label
+            target = $1
+            if /^\w+:/ =~ target
+              target = visitor.apply_to_Verb(::RD::Verb.new(target))
+            else
+              target = Text.new(visitor.apply_to_String(target))
+            end
+            Inline.note(target)
+          end
+
+          def ext_inline_verb_lang(label, source, content, visitor)
+            label = label.to_s
+            return nil unless /^lang:([a-z]{2,2}):(.*)$/ =~ label
+            Inline.lang($1, Text.new(visitor.apply_to_String($2)))
+          end
+
+          def ext_inline_verb_wait(label, source, content, visitor)
+            label = label.to_s
+            return nil unless /^wait$/ =~ label
+            WaitTag.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'rabbit/parser/rd/ext/base'
+require 'rabbit/parser/rd/ext/image'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        class Refer < Base
+          include Image
+
+          def default_ext_refer(label, source, content, visitor)
+            ref = ReferText.new(content)
+            ref.to = label.element_label
+            ref
+          end
+
+          # For backward compatibility.
+#         def ext_refer_img(label, content, visitor)
+#           img(label, content, visitor)
+#         end
+
+          def ext_refer_quote(label, source, content, visitor)
+            return nil unless /^quote:(.*)$/ =~ label.element_label
+            quoted_name = $1
+            quoted_label = ::RD::Reference::RDLabel.new(quoted_name,
+                                                        label.filename)
+            source = quoted_label.to_s if label.to_s == source
+            default_ext_refer(quoted_label, source, content)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'rabbit/parser/ext/tex'
+
+module Rabbit
+  module Parser
+    class RD
+      module Ext
+        module TeX
+          def make_image_by_LaTeX(source, visitor)
+            make_image_from_file(source, visitor) do |src_file_path, prop|
+              Parser::Ext::TeX.make_image_by_LaTeX(src_file_path, prop, visitor)
+            end
+          end
+
+          def make_image_by_mimeTeX(source, visitor)
+            make_image_from_file(source, visitor) do |src_file_path, prop|
+              Parser::Ext::TeX.make_image_by_mimeTeX(src_file_path, prop,
+                                                     visitor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/rd/rd2rabbit-lib.rb

@@ -0,0 +1,424 @@
+require "forwardable"
+
+require "rabbit/element"
+require 'rabbit/parser/pause-support'
+require 'rabbit/parser/ext/escape'
+require 'rabbit/parser/rd/visitor'
+require "rabbit/parser/rd/ext/refer"
+require "rabbit/parser/rd/ext/inline-verbatim"
+require "rabbit/parser/rd/ext/block-verbatim"
+
+module Rabbit
+  module Parser
+    class RD
+      class RD2RabbitVisitor < Visitor
+        extend Forwardable
+
+        include ::RD::MethodParse
+        include Element
+        include PauseSupport
+
+        SYSTEM_NAME = "RD2RabbitLVisitor"
+        SYSTEM_VERSION = "0.0.2"
+        VERSION = ::RD::Version.new_from_version_string(SYSTEM_NAME,
+                                                        SYSTEM_VERSION)
+
+        # must-have constants
+        OUTPUT_SUFFIX = ""
+        INCLUDE_SUFFIX = ["rabbit", "rb"]
+
+        EXTENSIONS = {
+          "refer" => Ext::Refer,
+          "inline_verbatim" => Ext::InlineVerbatim,
+          "block_verbatim" => Ext::BlockVerbatim,
+        }
+
+        def_delegators(:@canvas, :logger, :full_path, :tmp_dir_name)
+
+        attr_reader :canvas
+        def initialize(canvas)
+          @canvas = canvas
+
+          @slides = []
+          @slide = nil
+          @slide_property_mode = false
+          @index = {}
+
+          init_extensions
+          super()
+        end
+
+        def visit(tree)
+          prepare_labels(tree, "label-")
+          prepare_footnotes(tree)
+          super(tree)
+        end
+
+        def apply_to_DocumentElement(element, contents)
+          target = nil
+          mode = :ignore
+          contents.each do |content|
+            case content
+            when nil
+              mode = :ignore
+            when Slide
+              target = Body.new
+              content << target
+              @canvas << content
+              mode = :display
+            when TitleSlide
+              target = content
+              @canvas << content
+              mode = :display
+            when SlidePropertySetter
+              target = content
+              mode = :property
+            else
+              case mode
+              when :display
+                target << content
+              when :property
+                target.apply(content)
+              end
+            end
+          end
+          burn_out_pause_targets
+          burn_out_foot_texts
+        end
+
+        def apply_to_Headline(element, title)
+          anchor = get_anchor(element)
+          slide, @slide = @slide, nil
+          case element.level
+          when 1
+            if @slides.empty?
+              @slide = TitleSlide.new(Title.new(title))
+            else
+              @slide = Slide.new(HeadLine.new(title))
+            end
+            @foot_texts << []
+            @slides << @slide
+            @slide
+          when 2
+            SlidePropertySetter.new(slide)
+          else
+            nil
+          end
+        end
+
+        def apply_to_Include(element)
+          paths = element.tree.include_paths
+          fname = search_file(element.filename, paths, @include_suffix)
+          if fname
+            File.open(fname) do |f|
+              instance_eval(f.read, fname, 0)
+            end
+          end
+        end
+
+        def apply_to_TextBlock(element, content)
+          paragraph = Paragraph.new(content)
+          register_pause(paragraph) if paragraph.have_wait_tag?
+          paragraph
+        end
+
+        def apply_to_Verbatim(element)
+          content = []
+          element.each_line do |line|
+            content << line
+          end
+          content_str = content.join("")
+          /\A#\s*([^\n]+)(?:\n)?(?m:(.*)?)\z/ =~ content_str
+          apply_to_extension("block_verbatim", $1, $2.to_s, content_str)
+        end
+
+        def apply_to_ItemList(element, items)
+          apply_to_List(element, items, ItemList)
+        end
+
+        def apply_to_EnumList(element, items)
+          i = 1
+          apply_to_List(element, items, EnumList) do |list, item|
+            item.order = i
+            i += 1
+          end
+        end
+
+        def apply_to_DescList(element, items)
+          apply_to_List(element, items, DescriptionList)
+        end
+
+        def apply_to_MethodList(element, items)
+          apply_to_List(element, items, MethodList)
+        end
+
+        def apply_to_List(element, items, klass)
+          list = klass.new()
+          items.each do |item|
+            list << item
+            if block_given?
+              yield(list, item)
+            end
+          end
+          list
+        end
+
+        def apply_to_ItemListItem(element, content)
+          apply_to_ListItem(element, content, ItemListItem.new)
+        end
+
+        def apply_to_EnumListItem(element, content)
+          apply_to_ListItem(element, content, EnumListItem.new)
+        end
+
+        def apply_to_DescListItem(element, term, description)
+          desc_term = DescriptionTerm.new(Paragraph.new(term))
+          desc_content = DescriptionContent.new
+          apply_to_ListItem(element, description, desc_content)
+          DescriptionListItem.new(desc_term, desc_content)
+        end
+
+        def apply_to_MethodListItem(element, term, description)
+          method_term = parse_method(term)
+          method_description = MethodDescription.new
+          apply_to_ListItem(element, description, method_description)
+          MethodListItem.new(method_term, method_description)
+        end
+
+        def apply_to_ListItem(element, contents, item)
+          contents.each do |content|
+            item << content
+          end
+          waited_paragraphs = item.elements.find_all do |element|
+            element.is_a?(Paragraph) and element.have_wait_tag?
+          end
+          unless waited_paragraphs.empty?
+            waited_paragraphs.each do |paragraph|
+              paragraph.default_visible = true
+              paragraph.clear_theme
+              unregister_pause(paragraph)
+            end
+
+            item.default_visible = false
+            item.clear_theme
+            register_pause(item)
+          end
+          item
+        end
+
+        def apply_to_StringElement(element)
+          content = element.content.gsub(/\n\s*/, '')
+          Text.new(apply_to_String(content))
+        end
+
+        def apply_to_Emphasis(element, content)
+          Emphasis.new(content)
+        end
+
+        def apply_to_Code(element, content)
+          Code.new(content)
+        end
+
+        def apply_to_Var(element, content)
+          Variable.new(content)
+        end
+
+        def apply_to_Keyboard(element, content)
+          Keyboard.new(content)
+        end
+
+        def apply_to_Index(element, content)
+          Index.new(content)
+        end
+
+        def apply_to_Reference_with_RDLabel(element, content)
+          source = content.collect{|elem| elem.text}
+          apply_to_extension("refer", element.label, source, content)
+        end
+
+        def apply_to_Reference_with_URL(element, content)
+          ref = ReferText.new(content)
+          ref.to = element.label.url
+          ref
+        end
+
+        def apply_to_Footnote(element, content)
+          if @slide.nil?
+            Text.new("")
+          else
+            num = get_footnote_num(element)
+            unless num
+              raise ArgumentError, "[BUG?] #{element} is not registered."
+            end
+            add_foot_text(num, content)
+            Footnote.new(num)
+          end
+        end
+
+        def apply_to_Foottext(element, content)
+          num = get_footnote_num(element)
+          raise ArgumentError, "[BUG] #{element} isn't registered." unless num
+          FootText.new(num, content)
+        end
+
+        def apply_to_Verb(element)
+          source = apply_to_String(element.content)
+          content = element.content
+          apply_to_extension("inline_verbatim", element.to_label,
+                             source, content)
+        end
+
+        def apply_to_String(str)
+          Parser::Ext::Escape.escape_meta_character(str)
+        end
+
+        def create_have_text_element(klass, content)
+          raise "Why???" if content.size > 1
+          klass.new(content.collect{|x| x.text}.join(""))
+        end
+
+        private
+        def prepare_footnotes(tree)
+          @footnotes = tree.find_all{|i| i.is_a? ::RD::Footnote}
+          @foot_texts = []
+        end
+
+        def get_footnote_num(fn)
+          unless fn.is_a?(::RD::Footnote)
+            raise ArgumentError, "#{fn} must be Footnote."
+          end
+          i = @footnotes.index(fn)
+          if i
+            i + 1
+          else
+            nil
+          end
+        end
+
+        def parse_method(method)
+          klass, kind, method, args = ::RD::MethodParse.analize_method(method)
+
+          term = MethodTerm.new
+
+          if kind == :function
+            klass = kind = nil
+          else
+            kind = ::RD::MethodParse.kind2str(kind)
+          end
+
+          case method
+          when "self"
+            klass, kind, method, args = ::RD::MethodParse.analize_method(args)
+
+            term = make_pre_inited_method_term(klass, kind)
+            term << MethodName.new(Text.new("self"))
+            add_args_to_method_term(term, args)
+            term
+          when "[]"
+            args.strip!
+            args.sub!(/^\((.*)\)$/, '\\1')
+            args.split(/,/)
+            term = make_pre_inited_method_term(klass, kind)
+            term << MethodName.new(Text.new("["))
+            args.each do |arg|
+              term << Variable.new(Text.new(arg))
+            end
+            term << MethodName.new(Text.new("] = "))
+            term
+          when "[]="
+            args.tr!(' ', '')
+            args.sub!(/^\((.*)\)$/, '\\1')
+            ary = args.split(/,/)
+
+            case ary.length
+            when 1
+              args = []
+              val = 'val'
+            when 2
+              args, val = *ary
+              args = [Variable.new(Text.new(args))]
+            when 3
+              args = ary[0, 2].inject([]) do |result, x|
+                result + [Variable.new(Text.new(x)), Code.new(Text.new(", "))]
+              end
+              args.pop # removed too much ", "
+              val = ary[2]
+            end
+
+            term = make_pre_inited_method_term(klass, kind)
+            term << MethodName.new(Text.new("["))
+            args.each do |arg|
+              term << arg
+            end
+            term << MethodName.new(Text.new("] = "))
+            term << Variable.new(Text.new(val))
+            term
+          else
+            term = make_pre_inited_method_term(klass, kind)
+            term << MethodName.new(Text.new(method))
+            term.name = method
+            add_args_to_method_term(term, args)
+            term
+          end
+        end
+
+        def make_pre_inited_method_term(klass, kind)
+          term = MethodTerm.new
+          term << ClassName.new(Text.new(klass)) if klass
+          term << MethodKind.new(Text.new(kind)) if kind
+          term
+        end
+
+        def add_args_to_method_term(term, args)
+          first = true
+          prev_index = 0
+          args.scan(/(?:&#?)?\w+;?/) do |m|
+            code = $PREMATCH[prev_index..-1]
+            term << Code.new(Text.new(code)) unless code.empty?
+            prev_index = $PREMATCH.size + m.size
+            if /(?:&#?)\w+;/ =~ m
+              term << Code.new(Text.new(m))
+            else
+              term << Variable.new(Text.new(m))
+            end
+          end
+          term << Code.new(Text.new($POSTMATCH)) if $POSTMATCH
+          term
+        end
+
+        def add_foot_text(num, foot_text)
+          unless @footnotes[num - 1]
+            raise ArgumentError, "[BUG] footnote ##{num} isn't here."
+          end
+          @foot_texts.last << [foot_text, num - 1]
+        end
+
+        def burn_out_foot_texts
+          @slides.each do |slide|
+            ftb = FootTextBlock.new
+            current_foot_texts = @foot_texts.shift
+            while ft_info = current_foot_texts.shift
+              ft, num = ft_info
+              ftb << apply_to_Foottext(@footnotes[num], ft)
+            end
+            slide << ftb
+          end
+        end
+
+        class SlidePropertySetter
+          def initialize(slide)
+            @slide = slide
+          end
+
+          def apply(element)
+            return unless element.is_a?(Element::DescriptionList)
+            element.each do |item|
+              name = Parser.normalize_property_name(item.term.text)
+              @slide[name] = item.content.text.strip
+            end
+          end
+        end
+      end
+    end
+  end
+end