rdeck 0.1.0

data/lib/rdeck/markdown/parser.rb

@@ -0,0 +1,449 @@
+# frozen_string_literal: true
+
+require 'commonmarker'
+require 'json'
+
+module Rdeck
+  module Markdown
+    class Parser
+      FRONTMATTER_REGEX = /\A---\n(.*?)\n---\n/m
+      PAGE_SEPARATOR_REGEX = /^-{3,}$/
+
+      attr_reader :base_dir
+
+      def initialize(base_dir = '.')
+        @base_dir = File.expand_path(base_dir)
+      end
+
+      def parse(content, config = nil)
+        content = content.gsub("\r\n", "\n").tr("\r", "\n")
+
+        frontmatter, body = Frontmatter.extract(content)
+        frontmatter = apply_config(frontmatter, config)
+
+        pages = split_pages(body)
+
+        contents = pages.map do |page|
+          parse_page(page, frontmatter)
+        end
+
+        MarkdownDocument.new(frontmatter: frontmatter, contents: contents)
+      end
+
+      def parse_file(path, config = nil)
+        content = File.read(path)
+        @base_dir = File.dirname(File.expand_path(path))
+        parse(content, config)
+      end
+
+      private
+
+      def apply_config(frontmatter, config)
+        return frontmatter unless config
+
+        frontmatter ||= Frontmatter.new
+        frontmatter.breaks = config.breaks if frontmatter.breaks.nil? && !config.breaks.nil?
+        frontmatter.code_block_to_image_command ||= config.code_block_to_image_command
+        frontmatter.defaults = (frontmatter.defaults || []) + (config.defaults || [])
+        frontmatter
+      end
+
+      def split_pages(content)
+        pages = []
+        current_page = []
+        in_code_block = false
+        code_fence_char = nil
+
+        content.lines.each do |line|
+          if line =~ /^(`{3,}|~{3,})/
+            fence = ::Regexp.last_match(1)[0]
+            if !in_code_block
+              in_code_block = true
+              code_fence_char = fence
+            elsif fence == code_fence_char
+              in_code_block = false
+              code_fence_char = nil
+            end
+          end
+
+          if !in_code_block && line.match(PAGE_SEPARATOR_REGEX) && !line.match(/^={3,}$/)
+            pages << current_page.join
+            current_page = []
+          else
+            current_page << line
+          end
+        end
+
+        pages << current_page.join unless current_page.empty?
+        pages
+      end
+
+      def parse_page(content, _frontmatter)
+        page_config, clean_content = extract_page_config(content)
+
+        speaker_note, body_content = extract_speaker_notes(clean_content)
+
+        doc = Commonmarker.parse(body_content, options: {
+                                   extension: { table: true, strikethrough: true },
+                                   parse: { smart: false }
+                                 })
+
+        content_obj = process_ast(doc)
+        content_obj.layout = page_config[:layout] if page_config[:layout]
+        content_obj.freeze = page_config[:freeze] if page_config[:freeze]
+        content_obj.skip = page_config[:skip] if page_config[:skip]
+        content_obj.ignore = page_config[:ignore] if page_config[:ignore]
+        content_obj.speaker_note = speaker_note
+
+        content_obj
+      end
+
+      def extract_page_config(content)
+        config = {}
+        clean_lines = []
+
+        content.lines.each do |line|
+          if line =~ /<!--\s*(\{.*\})\s*-->/
+            json_str = ::Regexp.last_match(1)
+            begin
+              parsed = JSON.parse(json_str, symbolize_names: true)
+              config.merge!(parsed)
+            rescue JSON::ParserError
+              clean_lines << line
+            end
+          else
+            clean_lines << line
+          end
+        end
+
+        [config, clean_lines.join]
+      end
+
+      def extract_speaker_notes(content)
+        notes = []
+        clean_lines = []
+
+        content.lines.each do |line|
+          if line =~ /<!--\s*(.*?)\s*-->/
+            note = ::Regexp.last_match(1).strip
+            notes << note unless note.empty?
+          else
+            clean_lines << line
+          end
+        end
+
+        [notes.join("\n"), clean_lines.join]
+      end
+
+      def process_ast(doc)
+        content = Content.new
+
+        heading_levels = find_heading_levels(doc)
+        title_level = heading_levels.min
+        subtitle_level = title_level ? title_level + 1 : nil
+
+        doc.walk do |node|
+          case node.type
+          when :heading
+            level = node.header_level
+            text_content = extract_text(node)
+
+            if level == title_level
+              content.titles << text_content
+              content.title_bodies << node_to_body(node)
+            elsif level == subtitle_level
+              content.subtitles << text_content
+              content.subtitle_bodies << node_to_body(node)
+            else
+              content.bodies << node_to_body(node)
+            end
+
+          when :paragraph
+            next if node.parent && %i[item list block_quote].include?(node.parent.type)
+
+            content.bodies << node_to_body(node)
+
+          when :list
+            content.bodies << list_to_body(node)
+
+          when :block_quote
+            content.block_quotes << node_to_block_quote(node)
+
+          when :table
+            content.tables << node_to_table(node)
+
+          when :code_block
+            content.code_blocks << extract_code_block(node)
+
+          when :image
+            content.images << node_to_image(node)
+          end
+        end
+
+        content
+      end
+
+      def find_heading_levels(doc)
+        levels = []
+        doc.walk do |node|
+          levels << node.header_level if node.type == :heading
+        end
+        levels.uniq.sort
+      end
+
+      def extract_text(node)
+        text = []
+        node.walk do |child|
+          text << child.string_content if child.type == :text
+        end
+        text.join
+      end
+
+      def node_to_body(node)
+        paragraphs = node_to_paragraphs(node)
+        Body.new(paragraphs: paragraphs)
+      end
+
+      def node_to_paragraphs(node, bullet: Paragraph::BULLET_NONE, nesting: 0)
+        case node.type
+        when :heading, :paragraph
+          fragments = extract_fragments(node)
+          [Paragraph.new(fragments: fragments, bullet: bullet, nesting: nesting)]
+
+        when :text
+          [Paragraph.new(fragments: [Fragment.new(value: node.string_content)], bullet: bullet, nesting: nesting)]
+
+        else
+          []
+        end
+      end
+
+      def extract_fragments(node)
+        fragments = []
+        current_styles = { bold: false, italic: false, code: false, link: '' }
+
+        node.each do |child|
+          fragments.concat(process_inline_node(child, current_styles.dup))
+        end
+
+        fragments
+      end
+
+      def process_inline_node(node, styles)
+        case node.type
+        when :text
+          [Fragment.new(
+            value: node.string_content,
+            bold: styles[:bold],
+            italic: styles[:italic],
+            code: styles[:code],
+            link: styles[:link]
+          )]
+
+        when :strong
+          styles[:bold] = true
+          fragments = []
+          node.each { |child| fragments.concat(process_inline_node(child, styles)) }
+          fragments
+
+        when :emph
+          styles[:italic] = true
+          fragments = []
+          node.each { |child| fragments.concat(process_inline_node(child, styles)) }
+          fragments
+
+        when :code
+          [Fragment.new(
+            value: node.string_content,
+            bold: styles[:bold],
+            italic: styles[:italic],
+            code: true,
+            link: styles[:link]
+          )]
+
+        when :link
+          styles[:link] = node.url
+          fragments = []
+          node.each { |child| fragments.concat(process_inline_node(child, styles)) }
+          fragments
+
+        else
+          []
+        end
+      end
+
+      def list_to_body(node)
+        paragraphs = []
+        process_list_items(node, paragraphs, 0)
+        Body.new(paragraphs: paragraphs)
+      end
+
+      def process_list_items(list_node, paragraphs, nesting)
+        bullet = list_node.list_type == :ordered_list ? Paragraph::BULLET_NUMBERED : Paragraph::BULLET_DASH
+
+        list_node.each do |item|
+          next unless item.type == :item
+
+          item.each do |child|
+            case child.type
+            when :paragraph
+              fragments = extract_fragments(child)
+              paragraphs << Paragraph.new(fragments: fragments, bullet: bullet, nesting: nesting)
+
+            when :list
+              process_list_items(child, paragraphs, nesting + 1)
+            end
+          end
+        end
+      end
+
+      def node_to_block_quote(node)
+        paragraphs = []
+        node.each do |child|
+          paragraphs.concat(node_to_paragraphs(child))
+        end
+        BlockQuote.new(paragraphs: paragraphs, nesting: 0)
+      end
+
+      def node_to_table(node)
+        rows = []
+        is_header = true
+
+        node.each do |row_node|
+          next unless row_node.type == :table_row
+
+          cells = []
+          row_node.each do |cell_node|
+            next unless cell_node.type == :table_cell
+
+            fragments = extract_fragments(cell_node)
+            alignment = cell_alignment(cell_node)
+            cells << TableCell.new(fragments: fragments, alignment: alignment, is_header: is_header)
+          end
+
+          rows << TableRow.new(cells: cells)
+          is_header = false
+        end
+
+        Table.new(rows: rows)
+      end
+
+      def cell_alignment(_cell_node)
+        TableCell::ALIGN_START
+      end
+
+      def extract_code_block(node)
+        {
+          lang: node.fence_info || '',
+          content: node.string_content
+        }
+      end
+
+      def node_to_image(node)
+        url = node.url
+        path = resolve_image_path(url)
+        Image.new(path, from_markdown: true, link: node.title || '')
+      rescue StandardError => e
+        warn "Failed to load image #{url}: #{e.message}"
+        nil
+      end
+
+      def resolve_image_path(url)
+        return url if url.start_with?('http://', 'https://')
+
+        File.join(@base_dir, url)
+      end
+    end
+
+    class MarkdownDocument
+      attr_accessor :frontmatter, :contents
+
+      def initialize(frontmatter: nil, contents: [])
+        @frontmatter = frontmatter
+        @contents = contents
+      end
+
+      def to_slides(code_block_to_image_command = nil)
+        contents.map.with_index do |content, index|
+          content_to_slide(content, index + 1, code_block_to_image_command)
+        end
+      end
+
+      private
+
+      def content_to_slide(content, page_number, code_block_to_image_command)
+        slide = Slide.new(
+          layout: content.layout,
+          freeze: content.freeze,
+          skip: content.skip,
+          titles: content.titles,
+          title_bodies: content.title_bodies,
+          subtitles: content.subtitles,
+          subtitle_bodies: content.subtitle_bodies,
+          bodies: content.bodies,
+          images: content.images,
+          block_quotes: content.block_quotes,
+          tables: content.tables,
+          speaker_note: content.speaker_note
+        )
+
+        apply_defaults(slide, content, page_number)
+
+        if code_block_to_image_command
+          convert_code_blocks_to_images(slide, content.code_blocks,
+                                        code_block_to_image_command)
+        end
+
+        slide
+      end
+
+      def apply_defaults(slide, content, page_number)
+        return unless frontmatter&.defaults
+
+        context = build_context(content, page_number)
+        frontmatter.defaults.each do |default|
+          default.apply_to(slide) if default.evaluate(context)
+        end
+      end
+
+      def build_context(content, page_number)
+        {
+          page: page_number,
+          pageTotal: contents.size,
+          titles: content.titles,
+          subtitles: content.subtitles,
+          bodies: content.bodies.map(&:text),
+          blockQuotes: content.block_quotes.map(&:text),
+          codeBlocks: content.code_blocks,
+          images: content.images,
+          speakerNote: content.speaker_note,
+          headings: {}
+        }
+      end
+
+      def convert_code_blocks_to_images(slide, code_blocks, command); end
+    end
+
+    class Content
+      attr_accessor :layout, :freeze, :skip, :ignore, :titles, :title_bodies, :subtitles, :subtitle_bodies, :bodies,
+                    :images, :block_quotes, :tables, :code_blocks, :speaker_note
+
+      def initialize
+        @layout = ''
+        @freeze = false
+        @skip = false
+        @ignore = false
+        @titles = []
+        @title_bodies = []
+        @subtitles = []
+        @subtitle_bodies = []
+        @bodies = []
+        @images = []
+        @block_quotes = []
+        @tables = []
+        @code_blocks = []
+        @speaker_note = ''
+      end
+    end
+  end
+end

data/lib/rdeck/paragraph.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class Paragraph
+    BULLET_NONE = ''
+    BULLET_DASH = '-'
+    BULLET_NUMBERED = '1'
+
+    attr_accessor :fragments, :bullet, :nesting
+
+    def initialize(fragments: [], bullet: BULLET_NONE, nesting: 0)
+      @fragments = fragments
+      @bullet = bullet
+      @nesting = nesting
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Paragraph)
+
+      bullet == other.bullet &&
+        nesting == other.nesting &&
+        fragments == other.fragments
+    end
+
+    def text
+      fragments.map(&:value).join
+    end
+
+    def empty?
+      fragments.empty? || fragments.all?(&:empty?)
+    end
+  end
+end

data/lib/rdeck/presentation.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class Presentation
+    LAYOUT_STYLE = 'style'
+
+    attr_reader :id, :client
+
+    def initialize(id, client:)
+      @id = id
+      @client = client
+      @presentation = nil
+      @styles = {}
+      @fresh = false
+    end
+
+    def refresh
+      return if @fresh
+
+      @presentation = client.slides_service.get_presentation(id)
+      load_styles
+      @fresh = true
+    end
+
+    def slides_service
+      client.slides_service
+    end
+
+    def drive_service
+      client.drive_service
+    end
+
+    def apply(slides, pages: nil)
+      raise NotImplementedError, 'Presentation#apply will be implemented in Apply class'
+    end
+
+    def list_layouts
+      refresh
+      @presentation.layouts.map { |l| l.layout_properties.display_name }
+    end
+
+    def create_slide(index, layout_name)
+      refresh
+      layout = find_layout(layout_name)
+
+      unless layout
+        warn "Layout '#{layout_name}' not found, using first available layout"
+        layout = @presentation.layouts&.first
+        raise Error, 'No layouts available in presentation' unless layout
+      end
+
+      requests = [
+        {
+          create_slide: {
+            object_id_prop: generate_object_id,
+            insertion_index: index,
+            slide_layout_reference: {
+              layout_id: layout.object_id_prop
+            }
+          }
+        }
+      ]
+
+      batch_update(requests)
+      @fresh = false
+    end
+
+    def delete_slides(indices)
+      return if indices.empty?
+
+      refresh
+      slide_ids = indices.map { |i| @presentation.slides[i].object_id_prop }
+
+      requests = slide_ids.map do |slide_id|
+        {
+          delete_object: {
+            object_id_prop: slide_id
+          }
+        }
+      end
+
+      batch_update(requests)
+      @fresh = false
+    end
+
+    def move_slide(from_index, to_index)
+      refresh
+      slide_id = @presentation.slides[from_index].object_id_prop
+
+      requests = [
+        {
+          update_slides_position: {
+            slide_object_ids: [slide_id],
+            insertion_index: to_index
+          }
+        }
+      ]
+
+      batch_update(requests)
+      @fresh = false
+    end
+
+    def update_title(title)
+      drive_service.update_file(
+        id,
+        Google::Apis::DriveV3::File.new(name: title),
+        supports_all_drives: true
+      )
+    end
+
+    def export_pdf
+      drive_service.export_file(id, 'application/pdf')
+    end
+
+    def self.create(client:, folder_id: nil)
+      presentation = client.slides_service.create_presentation(
+        Google::Apis::SlidesV1::Presentation.new(title: 'Untitled Presentation')
+      )
+
+      if folder_id
+        client.drive_service.update_file(
+          presentation.presentation_id,
+          Google::Apis::DriveV3::File.new,
+          add_parents: folder_id,
+          supports_all_drives: true
+        )
+      end
+
+      new(presentation.presentation_id, client: client)
+    end
+
+    def self.create_from(base_id, client:, folder_id: nil)
+      copied = client.drive_service.copy_file(
+        base_id,
+        Google::Apis::DriveV3::File.new(name: 'Copy of Presentation'),
+        supports_all_drives: true
+      )
+
+      if folder_id
+        client.drive_service.update_file(
+          copied.id,
+          Google::Apis::DriveV3::File.new,
+          add_parents: folder_id,
+          remove_parents: copied.parents&.join(','),
+          supports_all_drives: true
+        )
+      end
+
+      new(copied.id, client: client)
+    end
+
+    def self.list(client)
+      query = "mimeType='application/vnd.google-apps.presentation'"
+      result = client.drive_service.list_files(
+        q: query,
+        order_by: 'modifiedTime desc',
+        page_size: 100,
+        supports_all_drives: true,
+        include_items_from_all_drives: true
+      )
+
+      result.files.map do |file|
+        OpenStruct.new(id: file.id, title: file.name)
+      end
+    end
+
+    def current_slides
+      refresh
+      require_relative 'slide_extractor'
+      extractor = SlideExtractor.new(@presentation)
+      extractor.extract_slides
+    end
+
+    def batch_update(requests)
+      return if requests.empty?
+
+      require_relative 'retry_handler'
+
+      requests.each_slice(1000) do |batch|
+        RetryHandler.with_retry do
+          req = Google::Apis::SlidesV1::BatchUpdatePresentationRequest.new(requests: batch)
+          slides_service.batch_update_presentation(id, req)
+        end
+      end
+
+      @fresh = false
+    end
+
+    def find_layout(name)
+      return nil unless @presentation&.layouts
+
+      @presentation.layouts.find do |layout|
+        layout.layout_properties&.display_name == name
+      end
+    end
+
+    private
+
+    def load_styles
+      @styles = {}
+      return unless @presentation.layouts
+
+      style_layout = @presentation.layouts.find do |layout|
+        layout.layout_properties.display_name == LAYOUT_STYLE
+      end
+
+      nil unless style_layout
+    end
+
+    def generate_object_id
+      "obj_#{Time.now.to_i}_#{rand(100_000)}"
+    end
+  end
+end
+
+require 'ostruct'