rdeck 0.1.0

data/lib/rdeck/request_builder.rb

@@ -0,0 +1,416 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class RequestBuilder
+    def initialize(presentation)
+      @presentation = presentation
+      @object_id_counter = 0
+    end
+
+    def build_slide_update_requests(_slide_index, slide, existing_slide)
+      requests = []
+
+      slide_id = existing_slide&.object_id_prop || generate_object_id
+
+      requests += build_clear_content_requests(existing_slide) if existing_slide
+
+      slide.titles.each_with_index do |title, index|
+        requests += build_text_update_requests_for_title(slide_id, [title], index)
+      end
+
+      requests += build_text_update_requests(slide_id, slide.subtitles, 'SUBTITLE')
+
+      requests += build_body_update_requests(slide_id, slide.bodies)
+
+      requests += build_image_update_requests(slide_id, slide.images)
+
+      requests += build_table_update_requests(slide_id, slide.tables)
+
+      if slide.speaker_note && !slide.speaker_note.empty?
+        requests << build_speaker_note_request(slide_id, slide.speaker_note)
+      end
+
+      requests
+    end
+
+    def build_layout_update_request(slide_id, layout_name)
+      layout = @presentation.find_layout(layout_name)
+      return nil unless layout
+
+      {
+        update_slide_properties: {
+          object_id_prop: slide_id,
+          slide_properties: {
+            layout_object_id: layout.object_id_prop
+          },
+          fields: 'layoutObjectId'
+        }
+      }
+    end
+
+    def build_clear_content_requests(slide)
+      requests = []
+
+      slide.page_elements&.each do |element|
+        next if element.shape&.placeholder
+
+        requests << {
+          delete_object: {
+            object_id_prop: element.object_id_prop
+          }
+        }
+      end
+
+      requests
+    end
+
+    def build_text_update_requests_for_title(slide_id, texts, index)
+      title_types = %w[TITLE CENTERED_TITLE]
+      requests = []
+
+      texts.each do |text|
+        placeholder = nil
+        title_types.each do |type|
+          placeholder = find_placeholder(slide_id, type, index)
+          break if placeholder
+        end
+
+        next unless placeholder
+
+        if placeholder_has_text?(placeholder)
+          requests << {
+            delete_text: {
+              object_id_prop: placeholder.object_id_prop,
+              text_range: {
+                type: 'ALL'
+              }
+            }
+          }
+        end
+
+        requests << {
+          insert_text: {
+            object_id_prop: placeholder.object_id_prop,
+            text: text,
+            insertion_index: 0
+          }
+        }
+      end
+
+      requests
+    end
+
+    def build_text_update_requests(slide_id, texts, placeholder_type)
+      requests = []
+
+      texts.each_with_index do |text, index|
+        placeholder = find_placeholder(slide_id, placeholder_type, index)
+        next unless placeholder
+
+        if placeholder_has_text?(placeholder)
+          requests << {
+            delete_text: {
+              object_id_prop: placeholder.object_id_prop,
+              text_range: {
+                type: 'ALL'
+              }
+            }
+          }
+        end
+
+        requests << {
+          insert_text: {
+            object_id_prop: placeholder.object_id_prop,
+            text: text,
+            insertion_index: 0
+          }
+        }
+      end
+
+      requests
+    end
+
+    def build_body_update_requests(slide_id, bodies)
+      requests = []
+
+      bodies.each_with_index do |body, index|
+        placeholder = find_placeholder(slide_id, 'BODY', index)
+        next unless placeholder
+
+        placeholder_id = placeholder.object_id_prop
+
+        if placeholder_has_text?(placeholder)
+          requests << {
+            delete_text: {
+              object_id_prop: placeholder_id,
+              text_range: {
+                type: 'ALL'
+              }
+            }
+          }
+        end
+
+        insertion_index = 0
+        body.paragraphs.each do |paragraph|
+          text = paragraph_to_text(paragraph)
+          requests << {
+            insert_text: {
+              object_id_prop: placeholder_id,
+              text: "#{text}\n",
+              insertion_index: insertion_index
+            }
+          }
+
+          if paragraph.bullet != Paragraph::BULLET_NONE
+            requests << build_bullet_request(
+              placeholder_id,
+              insertion_index,
+              insertion_index + text.length,
+              paragraph.bullet,
+              paragraph.nesting
+            )
+          end
+
+          requests += build_text_style_requests(
+            placeholder_id,
+            insertion_index,
+            paragraph.fragments
+          )
+
+          insertion_index += text.length + 1
+        end
+      end
+
+      requests
+    end
+
+    def build_image_update_requests(slide_id, images)
+      requests = []
+
+      images.each_with_index do |image, _index|
+        url = upload_image_to_drive(image)
+        next unless url
+
+        image_id = generate_object_id
+        requests << {
+          create_image: {
+            object_id_prop: image_id,
+            url: url,
+            element_properties: {
+              page_object_id: slide_id,
+              size: {
+                width: { magnitude: 400, unit: 'PT' },
+                height: { magnitude: 300, unit: 'PT' }
+              },
+              transform: {
+                scale_x: 1,
+                scale_y: 1,
+                translate_x: 100,
+                translate_y: 100,
+                unit: 'PT'
+              }
+            }
+          }
+        }
+      end
+
+      requests
+    end
+
+    def build_table_update_requests(slide_id, tables)
+      requests = []
+
+      tables.each do |table|
+        next if table.rows.empty?
+
+        rows = table.rows.size
+        cols = table.rows.first.cells.size
+
+        table_id = generate_object_id
+        requests << {
+          create_table: {
+            object_id_prop: table_id,
+            element_properties: {
+              page_object_id: slide_id,
+              size: {
+                width: { magnitude: 500, unit: 'PT' },
+                height: { magnitude: rows * 30, unit: 'PT' }
+              },
+              transform: {
+                scale_x: 1,
+                scale_y: 1,
+                translate_x: 50,
+                translate_y: 150,
+                unit: 'PT'
+              }
+            },
+            rows: rows,
+            columns: cols
+          }
+        }
+
+        table.rows.each_with_index do |row, row_idx|
+          row.cells.each_with_index do |cell, col_idx|
+            text = cell.text
+
+            requests << {
+              insert_text: {
+                object_id_prop: table_id,
+                cell_location: {
+                  row_index: row_idx,
+                  column_index: col_idx
+                },
+                text: text,
+                insertion_index: 0
+              }
+            }
+
+            next unless cell.is_header
+
+            requests << build_table_cell_style_request(
+              table_id,
+              row_idx,
+              col_idx,
+              bold: true
+            )
+          end
+        end
+      end
+
+      requests
+    end
+
+    def build_speaker_note_request(slide_id, _note)
+      {
+        create_paragraph_bullets: {
+          object_id_prop: "#{slide_id}_notes",
+          text_range: {
+            type: 'ALL'
+          }
+        }
+      }
+    end
+
+    def build_bullet_request(object_id, start_idx, end_idx, bullet_type, _nesting)
+      glyph = case bullet_type
+              when Paragraph::BULLET_NUMBERED
+                'NUMBERED_DECIMAL_NESTED'
+              else
+                'BULLET_DISC_CIRCLE_SQUARE'
+              end
+
+      {
+        create_paragraph_bullets: {
+          object_id_prop: object_id,
+          text_range: {
+            start_index: start_idx,
+            end_index: end_idx,
+            type: 'FIXED_RANGE'
+          },
+          bullet_preset: glyph
+        }
+      }
+    end
+
+    def build_text_style_requests(object_id, base_index, fragments)
+      requests = []
+      index = base_index
+
+      fragments.each do |fragment|
+        length = fragment.value.length
+        next if length.zero?
+
+        style = {}
+        style[:bold] = true if fragment.bold
+        style[:italic] = true if fragment.italic
+        style[:link] = { url: fragment.link } if fragment.link && !fragment.link.empty?
+
+        if fragment.code
+          style[:font_family] = 'Courier New'
+          style[:foreground_color] = {
+            opaque_color: {
+              rgb_color: { red: 0.2, green: 0.2, blue: 0.2 }
+            }
+          }
+        end
+
+        unless style.empty?
+          requests << {
+            update_text_style: {
+              object_id_prop: object_id,
+              text_range: {
+                start_index: index,
+                end_index: index + length,
+                type: 'FIXED_RANGE'
+              },
+              style: style,
+              fields: style.keys.join(',')
+            }
+          }
+        end
+
+        index += length
+      end
+
+      requests
+    end
+
+    def build_table_cell_style_request(table_id, row, col, bold: false)
+      {
+        update_text_style: {
+          object_id_prop: table_id,
+          cell_location: {
+            row_index: row,
+            column_index: col
+          },
+          style: {
+            bold: bold
+          },
+          fields: 'bold'
+        }
+      }
+    end
+
+    private
+
+    def generate_object_id
+      @object_id_counter += 1
+      "obj_#{Time.now.to_i}_#{@object_id_counter}"
+    end
+
+    def find_placeholder(slide_id, type, index)
+      presentation_data = @presentation.instance_variable_get(:@presentation)
+      return nil unless presentation_data
+
+      slide = presentation_data.slides&.find { |s| s.object_id_prop == slide_id }
+      return nil unless slide
+
+      placeholders = []
+      slide.page_elements&.each do |element|
+        next unless element.shape&.placeholder
+
+        placeholder_type = element.shape.placeholder.type
+        placeholders << element if placeholder_type == type
+      end
+
+      placeholders[index]
+    end
+
+    def placeholder_has_text?(placeholder)
+      return false unless placeholder
+      return false unless placeholder.shape&.text
+
+      placeholder.shape.text.text_elements&.any? do |element|
+        element.text_run && !element.text_run.content.to_s.strip.empty?
+      end
+    end
+
+    def paragraph_to_text(paragraph)
+      paragraph.fragments.map(&:value).join
+    end
+
+    def upload_image_to_drive(_image)
+      nil
+    end
+  end
+end

data/lib/rdeck/retry_handler.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class RetryHandler
+    MAX_RETRIES = 10
+    INITIAL_BACKOFF = 1
+    MAX_BACKOFF = 30
+
+    class << self
+      attr_accessor :verbose
+
+      def with_retry(max_retries: MAX_RETRIES, verbose: nil)
+        retries = 0
+        backoff = INITIAL_BACKOFF
+        should_log = verbose.nil? ? self.verbose : verbose
+
+        begin
+          yield
+        rescue Google::Apis::RateLimitError, Google::Apis::ServerError => e
+          retries += 1
+
+          raise Error, "Max retries (#{max_retries}) exceeded: #{e.message}" unless retries <= max_retries
+
+          if should_log
+            warn "API error (attempt #{retries}/#{max_retries}): #{e.message}"
+            warn "Retrying in #{backoff} seconds..."
+          end
+          sleep backoff
+
+          backoff = [(backoff * 2) + rand, MAX_BACKOFF].min
+          retry
+        rescue Google::Apis::ClientError => e
+          error_details = e.body ? "\nDetails: #{e.body}" : ''
+          raise Error, "API client error: #{e.message}#{error_details}"
+        rescue Google::Apis::AuthorizationError => e
+          raise Error, "Authorization error: #{e.message}. Please check your credentials."
+        rescue StandardError => e
+          raise Error, "Unexpected error: #{e.class}: #{e.message}"
+        end
+      end
+
+      def with_batch_retry(requests, batch_size: 1000, verbose: nil)
+        results = []
+
+        requests.each_slice(batch_size) do |batch|
+          result = with_retry(verbose: verbose) do
+            yield(batch)
+          end
+          results << result
+        end
+
+        results
+      end
+    end
+
+    self.verbose = true
+  end
+end

data/lib/rdeck/slide.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class Slide
+    attr_accessor :layout, :freeze, :skip, :titles, :title_bodies, :subtitles, :subtitle_bodies, :bodies, :images,
+                  :block_quotes, :tables, :speaker_note, :new_slide, :delete_slide
+
+    def initialize(attrs = {})
+      @layout = attrs[:layout] || ''
+      @freeze = attrs[:freeze] || false
+      @skip = attrs[:skip] || false
+      @titles = attrs[:titles] || []
+      @title_bodies = attrs[:title_bodies] || []
+      @subtitles = attrs[:subtitles] || []
+      @subtitle_bodies = attrs[:subtitle_bodies] || []
+      @bodies = attrs[:bodies] || []
+      @images = attrs[:images] || []
+      @block_quotes = attrs[:block_quotes] || []
+      @tables = attrs[:tables] || []
+      @speaker_note = attrs[:speaker_note] || ''
+      @new_slide = false
+      @delete_slide = false
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Slide)
+
+      layout == other.layout &&
+        titles == other.titles &&
+        title_bodies == other.title_bodies &&
+        subtitles == other.subtitles &&
+        subtitle_bodies == other.subtitle_bodies &&
+        bodies_equal?(bodies, other.bodies) &&
+        images_equivalent?(images, other.images) &&
+        block_quotes == other.block_quotes &&
+        tables == other.tables &&
+        speaker_note == other.speaker_note
+    end
+
+    def empty?
+      titles.empty? &&
+        subtitles.empty? &&
+        bodies.empty? &&
+        images.empty? &&
+        block_quotes.empty? &&
+        tables.empty?
+    end
+
+    private
+
+    def bodies_equal?(a, b)
+      return true if a == b
+      return false if a.size != b.size
+
+      a.zip(b).all? { |body_a, body_b| body_a == body_b }
+    end
+
+    def images_equivalent?(a, b)
+      return true if a.size != b.size
+
+      a.zip(b).all? { |img_a, img_b| img_a&.equivalent?(img_b) }
+    end
+  end
+end