rdeck 0.1.0

data/lib/rdeck/hungarian.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Rdeck
+  class Hungarian
+    def initialize(cost_matrix)
+      @original_matrix = cost_matrix
+      @n = cost_matrix.size
+      @matrix = deep_copy(cost_matrix)
+      @marked_rows = Array.new(@n, false)
+      @marked_cols = Array.new(@n, false)
+      @starred = Array.new(@n) { Array.new(@n, false) }
+      @primed = Array.new(@n) { Array.new(@n, false) }
+    end
+
+    def solve
+      negate_matrix!
+
+      subtract_row_minimums!
+
+      subtract_column_minimums!
+
+      loop do
+        clear_marks!
+        star_zeros!
+
+        break if count_starred_zeros == @n
+
+        cover_columns!
+
+        loop do
+          row, col = find_uncovered_zero
+          if row.nil?
+            adjust_matrix!
+            next
+          end
+
+          @primed[row][col] = true
+
+          star_col = find_star_in_row(row)
+          if star_col.nil?
+            augment_path(row, col)
+            clear_primes!
+            break
+          else
+            @marked_rows[row] = true
+            @marked_cols[star_col] = false
+          end
+        end
+
+        break if count_starred_zeros == @n
+      end
+
+      extract_solution
+    end
+
+    private
+
+    def deep_copy(matrix)
+      matrix.map(&:dup)
+    end
+
+    def negate_matrix!
+      @n.times do |i|
+        @n.times do |j|
+          @matrix[i][j] = -@matrix[i][j]
+        end
+      end
+    end
+
+    def subtract_row_minimums!
+      @n.times do |i|
+        min = @matrix[i].min
+        @n.times do |j|
+          @matrix[i][j] -= min
+        end
+      end
+    end
+
+    def subtract_column_minimums!
+      @n.times do |j|
+        min = Array.new(@n) { |i| @matrix[i][j] }.min
+        @n.times do |i|
+          @matrix[i][j] -= min
+        end
+      end
+    end
+
+    def clear_marks!
+      @marked_rows.fill(false)
+      @marked_cols.fill(false)
+    end
+
+    def star_zeros!
+      @n.times do |i|
+        @n.times do |j|
+          next unless @matrix[i][j].zero?
+          next if row_has_star?(i) || col_has_star?(j)
+
+          @starred[i][j] = true
+        end
+      end
+    end
+
+    def row_has_star?(row)
+      @starred[row].any?
+    end
+
+    def col_has_star?(col)
+      @n.times.any? { |i| @starred[i][col] }
+    end
+
+    def count_starred_zeros
+      @starred.flatten.count(true)
+    end
+
+    def cover_columns!
+      @n.times do |j|
+        @marked_cols[j] = true if col_has_star?(j)
+      end
+    end
+
+    def find_uncovered_zero
+      @n.times do |i|
+        next if @marked_rows[i]
+
+        @n.times do |j|
+          next if @marked_cols[j]
+
+          return [i, j] if @matrix[i][j].zero?
+        end
+      end
+      nil
+    end
+
+    def find_star_in_row(row)
+      @n.times do |j|
+        return j if @starred[row][j]
+      end
+      nil
+    end
+
+    def find_prime_in_row(row)
+      @n.times do |j|
+        return j if @primed[row][j]
+      end
+      nil
+    end
+
+    def find_star_in_col(col)
+      @n.times do |i|
+        return i if @starred[i][col]
+      end
+      nil
+    end
+
+    def augment_path(row, col)
+      path = [[row, col]]
+
+      loop do
+        star_row = find_star_in_col(path.last[1])
+        break if star_row.nil?
+
+        path << [star_row, path.last[1]]
+
+        prime_col = find_prime_in_row(star_row)
+        path << [star_row, prime_col]
+      end
+
+      path.each_with_index do |(r, c), idx|
+        @starred[r][c] = idx.even?
+      end
+    end
+
+    def clear_primes!
+      @n.times do |i|
+        @n.times do |j|
+          @primed[i][j] = false
+        end
+      end
+    end
+
+    def adjust_matrix!
+      min = Float::INFINITY
+      @n.times do |i|
+        next if @marked_rows[i]
+
+        @n.times do |j|
+          next if @marked_cols[j]
+
+          min = @matrix[i][j] if @matrix[i][j] < min
+        end
+      end
+
+      @n.times do |i|
+        @n.times do |j|
+          if @marked_rows[i] && @marked_cols[j]
+            @matrix[i][j] += min
+          elsif !@marked_rows[i] && !@marked_cols[j]
+            @matrix[i][j] -= min
+          end
+        end
+      end
+    end
+
+    def extract_solution
+      solution = {}
+      @n.times do |i|
+        @n.times do |j|
+          solution[i] = j if @starred[i][j]
+        end
+      end
+      solution
+    end
+  end
+end

data/lib/rdeck/image.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'zlib'
+
+module Rdeck
+  class Image
+    MIME_PNG = 'image/png'
+    MIME_JPEG = 'image/jpeg'
+    MIME_GIF = 'image/gif'
+
+    attr_accessor :data, :mime_type, :url, :from_markdown, :checksum, :phash, :mod_time, :link
+
+    def initialize(path_or_url, from_markdown: false, link: '')
+      @from_markdown = from_markdown
+      @link = link
+      load_from(path_or_url)
+    end
+
+    def equivalent?(other)
+      return false unless other.is_a?(Image)
+      return false if mime_type != other.mime_type
+      return false if link != other.link
+      return true if checksum == other.checksum
+
+      false
+    end
+
+    def checksum
+      @checksum ||= Zlib.crc32(data)
+    end
+
+    def phash
+      @phash ||= calculate_phash
+    end
+
+    def mime_type_to_ext
+      case mime_type
+      when MIME_PNG then '.png'
+      when MIME_JPEG then '.jpg'
+      when MIME_GIF then '.gif'
+      else '.png'
+      end
+    end
+
+    private
+
+    def load_from(path_or_url)
+      if path_or_url.start_with?('http://', 'https://')
+        load_from_url(path_or_url)
+      else
+        load_from_file(path_or_url)
+      end
+    end
+
+    def load_from_url(url_str)
+      @url = url_str
+      uri = URI.parse(url_str)
+      response = Net::HTTP.get_response(uri)
+      raise Error, "Failed to fetch image from #{url_str}: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+      @data = response.body
+      @mime_type = detect_mime_type(response['content-type'])
+      @mod_time = Time.now
+    end
+
+    def load_from_file(path)
+      raise Error, "Image file not found: #{path}" unless File.exist?(path)
+
+      @data = File.binread(path)
+      @mime_type = detect_mime_type_from_data(@data)
+      @mod_time = File.mtime(path)
+      @url = "file://#{File.expand_path(path)}"
+    end
+
+    def detect_mime_type(content_type)
+      return MIME_PNG if content_type&.include?('png')
+      return MIME_JPEG if content_type&.include?('jpeg') || content_type&.include?('jpg')
+      return MIME_GIF if content_type&.include?('gif')
+
+      detect_mime_type_from_data(@data)
+    end
+
+    def detect_mime_type_from_data(data)
+      return MIME_PNG if data[0, 8] == "\x89PNG\r\n\x1A\n".b
+      return MIME_JPEG if data[0, 2] == "\xFF\xD8".b
+      return MIME_GIF if %w[GIF87a GIF89a].include?(data[0, 6])
+
+      MIME_PNG
+    end
+
+    def calculate_phash
+      checksum
+    rescue StandardError => e
+      warn "Failed to calculate pHash: #{e.message}"
+      nil
+    end
+  end
+end

data/lib/rdeck/image_uploader.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module Rdeck
+  class ImageUploader
+    def initialize(drive_service, folder_id: nil)
+      @drive_service = drive_service
+      @folder_id = folder_id
+      @uploaded_files = []
+    end
+
+    def upload(image)
+      temp_file = create_temp_file(image)
+
+      begin
+        file_metadata = Google::Apis::DriveV3::File.new(
+          name: "rdeck_temp_#{Time.now.to_i}_#{rand(10_000)}#{image.mime_type_to_ext}",
+          parents: @folder_id ? [@folder_id] : nil
+        )
+
+        file = @drive_service.create_file(
+          file_metadata,
+          fields: 'id,webContentLink,webViewLink',
+          upload_source: temp_file.path,
+          content_type: image.mime_type,
+          supports_all_drives: true
+        )
+
+        permission = Google::Apis::DriveV3::Permission.new(
+          type: 'anyone',
+          role: 'reader'
+        )
+
+        @drive_service.create_permission(
+          file.id,
+          permission,
+          supports_all_drives: true
+        )
+
+        @uploaded_files << file.id
+
+        file.web_content_link || file.web_view_link
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    def upload_batch(images)
+      images.map { |image| upload(image) }
+    end
+
+    def cleanup
+      @uploaded_files.each do |file_id|
+        @drive_service.delete_file(file_id, supports_all_drives: true)
+      rescue Google::Apis::Error => e
+        warn "Failed to delete temporary file #{file_id}: #{e.message}"
+      end
+      @uploaded_files.clear
+    end
+
+    private
+
+    def create_temp_file(image)
+      ext = image.mime_type_to_ext
+      temp_file = Tempfile.new(['rdeck_image', ext])
+      temp_file.binmode
+      temp_file.write(image.data)
+      temp_file.flush
+      temp_file.rewind
+      temp_file
+    end
+  end
+end

data/lib/rdeck/markdown/cel_evaluator.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Rdeck
+  module Markdown
+    class CELEvaluator
+      def evaluate(expression, context)
+        return false if expression.nil? || expression.empty?
+
+        expr = expression.dup
+        context.each do |key, value|
+          expr = replace_variable(expr, key.to_s, value)
+        end
+
+        expr = transform_methods(expr)
+
+        safe_eval(expr, context)
+      rescue StandardError => e
+        warn "Failed to evaluate CEL expression '#{expression}': #{e.message}"
+        false
+      end
+
+      private
+
+      def replace_variable(expr, key, value)
+        case value
+        when Integer, Float
+          expr.gsub(/\b#{Regexp.escape(key)}\b/, value.to_s)
+        when String
+          expr.gsub(/\b#{Regexp.escape(key)}\b/, "\"#{escape_string(value)}\"")
+        when Array
+          array_str = "[#{value.map { |v| serialize_value(v) }.join(', ')}]"
+          expr.gsub(/\b#{Regexp.escape(key)}\b/, array_str)
+        when Hash
+          hash_str = "{#{value.map { |k, v| "#{serialize_value(k)} => #{serialize_value(v)}" }.join(', ')}}"
+          expr.gsub(/\b#{Regexp.escape(key)}\b/, hash_str)
+        when true, false
+          expr.gsub(/\b#{Regexp.escape(key)}\b/, value.to_s)
+        else
+          expr
+        end
+      end
+
+      def serialize_value(value)
+        case value
+        when Integer, Float, true, false
+          value.to_s
+        when String
+          "\"#{escape_string(value)}\""
+        when Array
+          "[#{value.map { |v| serialize_value(v) }.join(', ')}]"
+        when Hash
+          "{#{value.map { |k, v| "#{serialize_value(k)} => #{serialize_value(v)}" }.join(', ')}}"
+        else
+          'nil'
+        end
+      end
+
+      def escape_string(str)
+        str.gsub('"', '\\"').gsub("\n", '\\n')
+      end
+
+      def transform_methods(expr)
+        expr
+          .gsub('.size()', '.size')
+          .gsub(/\.contains\(([^)]+)\)/, '.include?(\1)')
+          .gsub(/\.startsWith\(([^)]+)\)/, '.start_with?(\1)')
+          .gsub(/\.endsWith\(([^)]+)\)/, '.end_with?(\1)')
+          .gsub(/\.matches\(([^)]+)\)/, '.match?(\1)')
+      end
+
+      def safe_eval(expr, _context)
+        return false unless safe_expression?(expr)
+
+        # rubocop:disable Security/Eval
+        eval(expr)
+        # rubocop:enable Security/Eval
+      rescue StandardError
+        false
+      end
+
+      def safe_expression?(expr)
+        dangerous_patterns = [
+          /`/,
+          /system/i,
+          /exec/i,
+          /fork/i,
+          /spawn/i,
+          /load/i,
+          /require/i,
+          /File\./,
+          /Dir\./,
+          /IO\./,
+          /Kernel\./,
+          /\beval\b/,
+          /send/i,
+          /instance_eval/i,
+          /class_eval/i,
+          /module_eval/i,
+          /define_method/i,
+          /__send__/,
+          /const_get/i,
+          /const_set/i
+        ]
+
+        dangerous_patterns.none? { |pattern| expr.match?(pattern) }
+      end
+    end
+  end
+end

data/lib/rdeck/markdown/frontmatter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Rdeck
+  module Markdown
+    class Frontmatter
+      attr_accessor :presentation_id, :title, :breaks, :defaults, :code_block_to_image_command
+
+      def initialize(attrs = {})
+        @presentation_id = attrs[:presentationID] || attrs['presentationID']
+        @title = attrs[:title] || attrs['title']
+        @breaks = attrs[:breaks] || attrs['breaks']
+        @defaults = parse_defaults(attrs[:defaults] || attrs['defaults'])
+        @code_block_to_image_command = attrs[:codeBlockToImageCommand] || attrs['codeBlockToImageCommand']
+      end
+
+      def self.extract(content)
+        return [nil, content] unless content.start_with?("---\n")
+
+        lines = content.lines
+        return [nil, content] unless lines.first == "---\n"
+
+        closing_index = lines[1..].index { |line| line.strip == '---' }
+        return [nil, content] unless closing_index
+
+        yaml_content = lines[1..closing_index].join
+        body_content = lines[(closing_index + 2)..].join
+
+        begin
+          yaml = YAML.safe_load(yaml_content, permitted_classes: [Symbol], symbolize_names: true)
+          frontmatter = new(yaml || {})
+          [frontmatter, body_content]
+        rescue Psych::SyntaxError => e
+          warn "Failed to parse frontmatter: #{e.message}"
+          [nil, content]
+        end
+      end
+
+      def self.apply_to_file(file_path, title, presentation_id)
+        content = File.exist?(file_path) ? File.read(file_path) : ''
+        frontmatter, body = extract(content)
+
+        frontmatter ||= new
+        frontmatter.title = title if title
+        frontmatter.presentation_id = presentation_id if presentation_id
+
+        new_content = "#{to_yaml_frontmatter(frontmatter)}\n#{body}"
+        File.write(file_path, new_content)
+      end
+
+      def self.to_yaml_frontmatter(frontmatter)
+        hash = {}
+        hash['presentationID'] = frontmatter.presentation_id if frontmatter.presentation_id
+        hash['title'] = frontmatter.title if frontmatter.title
+        hash['breaks'] = frontmatter.breaks unless frontmatter.breaks.nil?
+        hash['defaults'] = frontmatter.defaults if frontmatter.defaults && !frontmatter.defaults.empty?
+        if frontmatter.code_block_to_image_command
+          hash['codeBlockToImageCommand'] =
+            frontmatter.code_block_to_image_command
+        end
+
+        "---\n#{hash.to_yaml.sub(/^---\n/, '')}---"
+      end
+
+      private
+
+      def parse_defaults(defaults_array)
+        return [] unless defaults_array.is_a?(Array)
+
+        defaults_array.map { |default| DefaultCondition.new(default) }
+      end
+    end
+  end
+end