rabbit-qt 0.1.0

data/lib/rabbit/parser/markdown/converter.rb

@@ -0,0 +1,440 @@
+# Copyright (C) 2012-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require "English"
+
+require_relative "../../gettext"
+require_relative "../pause-support"
+require_relative "../ext/blockdiag"
+require_relative "../ext/escape"
+require_relative "../ext/image"
+require_relative "../ext/inline"
+require_relative "../ext/rouge"
+require_relative "../ext/tex"
+require_relative "../ext/video"
+
+module Rabbit
+  module Parser
+    class Markdown
+      class Converter
+        include GetText
+        include Element
+        include PauseSupport
+        include Ext::Video
+
+        def initialize(canvas)
+          @canvas = canvas
+          @slides = []
+          @slide = nil
+          @slide_property_mode = false
+        end
+
+        def convert(element, context=nil)
+          method_name = "convert_#{element.type}"
+          method_name << "_#{context}" if context
+          __send__(method_name, element)
+        end
+
+        private
+        def convert_container(element, context=nil)
+          elements = []
+          element.children.each do |child|
+            element = convert(child, context)
+            case element
+            when nil, :no_element
+              # ignore
+            else
+              elements << element
+            end
+          end
+          elements
+        end
+
+        def convert_root(element)
+          target = nil
+          mode = :ignore
+          convert_container(element).each do |content|
+            case content
+            when :no_element
+              next
+            when nil
+              mode = :ignore
+            when Element::Slide
+              target = content.body
+              @canvas << content
+              mode = :display
+            when TitleSlide
+              target = content
+              @canvas << content
+              mode = :display
+            when SlidePropertySetter, NoteSetter
+              target = content
+              mode = :property
+            else
+              case mode
+              when :display
+                target << content
+              when :property
+                target.apply(content)
+              end
+            end
+          end
+          burn_out_pause_targets
+        end
+
+        def convert_header(element)
+          slide, @slide = @slide, nil
+          contents = convert_container(element)
+          case element.options[:level]
+          when 1
+            if @slides.empty?
+              @slide = TitleSlide.new(Title.new(contents))
+            else
+              @slide = Element::Slide.new(HeadLine.new(contents))
+              @slide << Body.new
+            end
+            @slides << @slide
+            @slide
+          when 2
+            if /\Anote\z/i =~ contents.first.text
+              NoteSetter.new(@slides.last)
+            else
+              SlidePropertySetter.new(@slides.last)
+            end
+          else
+            nil
+          end
+        end
+
+        def text(content)
+          Text.new(Parser::Ext::Escape.escape_meta_character(content))
+        end
+
+        def convert_text(element)
+          text(element.value)
+        end
+
+        def convert_blank(element)
+          :no_element
+        end
+
+        def convert_dl(element)
+          list = DescriptionList.new
+          term = nil
+          content = nil
+          convert_container(element).each do |item|
+            case item
+            when DescriptionTerm
+              list << DescriptionListItem.new(term, content) if term
+              term = item
+            when DescriptionContent
+              content = item
+            end
+          end
+          list << DescriptionListItem.new(term, content) if term
+          list
+        end
+
+        def create_paragraph(elements)
+          paragraph = Paragraph.new(elements)
+          register_pause(paragraph) if paragraph.have_wait_tag?
+          paragraph
+        end
+
+        def convert_dt(element)
+          DescriptionTerm.new(create_paragraph(convert_container(element)))
+        end
+
+        def convert_dd(element)
+          DescriptionContent.new(convert_container(element))
+        end
+
+        def convert_p(element)
+          child_types = element.children.collect {|child| child.type}
+          if child_types == [:img]
+            convert_container(element)[0]
+          else
+            if child_types.count(:img) > 1
+              raise ParseError,
+                    _("multiple ![alt]{image}s in a paragraph isn't supported.")
+            end
+            if child_types.include?(:img)
+              format =
+                _("![alt]{image} and other contents in a paragraph " \
+                  "isn't supported: %{types}")
+              raise ParseError, format % {types: child_types}
+            end
+            if element.options[:transparent] and child_types == [:text]
+              element.children.first.value.chomp!
+            end
+            converted_children = apply_class(convert_container(element),
+                                             element.attr["class"])
+            create_paragraph(converted_children)
+          end
+        end
+
+        def apply_class(children, klass)
+          return children if klass.nil?
+          classes = klass.split
+          classes.inject(children) do |nested_children, klass|
+            CustomTag.new(klass, nested_children)
+          end
+        end
+
+        def create_list(list_class, contents)
+          list = list_class.new
+          contents.each do |content|
+            list << content
+            if block_given?
+              yield(list, content)
+            end
+          end
+          list
+        end
+
+        def create_list_item(list_item_class, contents)
+          list_item = list_item_class.new(contents)
+
+          waited_paragraphs = list_item.elements.find_all do |element|
+            element.is_a?(Paragraph) and element.have_wait_tag?
+          end
+          if waited_paragraphs.empty?
+            list_item.default_visible = true
+            list_item.clear_theme
+          else
+            waited_paragraphs.each do |paragraph|
+              paragraph.default_visible = true
+              paragraph.clear_theme
+              unregister_pause(paragraph)
+            end
+
+            list_item.default_visible = false
+            list_item.clear_theme
+            register_pause(list_item)
+          end
+
+          list_item
+        end
+
+        def convert_ul(element)
+          create_list(ItemList, convert_container(element, "ul"))
+        end
+
+        def convert_li_ul(element)
+          create_list_item(ItemListItem, convert_container(element))
+        end
+
+        def convert_ol(element)
+          i = 1
+          create_list(EnumList, convert_container(element, "ol")) do |list, item|
+            item.order = i
+            i += 1
+          end
+        end
+
+        def convert_li_ol(element)
+          create_list_item(EnumListItem, convert_container(element))
+        end
+
+        def convert_smart_quote(element)
+          Text.new(Parser::Ext::Entity::TABLE[element.value.to_s])
+        end
+
+        def convert_typographic_sym(element)
+          Text.new(Parser::Ext::Entity::TABLE[element.value.to_s])
+        end
+
+        def convert_table(element)
+          table = Table.new
+          convert_container(element).each do |item|
+            table << item
+          end
+          table
+        end
+
+        def convert_thead(element)
+          in_table_header do
+            TableHead.new(convert_container(element))
+          end
+        end
+
+        def in_table_header
+          in_table_header, @in_table_header = @in_table_header, true
+          yield
+        ensure
+          @in_table_header = in_table_header
+        end
+
+        def convert_tbody(element)
+          TableBody.new(convert_container(element))
+        end
+
+        def convert_tr(element)
+          TableRow.new(convert_container(element))
+        end
+
+        def convert_td(element)
+          if @in_table_header
+            header = TableHeader.new(convert_container(element))
+            def header.default_align
+              Pango::Alignment::CENTER
+            end
+            header
+          else
+            TableCell.new(convert_container(element))
+          end
+        end
+
+        def convert_hr(element)
+          raise ParseError, _("horizontal rule isn't supported.")
+        end
+
+        def convert_comment(element)
+          :no_element
+        end
+
+        def convert_codeblock(element)
+          content = element.value.chomp
+          language = detect_codeblock_language(element)
+          if language
+            converted = convert_codeblock_language(element, language, content)
+          end
+          converted || PreformattedBlock.new(PreformattedText.new(text(content)))
+        end
+
+        def detect_codeblock_language(element)
+          lang = element.attr["lang"]
+          return lang if lang
+
+          language = element.attr["language"]
+          return language if language
+
+          klass = element.attr["class"]
+          if klass and /\Alanguage-/ =~ klass
+            return $POSTMATCH
+          end
+
+          nil
+        end
+
+        def convert_codeblock_language(element, language, content)
+          case language
+          when "blockdiag"
+            make_image_from_file(element, content) do |src_file, prop|
+              Ext::BlockDiag.make_image(src_file.path, prop)
+            end
+          when "mermaid"
+            make_image_from_file(element,
+                                 content,
+                                 extension: ".mmd") do |src_file, prop|
+              src_file
+            end
+          when "video"
+            make_video(@canvas, content.strip, element.attr)
+          else
+            Ext::Rouge.highlight(language, content, element.attr)
+          end
+        end
+
+        def convert_blockquote(element)
+          BlockQuote.new(convert_container(element))
+        end
+
+        def convert_img(element)
+          options = element.attr.dup
+          uri = options.delete("src")
+          title = options.delete("title")
+          alt = options.delete("alt")
+          caption = title || alt
+          options["caption"] ||= caption if caption
+          image = Ext::Image.make_image(@canvas,
+                                        uri,
+                                        options,
+                                        body: @slides.last.body)
+          image || text(alt || src)
+        end
+
+        def convert_em(element)
+          Emphasis.new(Emphasis.new(convert_container(element)))
+        end
+
+        def convert_strong(element)
+          Emphasis.new(Emphasis.new(convert_container(element)))
+        end
+
+        def make_image_from_file(element, source, **options)
+          Ext::Image.make_image_from_file(@canvas,
+                                          source,
+                                          body: @slides.last.body,
+                                          **options) do |src_file|
+            prop = element.attr
+            image = yield(src_file, prop)
+            [image, prop]
+          end
+        end
+
+        def convert_math(element)
+          make_image_from_file(element, element.value) do |src_file, prop|
+            Ext::TeX.make_image_by_LaTeX(src_file.path, prop)
+          end
+        end
+
+        def convert_a(element)
+          ref = ReferText.new(convert_container(element))
+          ref.to = element.attr["href"]
+          ref
+        end
+
+        def convert_br(element)
+          Text.new("\n")
+        end
+
+        def convert_codespan(element)
+          Code.new(text(element.value))
+        end
+
+        def convert_wait(element)
+          WaitTag.new
+        end
+
+        def convert_note(element)
+          # TODO: Should we validate element.options[:category] == "span"?
+          Ext::Inline.note(convert_container(element))
+        end
+
+        def convert_tag(element)
+          name = element.attr["name"]
+          if name.nil?
+            raise ParseError, _("tag name is missing.")
+          end
+          if element.children.empty?
+            CustomTag.new(name)
+          else
+            CustomTag.new(name, convert_container(element))
+          end
+        end
+
+        def convert_strikethrough(element)
+          DeletedText.new(text(element.value))
+        end
+
+        def convert_html_element(element)
+          raise ParseError, _("HTML isn't supported.")
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/parser/markdown.rb

@@ -0,0 +1,144 @@
+# Copyright (C) 2012-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require "kramdown"
+require "kramdown-parser-gfm"
+
+require_relative "base"
+
+module Kramdown
+  module Parser
+    class Kramdown
+      alias_method :handle_extension_raw, :handle_extension
+      def handle_extension(name, opts, body, type, line_no=nil)
+        return true if handle_extension_raw(name, opts, body, type, line_no)
+        element = Element.new(name.to_sym,
+                              nil,
+                              opts,
+                              :category => type,
+                              :location => line_no)
+        if body
+          root, warnings = self.class.parse(body, @options)
+          fix_location(root, line_no)
+          if type == :span
+            p_element = root.children.first
+            p_element.children.each do |sub_element|
+              element.children << sub_element
+            end
+          else
+            root.children.each do |sub_element|
+              element.children << sub_element
+            end
+          end
+        end
+        @tree.children << element
+        true
+      end
+
+      alias_method :configure_parser_raw, :configure_parser
+      def configure_parser
+        @span_parsers.unshift(:strikethrough)
+        position = @block_parsers.index(:codeblock_fenced)
+        @block_parsers.insert(position, :codeblock_fenced_gfm)
+
+        configure_parser_raw
+      end
+
+      STRIKETHROUGH_DELIMITER = "~~"
+      STRIKETHROUGH_DELIMITER_PATTERN =
+        /#{Regexp.escape(STRIKETHROUGH_DELIMITER)}/
+      def parse_strikethrough
+        start_line_number = @src.current_line_number
+
+        delimiter = @src.scan(STRIKETHROUGH_DELIMITER_PATTERN)
+        saved_pos = @src.save_pos
+
+        text = @src.scan_until(STRIKETHROUGH_DELIMITER_PATTERN)
+        if text
+          text = text.sub(/#{STRIKETHROUGH_DELIMITER_PATTERN}\Z/, "")
+          @tree.children << Element.new(:strikethrough, text, nil,
+                                        :location => start_line_number)
+        else
+          @src.revert_pos(saved_pos)
+          add_text(delimiter)
+        end
+      end
+      define_parser(:strikethrough,
+                    STRIKETHROUGH_DELIMITER_PATTERN,
+                    STRIKETHROUGH_DELIMITER)
+
+      escaped_chars_start_re =
+        parser(:escaped_chars).start_re.to_s.sub(/(\]\)\))\z/, "~\\1")
+      parser(:escaped_chars).start_re = /#{escaped_chars_start_re}/
+
+
+      parser(:codeblock_fenced_gfm).method = "parse_codeblock_fenced_gfm"
+      def parse_codeblock_fenced_gfm
+        original_match = self.class::FENCED_CODEBLOCK_MATCH
+        begin
+          self.class.send(:remove_const, :FENCED_CODEBLOCK_MATCH)
+          self.class.const_set(:FENCED_CODEBLOCK_MATCH,
+                               GFM::FENCED_CODEBLOCK_MATCH)
+          parse_codeblock_fenced
+        ensure
+          self.class.send(:remove_const, :FENCED_CODEBLOCK_MATCH)
+          self.class.const_set(:FENCED_CODEBLOCK_MATCH, original_match)
+        end
+      end
+
+      private
+      def fix_location(element, base_location)
+        return unless element.options.key?(:location)
+        element.options[:location] += base_location - 1
+        element.children.each do |sub_element|
+          fix_location(sub_element, base_location)
+        end
+      end
+    end
+  end
+end
+
+module Rabbit
+  module Parser
+    class Markdown < Base
+    end
+  end
+end
+
+require_relative "markdown/converter"
+
+module Rabbit
+  module Parser
+    class Markdown
+      unshift_loader(self)
+      class << self
+        def format_name
+          "Makrdown"
+        end
+
+        def match?(source)
+          /\A(?:md|markdown)\z/i =~ source.extension.to_s
+        end
+      end
+
+      def parse
+        document = Kramdown::Document.new(@source.read)
+        converter = Converter.new(@canvas)
+        converter.convert(document.root)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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_target(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,56 @@
+# Copyright (C) 2007-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require "tempfile"
+
+require "poppler"
+
+require_relative "../element"
+require_relative "base"
+
+module Rabbit
+  module Parser
+    class PDF < Base
+      unshift_loader(self)
+      class << self
+        def format_name
+          "PDF"
+        end
+
+        def match?(source)
+          extension = source.extension
+          if extension.nil?
+            source.read.start_with?("%PDF-1.")
+          else
+            /\Apdf\z/i =~ extension
+          end
+        end
+      end
+
+      include Element
+      def parse
+        doc = Poppler::Document.new(:data => @source.read)
+        doc.each_with_index do |page, i|
+          if i.zero?
+            @canvas << PopplerTitleSlide.new(page, doc)
+          else
+            @canvas << PopplerSlide.new(page)
+          end
+        end
+      end
+    end
+  end
+end