rdeck 0.1.0

data/lib/rdeck/body.rb

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

data/lib/rdeck/cli.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Rdeck
+  class CLI
+    def self.start(argv)
+      new.run(argv)
+    end
+
+    def run(argv)
+      return show_help if argv.empty?
+
+      command = argv.shift
+      @options = { profile: nil }
+
+      case command
+      when 'apply'
+        run_apply(argv)
+      when 'new'
+        run_new(argv)
+      when 'ls'
+        run_ls(argv)
+      when 'ls-layouts'
+        run_ls_layouts(argv)
+      when 'open'
+        run_open(argv)
+      when 'export'
+        run_export(argv)
+      when 'doctor'
+        run_doctor(argv)
+      when 'version', '-v', '--version'
+        run_version
+      when 'help', '-h', '--help'
+        show_help
+      else
+        warn "Unknown command: #{command}"
+        warn "Run 'rdeck help' for usage information"
+        exit 1
+      end
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    private
+
+    def run_apply(argv)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: rdeck apply DECK_FILE [options]'
+        opts.on('--profile PROFILE', 'Profile name') { |v| @options[:profile] = v }
+        opts.on('-i', '--presentation-id ID', 'Presentation ID') { |v| @options[:presentation_id] = v }
+        opts.on('-t', '--title TITLE', 'Presentation title') { |v| @options[:title] = v }
+        opts.on('-p', '--page PAGES', "Pages to apply (e.g., '1,3-5')") { |v| @options[:page] = v }
+        opts.on('-c', '--code-block-to-image-command CMD', 'Command to convert code blocks to images') do |v|
+          @options[:code_block_to_image_command] = v
+        end
+        opts.on('--folder-id ID', 'Folder ID for temporary images') { |v| @options[:folder_id] = v }
+        opts.on('-w', '--watch', 'Watch file for changes') { @options[:watch] = true }
+        opts.on('-v', '--verbose', 'Verbose output') { @options[:verbose] = true }
+      end
+
+      parser.parse!(argv)
+
+      if argv.empty?
+        warn 'Error: DECK_FILE is required'
+        warn parser.help
+        exit 1
+      end
+
+      deck_file = argv.first
+
+      config = Config.load(@options[:profile])
+      parser = Markdown::Parser.new(File.dirname(deck_file))
+      md = parser.parse_file(deck_file, config)
+
+      presentation_id = @options[:presentation_id] || md.frontmatter&.presentation_id
+      raise Error, 'Presentation ID is required (use -i or specify in frontmatter)' unless presentation_id
+
+      client = Client.new(profile: @options[:profile])
+      presentation = Presentation.new(presentation_id, client: client)
+
+      if @options[:watch]
+        watch_and_apply(deck_file, config, presentation)
+      else
+        slides = md.to_slides(@options[:code_block_to_image_command])
+        pages = parse_pages(@options[:page], slides.size)
+        apply_instance = Apply.new(presentation)
+        apply_instance.apply(slides, pages: pages)
+        puts "Applied to #{presentation_id}"
+      end
+    end
+
+    def run_new(argv)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: rdeck new [MARKDOWN_FILE] [options]'
+        opts.on('--profile PROFILE', 'Profile name') { |v| @options[:profile] = v }
+        opts.on('-t', '--title TITLE', 'Presentation title') { |v| @options[:title] = v }
+        opts.on('-b', '--base ID', 'Base presentation ID to copy from') { |v| @options[:base] = v }
+        opts.on('--folder-id ID', 'Folder ID to create presentation in') { |v| @options[:folder_id] = v }
+      end
+
+      parser.parse!(argv)
+
+      markdown_file = argv.first
+
+      config = Config.load(@options[:profile])
+      client = Client.new(profile: @options[:profile])
+
+      base_id = @options[:base] || config.base_presentation_id
+      folder_id = @options[:folder_id] || config.folder_id
+
+      presentation = if base_id
+                       Presentation.create_from(base_id, client: client, folder_id: folder_id)
+                     else
+                       Presentation.create(client: client, folder_id: folder_id)
+                     end
+
+      presentation.update_title(@options[:title]) if @options[:title]
+
+      if markdown_file
+        title = @options[:title] || 'Untitled Presentation'
+        Markdown::Frontmatter.apply_to_file(markdown_file, title, presentation.id)
+        warn "Applied frontmatter to #{markdown_file}"
+      end
+
+      puts presentation.id
+    end
+
+    def run_ls(argv)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: rdeck ls [options]'
+        opts.on('--profile PROFILE', 'Profile name') { |v| @options[:profile] = v }
+      end
+
+      parser.parse!(argv)
+
+      client = Client.new(profile: @options[:profile])
+      Presentation.list(client).each do |pres|
+        puts "#{pres.id}\t#{pres.title}"
+      end
+    end
+
+    def run_ls_layouts(argv)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: rdeck ls-layouts DECK_FILE_OR_ID [options]'
+        opts.on('--profile PROFILE', 'Profile name') { |v| @options[:profile] = v }
+        opts.on('-i', '--presentation-id ID', 'Presentation ID') { |v| @options[:presentation_id] = v }
+      end
+
+      parser.parse!(argv)
+
+      deck_file_or_id = argv.first
+      presentation_id = resolve_presentation_id(deck_file_or_id, @options[:presentation_id])
+      raise Error, 'Presentation ID is required' unless presentation_id
+
+      client = Client.new(profile: @options[:profile])
+      presentation = Presentation.new(presentation_id, client: client)
+
+      presentation.list_layouts.each { |layout| puts layout }
+    end
+
+    def run_open(argv)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: rdeck open DECK_FILE_OR_ID [options]'
+        opts.on('--profile PROFILE', 'Profile name') { |v| @options[:profile] = v }
+        opts.on('-i', '--presentation-id ID', 'Presentation ID') { |v| @options[:presentation_id] = v }
+      end
+
+      parser.parse!(argv)
+
+      deck_file_or_id = argv.first
+      presentation_id = resolve_presentation_id(deck_file_or_id, @options[:presentation_id])
+      raise Error, 'Presentation ID is required' unless presentation_id
+
+      url = "https://docs.google.com/presentation/d/#{presentation_id}/"
+      puts url
+
+      case RUBY_PLATFORM
+      when /darwin/
+        system("open '#{url}'")
+      when /linux/
+        system("xdg-open '#{url}'")
+      when /mswin|mingw|cygwin/
+        system("start '#{url}'")
+      end
+    end
+
+    def run_export(argv)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: rdeck export DECK_FILE_OR_ID [options]'
+        opts.on('--profile PROFILE', 'Profile name') { |v| @options[:profile] = v }
+        opts.on('-i', '--presentation-id ID', 'Presentation ID') { |v| @options[:presentation_id] = v }
+        opts.on('-o', '--out FILE', 'Output file path') { |v| @options[:out] = v }
+      end
+
+      parser.parse!(argv)
+
+      deck_file_or_id = argv.first
+      presentation_id = resolve_presentation_id(deck_file_or_id, @options[:presentation_id])
+      raise Error, 'Presentation ID is required' unless presentation_id
+
+      client = Client.new(profile: @options[:profile])
+      presentation = Presentation.new(presentation_id, client: client)
+
+      output = @options[:out] || begin
+        base = deck_file_or_id && File.exist?(deck_file_or_id) ? File.basename(deck_file_or_id, '.*') : 'deck'
+        "#{base}.pdf"
+      end
+
+      File.binwrite(output, presentation.export_pdf)
+      puts "Exported to #{output}"
+    end
+
+    def run_doctor(argv)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: rdeck doctor [options]'
+        opts.on('--profile PROFILE', 'Profile name') { |v| @options[:profile] = v }
+      end
+
+      parser.parse!(argv)
+
+      puts 'Rdeck Doctor'
+      puts '=' * 50
+
+      puts "\nRuby version: #{RUBY_VERSION}"
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.1.0')
+        puts '  ✓ Ruby version OK'
+      else
+        puts '  ✗ Ruby 3.1.0 or higher required'
+      end
+
+      puts "\nConfiguration:"
+      config_path = Config.find_config_path(@options[:profile])
+      if config_path
+        puts "  ✓ Config found at: #{config_path}"
+      else
+        puts '  ✗ No config file found'
+        puts '    Expected locations:'
+        puts "      - #{File.join(Config.xdg_config_home, 'rdeck', 'config.yml')}"
+        puts "      - #{File.join(Config.xdg_config_home, 'rdeck', 'config.yaml')}"
+      end
+
+      puts "\nCredentials:"
+      client = Client.new(profile: @options[:profile])
+      credentials_path = client.send(:credentials_file_path)
+      if File.exist?(credentials_path)
+        puts "  ✓ Credentials found at: #{credentials_path}"
+      else
+        puts "  ✗ No credentials file found at: #{credentials_path}"
+        puts '    Please download OAuth2 credentials from Google Cloud Console'
+      end
+
+      puts "\nAPI Connection:"
+      begin
+        presentations = Presentation.list(client)
+        puts '  ✓ Successfully connected to Google APIs'
+        puts "    Found #{presentations.size} presentations"
+      rescue StandardError => e
+        puts '  ✗ Failed to connect to Google APIs'
+        puts "    Error: #{e.message}"
+      end
+    end
+
+    def run_version
+      puts "rdeck version #{Rdeck::VERSION}"
+    end
+
+    def show_help
+      puts <<~HELP
+        rdeck - Convert Markdown presentations to Google Slides
+
+        Usage:
+          rdeck COMMAND [options]
+
+        Commands:
+          apply DECK_FILE          Apply deck written in markdown to Google Slides
+          new [MARKDOWN_FILE]      Create new presentation
+          ls                       List Google Slides presentations
+          ls-layouts DECK_FILE_OR_ID   List layouts of Google Slides presentation
+          open DECK_FILE_OR_ID     Open Google Slides presentation in browser
+          export DECK_FILE_OR_ID   Export deck to PDF
+          doctor                   Check rdeck environment and configuration
+          version                  Show version
+          help                     Show this help message
+
+        Global Options:
+          --profile PROFILE        Profile name
+
+        Run 'rdeck COMMAND --help' for more information on a command.
+      HELP
+    end
+
+    def resolve_presentation_id(file_or_id, option_id)
+      return option_id if option_id
+
+      if file_or_id && File.exist?(file_or_id)
+        parser = Markdown::Parser.new(File.dirname(file_or_id))
+        md = parser.parse_file(file_or_id)
+        return md.frontmatter&.presentation_id
+      end
+
+      file_or_id
+    end
+
+    def parse_pages(page_str, total)
+      return (1..total).to_a unless page_str
+
+      pages = []
+      page_str.split(',').each do |part|
+        if part.include?('-')
+          range_parts = part.split('-', -1)
+          start_page = range_parts[0].to_s.empty? ? 1 : range_parts[0].to_i
+          end_page = range_parts[1].to_s.empty? ? total : range_parts[1].to_i
+          pages += (start_page..end_page).to_a
+        else
+          pages << part.to_i
+        end
+      end
+      pages.uniq.sort
+    end
+
+    def watch_and_apply(deck_file, config, presentation)
+      require 'listen'
+
+      parser = Markdown::Parser.new(File.dirname(deck_file))
+
+      listener = Listen.to(File.dirname(deck_file),
+                           only: /#{Regexp.escape(File.basename(deck_file))}$/) do |modified, added, _removed|
+        if modified.any? || added.any?
+          begin
+            md = parser.parse_file(deck_file, config)
+            slides = md.to_slides(@options[:code_block_to_image_command])
+            apply_instance = Apply.new(presentation)
+            apply_instance.apply(slides)
+            puts "Applied changes at #{Time.now}"
+          rescue StandardError => e
+            warn "Error applying changes: #{e.message}"
+          end
+        end
+      end
+
+      puts "Watching #{deck_file} for changes..."
+      puts 'Press Ctrl+C to stop'
+      listener.start
+      sleep
+    end
+
+    def handle_error(error)
+      case error
+      when Rdeck::Error
+        warn "Error: #{error.message}"
+      when Google::Apis::Error
+        warn "Google API Error: #{error.message}"
+      else
+        warn "Unexpected error: #{error.class}: #{error.message}"
+        warn error.backtrace.join("\n") if @options&.dig(:verbose)
+      end
+      exit 1
+    end
+  end
+end

data/lib/rdeck/client.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'google/apis/slides_v1'
+require 'google/apis/drive_v3'
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require 'fileutils'
+
+module Rdeck
+  class Client
+    SCOPES = [
+      Google::Apis::SlidesV1::AUTH_PRESENTATIONS,
+      Google::Apis::DriveV3::AUTH_DRIVE
+    ].freeze
+
+    attr_reader :profile
+
+    def initialize(profile: nil)
+      @profile = profile
+      @slides_service = nil
+      @drive_service = nil
+    end
+
+    def slides_service
+      @slides_service ||= begin
+        service = Google::Apis::SlidesV1::SlidesService.new
+        service.authorization = authorization
+        service
+      end
+    end
+
+    def drive_service
+      @drive_service ||= begin
+        service = Google::Apis::DriveV3::DriveService.new
+        service.authorization = authorization
+        service
+      end
+    end
+
+    private
+
+    def authorization
+      @authorization ||= if ENV['DECK_SERVICE_ACCOUNT_KEY'] || ENV['RDECK_SERVICE_ACCOUNT_KEY']
+                           service_account_auth
+                         elsif ENV['DECK_ENABLE_ADC'] || ENV['RDECK_ENABLE_ADC']
+                           application_default_credentials
+                         elsif ENV['DECK_ACCESS_TOKEN'] || ENV['RDECK_ACCESS_TOKEN']
+                           access_token_auth
+                         else
+                           oauth2_auth
+                         end
+    end
+
+    def service_account_auth
+      key_content = ENV['DECK_SERVICE_ACCOUNT_KEY'] || ENV.fetch('RDECK_SERVICE_ACCOUNT_KEY', nil)
+      key_io = StringIO.new(key_content)
+      authorizer = Google::Auth::ServiceAccountCredentials.make_creds(
+        json_key_io: key_io,
+        scope: SCOPES
+      )
+      authorizer.fetch_access_token!
+      authorizer
+    end
+
+    def application_default_credentials
+      Google::Auth.get_application_default(SCOPES)
+    end
+
+    def access_token_auth
+      token = ENV['DECK_ACCESS_TOKEN'] || ENV.fetch('RDECK_ACCESS_TOKEN', nil)
+      Signet::OAuth2::Client.new(access_token: token)
+    end
+
+    def oauth2_auth
+      credentials_path = credentials_file_path
+      token_path = token_file_path
+
+      unless File.exist?(credentials_path)
+        raise Error, "Credentials file not found at #{credentials_path}. " \
+                     'Please download OAuth2 credentials from Google Cloud Console.'
+      end
+
+      client_id = Google::Auth::ClientId.from_file(credentials_path)
+      token_store = Google::Auth::Stores::FileTokenStore.new(file: token_path)
+      authorizer = Google::Auth::UserAuthorizer.new(client_id, SCOPES, token_store)
+
+      user_id = 'default'
+      credentials = authorizer.get_credentials(user_id)
+
+      if credentials.nil?
+        url = authorizer.get_authorization_url(base_url: 'urn:ietf:wg:oauth:2.0:oob')
+        puts 'Open the following URL in your browser and enter the resulting code:'
+        puts url
+        print 'Code: '
+        code = $stdin.gets.chomp
+        credentials = authorizer.get_and_store_credentials_from_code(
+          user_id: user_id,
+          code: code,
+          base_url: 'urn:ietf:wg:oauth:2.0:oob'
+        )
+      end
+
+      credentials
+    end
+
+    def credentials_file_path
+      base = Config.xdg_data_home
+      FileUtils.mkdir_p(File.join(base, 'rdeck'))
+
+      if @profile
+        File.join(base, 'rdeck', "credentials-#{@profile}.json")
+      else
+        File.join(base, 'rdeck', 'credentials.json')
+      end
+    end
+
+    def token_file_path
+      base = Config.xdg_state_home
+      FileUtils.mkdir_p(File.join(base, 'rdeck'))
+
+      if @profile
+        File.join(base, 'rdeck', "token-#{@profile}.json")
+      else
+        File.join(base, 'rdeck', 'token.json')
+      end
+    end
+  end
+end

data/lib/rdeck/config.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Rdeck
+  class Config
+    attr_accessor :breaks, :defaults, :code_block_to_image_command, :folder_id, :base_presentation_id
+
+    def initialize
+      @breaks = false
+      @defaults = []
+      @code_block_to_image_command = nil
+      @folder_id = nil
+      @base_presentation_id = nil
+    end
+
+    def self.load(profile = nil)
+      config = new
+      config_path = find_config_path(profile)
+      if config_path && File.exist?(config_path)
+        yaml = YAML.safe_load_file(config_path, permitted_classes: [Symbol], symbolize_names: true)
+        config.apply_yaml(yaml)
+      end
+      config
+    end
+
+    def self.find_config_path(profile = nil)
+      base = xdg_config_home
+      suffix = profile ? "-#{profile}" : ''
+
+      [
+        File.join(base, 'rdeck', "config#{suffix}.yml"),
+        File.join(base, 'rdeck', "config#{suffix}.yaml")
+      ].find { |path| File.exist?(path) }
+    end
+
+    def self.xdg_config_home
+      ENV.fetch('XDG_CONFIG_HOME', File.expand_path('~/.config'))
+    end
+
+    def self.xdg_data_home
+      ENV.fetch('XDG_DATA_HOME', File.expand_path('~/.local/share'))
+    end
+
+    def self.xdg_state_home
+      ENV.fetch('XDG_STATE_HOME', File.expand_path('~/.local/state'))
+    end
+
+    def apply_yaml(yaml)
+      @breaks = yaml[:breaks] if yaml.key?(:breaks)
+      @defaults = parse_defaults(yaml[:defaults]) if yaml.key?(:defaults)
+      @code_block_to_image_command = yaml[:codeBlockToImageCommand] if yaml.key?(:codeBlockToImageCommand)
+      @folder_id = yaml[:folderID] if yaml.key?(:folderID)
+      @base_presentation_id = yaml[:basePresentationID] if yaml.key?(:basePresentationID)
+    end
+
+    private
+
+    def parse_defaults(defaults_array)
+      return [] unless defaults_array.is_a?(Array)
+
+      defaults_array.map do |default|
+        DefaultCondition.new(default)
+      end
+    end
+  end
+
+  class DefaultCondition
+    attr_accessor :if_condition, :layout, :freeze, :ignore, :skip
+
+    def initialize(attrs = {})
+      @if_condition = fetch_attr(attrs, :if)
+      @layout = fetch_attr(attrs, :layout)
+      @freeze = fetch_attr(attrs, :freeze)
+      @ignore = fetch_attr(attrs, :ignore)
+      @skip = fetch_attr(attrs, :skip)
+    end
+
+    def evaluate(context)
+      return true unless if_condition
+
+      Rdeck::Markdown::CELEvaluator.new.evaluate(if_condition, context)
+    end
+
+    def apply_to(slide)
+      slide.layout = layout if layout
+      slide.freeze = freeze unless freeze.nil?
+      slide.skip = skip unless skip.nil?
+    end
+
+    private
+
+    def fetch_attr(attrs, key)
+      attrs.fetch(key) { attrs[key.to_s] }
+    end
+  end
+end

data/lib/rdeck/fragment.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class Fragment
+    attr_accessor :value, :bold, :italic, :link, :code, :style_name
+
+    def initialize(value: '', bold: false, italic: false, link: '', code: false, style_name: '')
+      @value = value
+      @bold = bold
+      @italic = italic
+      @link = link
+      @code = code
+      @style_name = style_name
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Fragment)
+
+      value == other.value && styles_equal?(other)
+    end
+
+    def styles_equal?(other)
+      bold == other.bold &&
+        italic == other.italic &&
+        link == other.link &&
+        code == other.code &&
+        style_name == other.style_name
+    end
+
+    def empty?
+      value.empty?
+    end
+  end
+end