rdeck 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: da13cdf307d357991ee63bb6b0809c37c72aad4bc535b0e3b2daaccf17af17d7
+  data.tar.gz: 224b8810ab80919eb2f84c27046d11bfa2ea71b80e4be8ff0f9c241291546864
+SHA512:
+  metadata.gz: 935940ebb52fb91f3c7fdb731be78e590de4fb307211e4d28a77d2b20277075aed4fae17cad1cfb63deb9fa0a6e9f26a6a398889befb7805a5b2e6f9160f5176
+  data.tar.gz: f2fc4b8a1238cf719940dd2f99e4cedd60139e01d179378ab2f11d9a47dde3b862019360821acea77e3966a4fd8aaf17dcf8a42dd202d095839894fbaecfa488

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0 - 2025-12-27
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,290 @@
+# Rdeck
+
+Rdeck is a Ruby CLI tool that converts Markdown presentations to Google Slides, enabling continuous deck creation with content and design separation.
+
+This is a Ruby implementation of the [deck](https://github.com/k1LoW/deck) tool originally written in Go.
+
+## Features
+
+- Convert Markdown files to Google Slides presentations
+- Support for CommonMark and GitHub Flavored Markdown (GFM)
+- Automatic slide layout detection
+- Support for images, tables, and block quotes
+- Code blocks with syntax highlighting (via external command)
+- Incremental updates - only modify changed slides
+- File watching mode for live updates
+- Custom style support
+- Multiple authentication methods (OAuth2, Service Account, ADC)
+- Profile support for multiple Google accounts
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rdeck'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install rdeck
+```
+
+## Prerequisites
+
+### Google Cloud Setup
+
+1. Create a project in [Google Cloud Console](https://console.cloud.google.com/)
+2. Enable the Google Slides API and Google Drive API
+3. Create OAuth2 credentials or a Service Account
+4. Download the credentials file
+
+### System Dependencies
+
+- Ruby 3.1.0 or higher
+- libvips (for image processing)
+
+On macOS:
+```bash
+brew install vips
+```
+
+On Ubuntu/Debian:
+```bash
+sudo apt-get install libvips-dev
+```
+
+## Usage
+
+### Create a New Presentation
+
+```bash
+# Create a blank presentation
+$ rdeck new
+
+# Create with a title and save ID to markdown file
+$ rdeck new deck.md -t "My Presentation"
+
+# Create from a base template
+$ rdeck new deck.md -t "My Presentation" -b <base-presentation-id>
+```
+
+### Apply Markdown to Slides
+
+```bash
+# Apply markdown to presentation
+$ rdeck apply deck.md
+
+# Specify presentation ID via command line
+$ rdeck apply deck.md -i <presentation-id>
+
+# Apply specific pages
+$ rdeck apply deck.md -p 1,3-5
+
+# Watch mode - automatically apply on file changes
+$ rdeck apply deck.md -w
+```
+
+### Other Commands
+
+```bash
+# List your presentations
+$ rdeck ls
+
+# List available layouts
+$ rdeck ls-layouts deck.md
+
+# Open presentation in browser
+$ rdeck open deck.md
+
+# Export to PDF
+$ rdeck export deck.md -o presentation.pdf
+
+# Check environment and configuration
+$ rdeck doctor
+```
+
+## Markdown Format
+
+### Basic Structure
+
+```markdown
+---
+presentationID: your-presentation-id
+title: My Presentation
+---
+
+# First Slide Title
+
+This is the content of the first slide.
+
+---
+
+## Second Slide
+
+- Bullet point 1
+- Bullet point 2
+  - Nested bullet
+
+---
+
+# Slide with Image
+
+![alt text](path/to/image.png)
+
+---
+
+# Slide with Table
+
+| Header 1 | Header 2 |
+|----------|----------|
+| Cell 1   | Cell 2   |
+| Cell 3   | Cell 4   |
+```
+
+### Frontmatter Options
+
+```yaml
+---
+presentationID: your-presentation-id  # Required for apply
+title: My Presentation
+breaks: true  # Treat single line breaks as <br>
+codeBlockToImageCommand: "command to convert code"
+defaults:
+  - if: page == 1
+    layout: title
+  - if: titles.size() == 0
+    layout: blank
+---
+```
+
+### Page Configuration
+
+Use HTML comments with JSON to configure individual pages:
+
+```markdown
+<!-- {"layout": "title-and-body"} -->
+<!-- {"freeze": true} -->
+<!-- {"skip": true} -->
+
+# Slide Title
+
+Content here
+
+<!-- This is a speaker note -->
+```
+
+### Supported Markdown Features
+
+- **Headers** (H1-H6): Mapped to title, subtitle, or body based on hierarchy
+- **Bold** and *italic* text
+- [Links](https://example.com)
+- `Inline code`
+- Bullet lists (ordered and unordered)
+- Nested lists
+- > Block quotes
+- Tables
+- Images
+- ~~Strikethrough~~
+- Horizontal rules (for page breaks: `---`)
+
+## Configuration
+
+Configuration files are located at:
+- `~/.config/rdeck/config.yml`
+- `~/.config/rdeck/config-{profile}.yml` (for profiles)
+
+Example configuration:
+
+```yaml
+# Base presentation to copy from
+basePresentationID: "abc123..."
+
+# Default folder for new presentations
+folderID: "xyz789..."
+
+# Default line break behavior
+breaks: true
+
+# Command to convert code blocks to images
+codeBlockToImageCommand: "code2img"
+
+# Default conditions for layout selection
+defaults:
+  - if: page == 1
+    layout: title
+  - if: titles.size() == 1 && headings[2].size() == 1
+    layout: section
+```
+
+## Authentication
+
+### OAuth2 (Default)
+
+1. Download OAuth2 credentials from Google Cloud Console
+2. Save to `~/.local/share/rdeck/credentials.json`
+3. Run any rdeck command - you'll be prompted to authorize
+
+### Service Account
+
+```bash
+export RDECK_SERVICE_ACCOUNT_KEY='{ "type": "service_account", ... }'
+rdeck apply deck.md
+```
+
+### Application Default Credentials
+
+```bash
+export RDECK_ENABLE_ADC=1
+rdeck apply deck.md
+```
+
+### Access Token
+
+```bash
+export RDECK_ACCESS_TOKEN="ya29...."
+rdeck apply deck.md
+```
+
+## Profiles
+
+Use profiles to manage multiple Google accounts:
+
+```bash
+# Use a specific profile
+rdeck apply deck.md --profile work
+
+# Profile files
+~/.config/rdeck/config-work.yml
+~/.local/share/rdeck/credentials-work.json
+~/.local/state/rdeck/token-work.json
+```
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+bundle exec rake spec  # Run tests
+bundle exec rdeck      # Run CLI
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ydah/rdeck.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Acknowledgments
+
+This project is a Ruby port of [deck](https://github.com/k1LoW/deck) by k1LoW. The original Go implementation provided the specification and inspiration for this Ruby version.

data/exe/rdeck

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'rdeck'
+
+Rdeck::CLI.start(ARGV)

data/lib/rdeck/action_generator.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class ActionGenerator
+    Action = Struct.new(:type, :index, :move_to_index, :slide, keyword_init: true)
+
+    # Similarity scoring constants
+    SCORE_EXACT_MATCH = 500
+    SCORE_LAYOUT_MATCH = 50
+    SCORE_TITLES_MATCH = 80
+    SCORE_SUBTITLES_MATCH = 20
+    SCORE_BODIES_MATCH = 160
+    SCORE_IMAGES_MATCH = 40
+    SCORE_BLOCK_QUOTES_MATCH = 30
+    SCORE_TABLES_MATCH = 35
+    SCORE_SAME_POSITION_WITH_LAYOUT = 8
+    SCORE_EARLIER_POSITION_WITH_LAYOUT = 6
+    SCORE_LATER_POSITION_WITH_LAYOUT = 4
+    SCORE_FALLBACK_WITH_LAYOUT = 2
+    SCORE_SAME_POSITION_WITHOUT_LAYOUT = 4
+    SCORE_LATER_POSITION_WITHOUT_LAYOUT = 2
+
+    def generate(before, after)
+      before_copy = deep_copy(before)
+      after_copy = deep_copy(after)
+
+      adjusted_before, adjusted_after = adjust_slide_count(before_copy, after_copy)
+
+      apply_freeze_marks(adjusted_before, adjusted_after)
+
+      mapping = map_slides(adjusted_before, adjusted_after)
+
+      apply_delete_marks(adjusted_before, adjusted_after, mapping)
+
+      actions = []
+
+      actions += generate_append_actions(adjusted_before)
+
+      actions += generate_update_actions(adjusted_before, adjusted_after, mapping)
+
+      actions += generate_delete_actions(adjusted_before, mapping)
+
+      cleaned_after = remove_delete_marked(adjusted_after)
+      actions += generate_move_actions(adjusted_before, cleaned_after, mapping)
+
+      actions
+    end
+
+    private
+
+    def deep_copy(slides)
+      slides.map(&:dup)
+    end
+
+    def adjust_slide_count(before, after)
+      size_diff = after.size - before.size
+
+      if size_diff.positive?
+        size_diff.times do
+          slide = Slide.new
+          slide.new_slide = true
+          before << slide
+        end
+      elsif size_diff.negative?
+        (-size_diff).times do
+          after << Slide.new
+        end
+      end
+
+      [before, after]
+    end
+
+    def apply_freeze_marks(before, after)
+      before.each_with_index do |slide, i|
+        after[i].freeze = true if slide.freeze
+      end
+    end
+
+    def map_slides(before, after)
+      n = before.size
+      return {} if n.zero?
+
+      similarity_matrix = Array.new(n) { Array.new(n, 0) }
+      n.times do |i|
+        n.times do |j|
+          similarity_matrix[i][j] = calculate_similarity(before[i], after[j], i, j)
+        end
+      end
+
+      require_relative 'hungarian'
+      hungarian = Hungarian.new(similarity_matrix)
+      hungarian.solve
+    end
+
+    def calculate_similarity(slide1, slide2, idx1, idx2)
+      return SCORE_EXACT_MATCH if slide1 == slide2
+
+      score = 0
+
+      if slide1.layout == slide2.layout && !slide1.layout.empty?
+        score += SCORE_LAYOUT_MATCH
+
+        score += SCORE_TITLES_MATCH if slide1.titles == slide2.titles && !slide1.titles.empty?
+        score += SCORE_SUBTITLES_MATCH if slide1.subtitles == slide2.subtitles && !slide1.subtitles.empty?
+        score += SCORE_BODIES_MATCH if slide1.bodies == slide2.bodies
+        score += SCORE_IMAGES_MATCH if images_equivalent?(slide1.images, slide2.images)
+        score += SCORE_BLOCK_QUOTES_MATCH if slide1.block_quotes == slide2.block_quotes
+        score += SCORE_TABLES_MATCH if slide1.tables == slide2.tables
+      end
+
+      if slide1.layout == slide2.layout && !slide1.layout.empty?
+        score += if idx1 == idx2
+                   SCORE_SAME_POSITION_WITH_LAYOUT
+                 elsif idx2 < idx1
+                   SCORE_EARLIER_POSITION_WITH_LAYOUT
+                 elsif idx1 < idx2
+                   SCORE_LATER_POSITION_WITH_LAYOUT
+                 else
+                   SCORE_FALLBACK_WITH_LAYOUT
+                 end
+      elsif idx1 == idx2
+        score += SCORE_SAME_POSITION_WITHOUT_LAYOUT
+      elsif idx1 < idx2
+        score += SCORE_LATER_POSITION_WITHOUT_LAYOUT
+      end
+
+      score
+    end
+
+    def images_equivalent?(images1, images2)
+      return true if images1.size != images2.size
+
+      images1.zip(images2).all? { |img1, img2| img1&.equivalent?(img2) }
+    end
+
+    def apply_delete_marks(before, after, mapping)
+      mapping.each do |before_idx, after_idx|
+        before[before_idx].delete_slide = if after[after_idx].freeze
+                                            false
+                                          elsif before[before_idx].new_slide
+                                            false
+                                          else
+                                            after[after_idx].empty?
+                                          end
+      end
+    end
+
+    def generate_append_actions(before)
+      before.select { |s| s.new_slide && !s.delete_slide }
+            .map { |s| Action.new(type: :append, slide: s) }
+    end
+
+    def generate_update_actions(before, after, mapping)
+      actions = []
+
+      mapping.each do |before_idx, after_idx|
+        next if before[before_idx].delete_slide
+        next if after[after_idx].freeze
+
+        actions << Action.new(type: :update, index: before_idx, slide: after[after_idx])
+      end
+
+      actions
+    end
+
+    def generate_delete_actions(before, _mapping)
+      before.each_with_index.select { |slide, _| slide.delete_slide }
+            .map { |_, idx| Action.new(type: :delete, index: idx) }
+    end
+
+    def generate_move_actions(_before, _after, _mapping)
+      []
+    end
+
+    def remove_delete_marked(slides)
+      slides.reject(&:delete_slide)
+    end
+  end
+end

data/lib/rdeck/apply.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class Apply
+    attr_reader :presentation
+
+    def initialize(presentation)
+      @presentation = presentation
+      @request_builder = nil
+      @image_uploader = nil
+    end
+
+    def apply(slides, pages: nil, folder_id: nil)
+      pages ||= (1..slides.size).to_a
+
+      presentation.refresh
+      initialize_helpers(folder_id)
+
+      before = presentation.current_slides
+      after = build_after_slides(before, slides, pages)
+
+      generator = ActionGenerator.new
+      actions = generator.generate(before, after)
+
+      preload_images(actions)
+
+      execute_actions(actions)
+
+      presentation.refresh
+    ensure
+      @image_uploader&.cleanup
+    end
+
+    private
+
+    def initialize_helpers(folder_id)
+      require_relative 'request_builder'
+      require_relative 'image_uploader'
+      @request_builder = RequestBuilder.new(presentation)
+      @image_uploader = ImageUploader.new(presentation.drive_service, folder_id:)
+    end
+
+    def slide_layout_name(slide)
+      slide&.slide_properties&.layout_object_id&.then do |layout_id|
+        presentation_data = presentation.instance_variable_get(:@presentation)
+        presentation_data&.layouts&.find { _1.object_id_prop == layout_id }&.layout_properties&.display_name
+      end
+    end
+
+    def build_after_slides(before, slides, pages)
+      before.dup.tap do |after|
+        pages.each_with_index do |page, idx|
+          slide = slides[page - 1]
+          next unless slide
+
+          idx < after.size ? after[idx] = slide : after << slide
+        end
+      end
+    end
+
+    def preload_images(actions)
+      actions
+        .filter { %i[append update].include?(_1.type) && _1.slide }
+        .flat_map { _1.slide.images || [] }
+        .filter(&:from_markdown)
+        .each { @image_uploader.upload(_1) }
+    end
+
+    def execute_actions(actions)
+      state = ExecutionState.new(presentation.current_slides.size)
+
+      actions.each do |action|
+        case action
+        in { type: :append }
+          handle_append(action, state)
+        in { type: :update }
+          handle_update(action, state)
+        in { type: :delete }
+          state.delete_indices << action.index
+        in { type: :move }
+          handle_move(action, state)
+        end
+      end
+
+      presentation.batch_update(state.all_requests)
+
+      presentation.delete_slides(state.delete_indices.sort.reverse) unless state.delete_indices.empty?
+    end
+
+    def handle_append(action, state)
+      layout = action.slide.layout.empty? ? 'BLANK' : action.slide.layout
+      index = state.current_slide_count + state.append_count
+
+      presentation.create_slide(index, layout)
+
+      presentation.refresh
+      new_slide = current_slide_at(index)
+      requests = @request_builder.build_slide_update_requests(index, action.slide, new_slide)
+      state.appending_requests.concat(requests.compact)
+
+      state.append_count += 1
+    end
+
+    def handle_update(action, state)
+      presentation.refresh
+      existing_slide = current_slide_at(action.index)
+
+      current_layout = slide_layout_name(existing_slide)
+      requested_layout = action.slide.layout
+
+      if layout_change_needed?(current_layout, requested_layout)
+        recreate_slide_with_new_layout(action, state, current_layout, requested_layout)
+      else
+        requests = @request_builder.build_slide_update_requests(action.index, action.slide, existing_slide)
+        state.update_requests.concat(requests.compact)
+      end
+    end
+
+    def handle_move(action, state)
+      flush_pending_requests(state)
+      presentation.move_slide(action.index, action.move_to_index)
+    end
+
+    def layout_change_needed?(current, requested)
+      requested && !requested.empty? && current != requested
+    end
+
+    def recreate_slide_with_new_layout(action, state, current_layout, requested_layout)
+      warn "Recreating slide #{action.index} to change layout from '#{current_layout}' to '#{requested_layout}'"
+
+      flush_pending_requests(state)
+
+      presentation.delete_slides([action.index])
+
+      presentation.create_slide(action.index, requested_layout)
+
+      presentation.refresh
+      new_slide = current_slide_at(action.index)
+      requests = @request_builder.build_slide_update_requests(action.index, action.slide, new_slide)
+
+      presentation.batch_update(requests.compact)
+    end
+
+    def flush_pending_requests(state)
+      presentation.batch_update(state.all_requests)
+      state.clear_requests
+    end
+
+    def current_slide_at(index) = presentation.instance_variable_get(:@presentation).slides[index]
+
+    class ExecutionState
+      attr_accessor :append_count
+      attr_reader :appending_requests, :update_requests, :delete_indices, :current_slide_count
+
+      def initialize(current_slide_count)
+        @current_slide_count = current_slide_count
+        @append_count = 0
+        @appending_requests = []
+        @update_requests = []
+        @delete_indices = []
+      end
+
+      def all_requests = appending_requests + update_requests
+
+      def clear_requests
+        @appending_requests = []
+        @update_requests = []
+      end
+    end
+  end
+end

data/lib/rdeck/block_quote.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class BlockQuote
+    attr_accessor :paragraphs, :nesting
+
+    def initialize(paragraphs: [], nesting: 0)
+      @paragraphs = paragraphs
+      @nesting = nesting
+    end
+
+    def ==(other)
+      return false unless other.is_a?(BlockQuote)
+
+      paragraphs == other.paragraphs &&
+        nesting == other.nesting
+    end
+
+    def text
+      paragraphs.map(&:text).join("\n")
+    end
+
+    def empty?
+      paragraphs.empty? || paragraphs.all?(&:empty?)
+    end
+  end
+end