demotape 0.0.0.pre.0

data/lib/demo_tape/duration.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DemoTape
+  class Duration
+    VALID_UNITS = %w[ms s m h].freeze
+
+    def self.parse(input)
+      input = "0#{input}" if input.to_s.start_with?(".")
+
+      return input if input.is_a?(Numeric)
+      return 1 if input.to_s.strip.empty?
+
+      value, unit = *input.match(/((?:\d+\.)?(?:\d+))([a-z]{1,2})?/).captures
+
+      unit ||= "s"
+
+      case unit
+      when "ms"
+        value.to_f / 1000.0
+      when "s"
+        value.to_f
+      when "m"
+        value.to_f * 60.0
+      when "h"
+        value.to_f * 3600.0
+      else
+        raise ArgumentError, "Unknown time unit: #{unit.inspect}"
+      end
+    end
+  end
+end

data/lib/demo_tape/exporter.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+module DemoTape
+  class Exporter
+    attr_reader :tmp_dir, :frame_count, :options, :theme
+
+    def initialize(tmp_dir:, frame_count:, options:, theme:)
+      @tmp_dir = tmp_dir
+      @frame_count = frame_count
+      @options = options
+      @theme = theme
+    end
+
+    def bounds
+      @bounds ||= compute_image_bounds
+    end
+
+    def video(path)
+      text_input = tmp_dir.join("frame-text-%05d.png")
+      cursor_input = tmp_dir.join("frame-cursor-%05d.png")
+      mask_path = tmp_dir.join("border-radius-mask.png")
+
+      create_border_radius_mask(
+        bounds.with_padding_width,
+        bounds.with_padding_height,
+        options.border_radius,
+        mask_path
+      )
+
+      # Check if margin_fill is a file path
+      if File.file?(options.margin_fill)
+        # Use image as background
+        filter = build_filter_with_image_background(bounds, mask_path)
+
+        inputs = []
+        inputs << "-framerate #{options.fps} -i #{text_input}"
+        inputs << "-framerate #{options.fps} -i #{cursor_input}"
+        inputs << "-loop 1 -i #{Shellwords.escape(options.margin_fill)}"
+        inputs << "-loop 1 -i #{Shellwords.escape(mask_path)}"
+      else
+        # Use solid color as background
+        filter = build_filter_with_color_background(bounds, mask_path)
+
+        inputs = []
+        inputs << "-framerate #{options.fps} -i #{text_input}"
+        inputs << "-framerate #{options.fps} -i #{cursor_input}"
+        inputs << "-loop 1 -i #{Shellwords.escape(mask_path)}"
+      end
+
+      cmd = <<~CMD
+        ffmpeg -y \
+          -loglevel error \
+          #{inputs.join(" \\\n            ")} \
+          -filter_complex "#{filter}" \
+          -frames:v #{frame_count} \
+          -c:v libx264 \
+          -pix_fmt yuv420p \
+          -r #{options.fps} \
+          -movflags +faststart \
+          #{Shellwords.escape(path)}
+      CMD
+
+      system(cmd)
+    end
+
+    def webm(path)
+      text_input = tmp_dir.join("frame-text-%05d.png")
+      cursor_input = tmp_dir.join("frame-cursor-%05d.png")
+
+      # Always create border radius mask (square corners if radius is 0)
+      mask_path = tmp_dir.join("border-radius-mask.png")
+      create_border_radius_mask(
+        bounds.with_padding_width,
+        bounds.with_padding_height,
+        options.border_radius,
+        mask_path
+      )
+
+      # Check if margin_fill is a file path
+      if File.file?(options.margin_fill)
+        # Use image as background
+        filter = build_filter_with_image_background(bounds, mask_path)
+
+        inputs = []
+        inputs << "-framerate #{options.fps} -i #{text_input}"
+        inputs << "-framerate #{options.fps} -i #{cursor_input}"
+        inputs << "-loop 1 -i #{Shellwords.escape(options.margin_fill)}"
+        inputs << "-loop 1 -i #{Shellwords.escape(mask_path)}"
+      else
+        # Use solid color as background
+        filter = build_filter_with_color_background(bounds, mask_path)
+
+        inputs = []
+        inputs << "-framerate #{options.fps} -i #{text_input}"
+        inputs << "-framerate #{options.fps} -i #{cursor_input}"
+        inputs << "-loop 1 -i #{Shellwords.escape(mask_path)}"
+      end
+
+      cmd = <<~CMD
+        ffmpeg -y \
+          -loglevel error \
+          #{inputs.join(" \\\n            ")} \
+          -filter_complex "#{filter}" \
+          -frames:v #{frame_count} \
+          -c:v libvpx-vp9 \
+          -pix_fmt yuva420p \
+          -b:v 0 \
+          -crf 30 \
+          -r #{options.fps} \
+          #{Shellwords.escape(path)}
+      CMD
+
+      system(cmd)
+    end
+
+    def gif(path)
+      text_input = tmp_dir.join("frame-text-%05d.png")
+      cursor_input = tmp_dir.join("frame-cursor-%05d.png")
+      loop_flag = options.loop ? "-loop 0" : "-loop -1"
+
+      # Always create border radius mask (square corners if radius is 0)
+      mask_path = tmp_dir.join("border-radius-mask.png")
+      create_border_radius_mask(
+        bounds.with_padding_width,
+        bounds.with_padding_height,
+        options.border_radius,
+        mask_path
+      )
+
+      # Check if margin_fill is a file path
+      if File.file?(options.margin_fill)
+        # Use image as background
+        filter = build_filter_with_image_background(bounds, mask_path)
+
+        inputs = []
+        inputs << "-framerate #{options.fps} -i #{text_input}"
+        inputs << "-framerate #{options.fps} -i #{cursor_input}"
+        inputs << "-loop 1 -i #{Shellwords.escape(options.margin_fill)}"
+        inputs << "-loop 1 -i #{Shellwords.escape(mask_path)}"
+      else
+        # Use solid color as background
+        filter = build_filter_with_color_background(bounds, mask_path)
+
+        inputs = []
+        inputs << "-framerate #{options.fps} -i #{text_input}"
+        inputs << "-framerate #{options.fps} -i #{cursor_input}"
+        inputs << "-loop 1 -i #{Shellwords.escape(mask_path)}"
+      end
+
+      filter = apply_gif_loop_delay(filter)
+      total_frames = calculate_gif_total_frames
+
+      cmd = <<~CMD
+        ffmpeg -y \
+          -loglevel error \
+          #{inputs.join(" \\\n            ")} \
+          -filter_complex "#{filter}" \
+          -frames:v #{total_frames} \
+          #{loop_flag} \
+          -r #{options.fps} \
+          #{Shellwords.escape(path)}
+      CMD
+
+      system(cmd)
+    end
+
+    def png(path)
+      text_input = tmp_dir.join(format("frame-text-%05d.png", frame_count))
+      cursor_input = tmp_dir.join(format("frame-cursor-%05d.png", frame_count))
+
+      # Always create border radius mask (square corners if radius is 0)
+      mask_path = tmp_dir.join("border-radius-mask.png")
+      create_border_radius_mask(
+        bounds.with_padding_width,
+        bounds.with_padding_height,
+        options.border_radius,
+        mask_path
+      )
+
+      # Check if margin_fill is a file path
+      if File.file?(options.margin_fill)
+        # Use image as background
+        filter = build_filter_with_image_background(bounds, mask_path)
+
+        inputs = []
+        inputs << "-i #{Shellwords.escape(text_input.to_s)}"
+        inputs << "-i #{Shellwords.escape(cursor_input.to_s)}"
+        inputs << "-i #{Shellwords.escape(options.margin_fill)}"
+        inputs << "-i #{Shellwords.escape(mask_path)}"
+      else
+        # Use solid color as background
+        filter = build_filter_with_color_background(bounds, mask_path)
+
+        inputs = []
+        inputs << "-i #{Shellwords.escape(text_input.to_s)}"
+        inputs << "-i #{Shellwords.escape(cursor_input.to_s)}"
+        inputs << "-i #{Shellwords.escape(mask_path)}"
+      end
+
+      cmd = <<~CMD
+        ffmpeg -y \
+          -loglevel error \
+          #{inputs.join(" \\\n            ")} \
+          -filter_complex "#{filter}" \
+          -frames:v 1 \
+          #{Shellwords.escape(path)}
+      CMD
+
+      system(cmd)
+    end
+
+    def get_png_dimensions(file_path)
+      File.open(file_path, "rb") do |f|
+        f.read(8)  # Skip PNG signature
+        f.read(4)  # Skip chunk length
+        f.read(4)  # Skip "IHDR"
+        width = f.read(4).unpack1("N")   # Read width (big-endian)
+        height = f.read(4).unpack1("N")  # Read height (big-endian)
+        [width, height]
+      end
+    end
+
+    def compute_image_bounds
+      first_frame = tmp_dir.glob("frame-text-*.png").first
+      actual_width, actual_height = get_png_dimensions(first_frame)
+      padding = options.padding
+      margin = options.margin
+
+      # options.width and options.height are the FINAL output dimensions
+      # We need to work backwards: final size includes margin
+      final_width = options.width
+      final_height = options.height
+
+      # Calculate how much space is available for padding area
+      # (after subtracting margin)
+      available_for_padding_width = final_width - margin.left - margin.right
+      available_for_padding_height = final_height - margin.top - margin.bottom
+
+      # Calculate content width/height with user-specified padding
+      content_width = actual_width + padding.left + padding.right
+      content_height = actual_height + padding.top + padding.bottom
+
+      # Any additional space needed goes to right and bottom
+      extra_width = [0, available_for_padding_width - content_width].max
+      extra_height = [0, available_for_padding_height - content_height].max
+
+      # Dimensions after padding is applied
+      # (fits within available space after margin)
+      with_padding_width = content_width + extra_width
+      with_padding_height = content_height + extra_height
+
+      Bounds.new(
+        padding_left: padding.left,
+        padding_top: padding.top,
+        with_padding_width:,
+        with_padding_height:,
+        margin_left: margin.left,
+        margin_top: margin.top,
+        with_margin_width: final_width,
+        with_margin_height: final_height
+      )
+    end
+
+    def build_filter_with_image_background(bounds, _mask_path)
+      # Input 0: text frames
+      # Input 1: cursor frames
+      # Input 2: background image
+      # Input 3: mask
+
+      # Scale background to output size and center/crop if needed
+      filter = "[2:v]scale=#{bounds.with_margin_width}:#{bounds.with_margin_height}:force_original_aspect_ratio=increase,crop=#{bounds.with_margin_width}:#{bounds.with_margin_height}[bg];" # rubocop:disable Layout/LineLength
+
+      # Overlay text+cursor, add padding
+      filter += "[0:v][1:v]overlay=0:0"
+      filter += ",pad=#{bounds.with_padding_width}:#{bounds.with_padding_height}:#{bounds.padding_left}:#{bounds.padding_top}:#{theme.background}" # rubocop:disable Layout/LineLength
+
+      # Apply border radius mask
+      filter += "[term];[3]loop=-1[mask];[term][mask]alphamerge[terminal];"
+
+      # Overlay terminal on background, centered
+      filter += "[bg][terminal]overlay=(W-w)/2:(H-h)/2"
+      filter
+    end
+
+    def build_filter_with_color_background(bounds, _mask_path)
+      # Overlay text+cursor, add padding, then add margin
+      filter = "[0:v][1:v]overlay=0:0"
+      filter += ",pad=#{bounds.with_padding_width}:#{bounds.with_padding_height}:#{bounds.padding_left}:#{bounds.padding_top}:#{theme.background}" # rubocop:disable Layout/LineLength
+
+      # Apply border radius mask
+      filter += "[term];[2]loop=-1[mask];[term][mask]alphamerge"
+
+      filter += ",pad=#{bounds.with_margin_width}:#{bounds.with_margin_height}:#{bounds.margin_left}:#{bounds.margin_top}:#{options.margin_fill}" # rubocop:disable Layout/LineLength
+      filter
+    end
+
+    def create_border_radius_mask(width, height, radius, path)
+      # Ensure radius is non-negative
+      radius = [0, radius.to_i].max
+
+      # Create a grayscale image for the alpha mask
+      img = ChunkyPNG::Image.new(width, height, ChunkyPNG::Color::BLACK)
+
+      if radius.zero?
+        # No border radius - just fill everything white
+        (0...height).each do |y|
+          (0...width).each do |x|
+            img[x, y] = ChunkyPNG::Color::WHITE
+          end
+        end
+      else
+        # Draw a white rounded rectangle
+        # Fill the main rectangle
+        (radius...(height - radius)).each do |y|
+          (0...width).each do |x|
+            img[x, y] = ChunkyPNG::Color::WHITE
+          end
+        end
+
+        (0...height).each do |y|
+          (radius...(width - radius)).each do |x|
+            img[x, y] = ChunkyPNG::Color::WHITE
+          end
+        end
+
+        # Draw the four rounded corners
+        draw_rounded_corner(img, radius, radius, radius)
+        draw_rounded_corner(img, width - radius - 1, radius, radius)
+        draw_rounded_corner(img, radius, height - radius - 1, radius)
+        draw_rounded_corner(img, width - radius - 1, height - radius - 1,
+                            radius)
+      end
+
+      img.save(path)
+    end
+
+    def draw_rounded_corner(img, cx, cy, radius)
+      (-radius..radius).each do |dy|
+        (-radius..radius).each do |dx|
+          dist_sq = (dx * dx) + (dy * dy)
+          next unless dist_sq <= (radius + 1) * (radius + 1)
+
+          x = cx + dx
+          y = cy + dy
+          if x.negative? || x >= img.width || y.negative? || y >= img.height
+            next
+          end
+
+          img[x, y] = ChunkyPNG::Color::WHITE
+        end
+      end
+    end
+
+    def apply_gif_loop_delay(filter)
+      delay = Duration.parse(options.loop_delay)
+
+      return filter unless delay.positive?
+
+      delay_frames = (delay * options.fps).ceil
+      "#{filter},tpad=stop_mode=clone:stop_duration=#{delay_frames}"
+    end
+
+    def calculate_gif_total_frames
+      delay = Duration.parse(options.loop_delay)
+
+      return frame_count unless delay.positive?
+
+      delay_frames = (delay * options.fps).ceil
+      frame_count + delay_frames
+    end
+  end
+end

data/lib/demo_tape/generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DemoTape
+  class Generator < Thor::Group
+    include Thor::Actions
+
+    attr_accessor :options
+
+    def self.source_root
+      File.join(__dir__, "templates")
+    end
+
+    no_commands do
+      # Add helper methods here
+    end
+  end
+end

data/lib/demo_tape/lexer.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module DemoTape
+  class Lexer
+    def self.tokenize(content)
+      new.tokenize(content)
+    end
+
+    attr_reader :line_map
+
+    def tokenize(content)
+      tokens = []
+      @line_map = {}
+      @line_number = 0
+      token_index = 0
+      in_multiline = false
+      multiline_content = []
+      multiline_start_line = 0
+      multiline_start_col = 1
+
+      content.each_line do |line|
+        @line_number += 1
+        original_line = line.dup
+        stripped_line = line.strip
+
+        # Handle multiline string collection
+        if in_multiline
+          if stripped_line == '"""'
+            # End of multiline string
+            in_multiline = false
+
+            # Create the multiline string token,
+            # but first, strip the initial linebreak after the opening quotes
+            multiline_content.first.gsub!(/\A\r?\n/, "")
+            multiline_text = multiline_content.join("\n")
+            @line_map[token_index] = {
+              line: multiline_start_line,
+              column: multiline_start_col,
+              content: '"""',
+              raw: '"""..."""'
+            }
+            tokens << [:STRING, multiline_text]
+            token_index += 1
+
+            # Add NEWLINE token after multiline string
+            @line_map[token_index] = {
+              line: @line_number,
+              column: 1,
+              content: '"""'
+            }
+            tokens << [:NEWLINE, "\n"]
+            token_index += 1
+
+            multiline_content = []
+          else
+            # Collect line content (preserve original spacing)
+            multiline_content << line.chomp
+          end
+          next
+        end
+
+        # Skip empty lines and comments (but only when not in multiline)
+        next if stripped_line.empty? || stripped_line.start_with?("#")
+
+        line_tokens = tokenize_line(stripped_line)
+
+        # Check if any token starts a multiline string
+        multiline_idx = line_tokens.find_index do |t|
+          t[0] == :TRIPLE_QUOTE_START
+        end
+        if multiline_idx
+          # Process tokens before the triple quote
+          line_tokens[0...multiline_idx].each do |token|
+            col = token[2] || 1
+            raw = token[3] || token[1].to_s
+
+            @line_map[token_index] = {
+              line: @line_number,
+              column: col,
+              content: original_line.strip,
+              raw: raw
+            }
+
+            token.pop if token.size == 4
+            token.pop if token.size == 3
+            token_index += 1
+          end
+
+          tokens.concat(line_tokens[0...multiline_idx])
+
+          # Start multiline mode
+          in_multiline = true
+          multiline_start_line = @line_number
+          multiline_start_col = line_tokens[multiline_idx][2] || 1
+          multiline_content = []
+          next
+        end
+
+        # Store line metadata separately indexed by token position
+        line_tokens.each do |token|
+          col = token[2] || 1
+          raw = token[3] || token[1].to_s
+
+          @line_map[token_index] = {
+            line: @line_number,
+            column: col,
+            content: original_line.strip,
+            raw: raw
+          }
+
+          # Remove column and raw from token before adding to tokens array
+          token.pop if token.size == 4  # Remove raw
+          token.pop if token.size == 3  # Remove column
+          token_index += 1
+        end
+
+        tokens.concat(line_tokens)
+
+        @line_map[token_index] = {
+          line: @line_number,
+          column: 1,
+          content: original_line.strip
+        }
+
+        tokens << [:NEWLINE, "\n"]
+        token_index += 1
+      end
+
+      tokens
+    end
+
+    private def tokenize_line(line)
+      tokens = []
+      scanner = StringScanner.new(line)
+
+      until scanner.eos?
+        # Track column position before scanning token
+        col = scanner.pos + 1
+
+        # Whitespace (emit as token instead of skipping)
+        if scanner.scan(/\s+/)
+          tokens << [:SPACE, scanner[0], col]
+          next
+        end
+
+        # Triple-quoted string start
+        if scanner.scan('"""')
+          tokens << [:TRIPLE_QUOTE_START, '"""', col, '"""']
+
+        # Double-quoted string (with escape support)
+        elsif scanner.scan(/"((?:[^"\\]|\\.)*)"/)
+          tokens << [:STRING, unescape_string(scanner[1]), col, scanner[0]]
+
+        # Single-quoted string (with escape support)
+        elsif scanner.scan(/'((?:[^'\\]|\\.)*)'/) # rubocop:disable Lint/DuplicateBranch
+          tokens << [:STRING, unescape_string(scanner[1]), col, scanner[0]]
+
+        # Regex pattern (between forward slashes)
+        elsif scanner.scan(%r{/((?:[^/\\]|\\.)*)/})
+          tokens << [:REGEX, scanner[1], col, scanner[0]]
+
+        # Duration (number + time unit - any identifier)
+        elsif scanner.scan(/(\d+(?:\.\d+)?|\.\d+)([a-zA-Z]+)/)
+          tokens << [
+            :NUMBER,
+            scanner[1].include?(".") ? scanner[1].to_f : scanner[1].to_i,
+            col,
+            scanner[1]
+          ]
+          # TIME_UNIT starts after the number
+          time_unit_col = col + scanner[1].length
+          tokens << [:TIME_UNIT, scanner[2], time_unit_col, scanner[2]]
+
+        # Number
+        elsif scanner.scan(/\d+(?:\.\d+)?|\.\d+/)
+          value = scanner[0].include?(".") ? scanner[0].to_f : scanner[0].to_i
+          tokens << [:NUMBER, value, col, scanner[0]]
+
+        # At symbol
+        elsif scanner.scan("@")
+          tokens << [:AT, "@", col, "@"]
+
+        # Plus symbol
+        elsif scanner.scan("+")
+          tokens << [:PLUS, "+", col, "+"]
+
+        # Comma
+        elsif scanner.scan(",")
+          tokens << [:COMMA, ",", col, ","]
+
+        # Identifier (including dot notation for nested options)
+        elsif scanner.scan(/[a-zA-Z_][\w.]*/)
+          tokens << [:IDENTIFIER, scanner[0], col, scanner[0]]
+
+        # Word
+        elsif scanner.scan(/\S+/)
+          tokens << [:WORD, scanner[0], col, scanner[0]]
+
+        else
+          break
+        end
+      end
+
+      tokens
+    end
+
+    def unescape_string(str)
+      # First handle Unicode escapes to avoid double-processing
+      str = str.gsub(/\\u([0-9a-fA-F]{4})/) do
+        code_point = Regexp.last_match(1).to_i(16)
+
+        # Check if this is a high surrogate (0xD800-0xDBFF)
+        if code_point.between?(0xD800, 0xDBFF)
+          # Look ahead for low surrogate
+          remaining = Regexp.last_match.post_match
+
+          if remaining =~ /^\\u([dD][c-fC-F][0-9a-fA-F]{2})/
+            low_surrogate = Regexp.last_match(1).to_i(16)
+
+            # Combine surrogates into single code point
+            full_code_point = 0x10000 +
+                              ((code_point - 0xD800) << 10) +
+                              (low_surrogate - 0xDC00)
+
+            # Return the character and mark the low surrogate for removal
+            "#{[full_code_point].pack('U*')}\u0000SKIP6"
+          else
+            # Orphaned high surrogate, keep as-is
+            [code_point].pack("U*")
+          end
+        elsif code_point.between?(0xDC00, 0xDFFF)
+          # Low surrogate without high surrogate, skip if marked
+          ""
+        else
+          [code_point].pack("U*")
+        end
+      end
+
+      # Remove skip markers left by surrogate pair processing
+      str = str.gsub("\x00SKIP6", "")
+
+      # Handle 8-digit Unicode escapes
+      str = str.gsub(/\\U([0-9a-fA-F]{8})/) do
+        code_point = Regexp.last_match(1).to_i(16)
+        [code_point].pack("U*")
+      end
+
+      # Handle other escape sequences
+      str.gsub(/\\(.)/) do
+        case Regexp.last_match(1)
+        when "n" then "\n"
+        when "t" then "\t"
+        when "r" then "\r"
+        when "\\" then "\\"
+        when '"' then '"'
+        when "'" then "'"
+        else Regexp.last_match(1) # Keep other escapes as-is
+        end
+      end
+    end
+  end
+end