demotape 0.0.2 → 0.0.3

data/lib/demo_tape/command.rb

@@ -62,6 +62,7 @@ module DemoTape
       "F12" => :f12,
       "Meta" => :meta,
       "Command" => :command,
+      "Cmd" => :command,
       "Slash" => "/",
       "BackSlash" => "\\"
     }.freeze
@@ -69,12 +70,14 @@ module DemoTape
     VALID_COMMANDS = KEY_MAPPING.keys + %w[
       Clear
       Copy
+      Group
       Include
       Output
       Pause
       Paste
       Require
       Resume
+      Run
       Screenshot
       Send
       Set
@@ -85,9 +88,10 @@ module DemoTape
       WaitUntil
     ].freeze
 
-    META_COMMANDS = %w[Require Set Include Output].freeze
-    COMMANDS_WITH_SPEED = KEY_MAPPING.keys + %w[Type]
-    COMMANDS_WITH_TIMEOUT = %w[WaitUntil].freeze
+    META_COMMANDS = %w[Group Include Output Require Set].freeze
+    COMMANDS_WITH_DURATION = KEY_MAPPING.keys +
+                             %w[Run Type TypeFile WaitUntil Wait Sleep].freeze
+    COMMANDS_WITH_COUNT = KEY_MAPPING.keys + %w[Wait Sleep Set]
     VALID_TIME_UNITS = %w[ms s m h].freeze
 
     # Valid keys that can be used in key combos
@@ -103,21 +107,21 @@ module DemoTape
       typing_speed variable_typing width
     ].freeze
 
-    attr_reader :type, :args, :options
+    attr_reader :type, :args, :options, :children
     attr_accessor :column, :duration_column, :file, :line, :line_content,
-                  :speed_column, :timeout_column, :tokens
+                  :tokens
 
     def initialize(type, args = "", **options)
       @type = type
       @args = args
       @options = options
+      @children = options.delete(:children) || []
+      @group_invocation = options.delete(:group_invocation) || false
       @line = nil
       @column = nil
       @line_content = nil
       @file = nil
       @duration_column = nil
-      @speed_column = nil
-      @timeout_column = nil
       @tokens = []
     end
 
@@ -126,6 +130,10 @@ module DemoTape
       VALID_KEYS.include?(type)
     end
 
+    def group?
+      type == "Group"
+    end
+
     def keys
       return [] unless key?
 
@@ -153,22 +161,14 @@ module DemoTape
                       .to_sym
     end
 
-    def validate_command!
-      return if VALID_COMMANDS.include?(type)
-
-      raise_error "Unknown command: #{type.inspect}"
+    def find_token(klass, list = tokens)
+      list.find {|token| token.is_a?(klass) }
     end
 
-    def validate_speed!
-      return unless options[:speed] && !COMMANDS_WITH_SPEED.include?(type)
-
-      raise_error "Command #{type.inspect} does not accept speed option"
-    end
-
-    def validate_timeout!
-      return unless options[:timeout] && !COMMANDS_WITH_TIMEOUT.include?(type)
-
-      raise_error "Command #{type.inspect} does not accept timeout option"
+    def group_invocation?
+      # Group invocations are marked as such
+      # AND don't start with uppercase letter
+      @group_invocation && type[0].to_s.match?(/[^A-Z]/)
     end
 
     def validate_set_options!
@@ -180,96 +180,35 @@ module DemoTape
       return if SET_OPTIONS.include?(base_option)
 
       raise_error "Unknown option: #{options[:option].inspect} #{self}",
-                  column_override: tokens[1].column
-    end
-
-    def validate_keys!
-      return unless options[:keys]
-
-      all_keys = options[:keys] + [type]
-
-      all_keys.each do |key|
-        next if VALID_KEYS.include?(key)
-
-        unless VALID_COMMANDS.include?(key)
-          raise_error "Invalid key in combo: #{key.inspect}"
-        end
-
-        raise_error "Command #{key.inspect} doesn't support key combos"
-      end
-    end
-
-    def validate_regex!
-      return unless type == "WaitUntil"
-
-      raise_error "WaitUntil command requires a regex pattern" if args.empty?
-
-      begin
-        options[:pattern] = Regexp.new(args)
-      rescue RegexpError => error
-        raise_error "Invalid regex pattern: #{error.message}"
-      end
+                  column_override: tokens[2].column
     end
 
     def prepare!
-      validate_command!
-      validate_speed!
-      validate_timeout!
       normalize_theme_options!
       validate_set_options!
-      validate_keys!
-      validate_regex!
-      validate_duration!
-      validate_type_file!
-
       normalize_spacing_values!
 
       self
     end
 
-    private def validate_type_file!
-      return unless type == "TypeFile"
-
-      raise_error "TypeFile command requires a file path" if args.empty?
-    end
-
-    private def validate_duration!
-      [args, :duration] => [duration, source] if %w[Sleep Wait].include?(type)
-      [options[:speed], :speed] => [duration, source] if options[:speed]
-      [options[:timeout], :timeout] => [duration, source] if options[:timeout]
-
-      return unless duration
-
-      unit = duration[/[a-z]+$/i]
-      return if VALID_TIME_UNITS.include?(unit)
-
-      col = case source
-            when :speed then speed_column
-            when :timeout then timeout_column
-            else duration_column
-            end
-
-      raise_error "Invalid time unit: #{unit.inspect}", column_override: col
-    end
-
     private def normalize_theme_options!
       return unless type == "Set"
       return unless options[:option]&.include?(".")
 
-      option, sub_option = *options[:option].split(".", 2)
+      option, property = *options[:option].split(".", 2)
 
       unless option == "theme"
         raise_error "Unexpected attribute #{options[:option].inspect}",
-                    column_override: tokens[1].column
+                    column_override: tokens[2].column
       end
 
-      unless Theme.valid_options.include?(sub_option.to_sym)
+      unless Theme.valid_options.include?(property.to_sym)
         raise_error "Invalid theme property",
-                    column_override: tokens[1].column + 6 # ".theme".size
+                    column_override: tokens[2].column + option.length + 1
       end
 
       @options[:option] = option
-      @options[:sub_option] = sub_option
+      @options[:property] = property
     end
 
     private def normalize_spacing_values!
@@ -286,12 +225,23 @@ module DemoTape
 
     def raise_error(message, column_override: nil)
       col = column_override || column
+      line_content = tokens
+                     # Remove "end" keyword from line content
+                     # This is required so we can properly point to errors
+                     # in commands that have blocks (e.g. Run do..end)
+                     .reject { it.is_a?(Token::Keyword) && it.value == "end" }
+                     .map(&:raw).join
 
-      raise DemoTape::ParseError, message unless line && col && line_content
+      raise DemoTape::ParseError, message unless line && col
 
       error_msg = "#{message} at #{location(column_override:)}:\n"
-      error_msg += "  #{line_content}\n"
-      error_msg += "  #{' ' * (col - 1)}^"
+      error_msg += "  #{line_content.strip}\n"
+
+      # Calculate pointer position: col is absolute position in original line
+      # line_content.strip removes leading spaces, so we need to adjust
+      leading_spaces = line_content[/^\s*/].size
+      pointer_col = col - leading_spaces - 1
+      error_msg += "  #{' ' * pointer_col}^"
 
       raise DemoTape::ParseError, error_msg
     end
@@ -308,28 +258,38 @@ module DemoTape
 
       tokens.each_with_index do |token, index|
         previous_token = tokens[index - 1]
-        preceded_by_comma = previous_token.is_a?(Token::Operator) &&
-                            previous_token.value == ","
+        preceded_by_number = previous_token.is_a?(Token::Number)
+        preceded_by_group_name = tokens[index - 2]&.value == "Group"
+        preceded_by_command_with_duration =
+          %w[Sleep Wait].include?(tokens[index - 2]&.value) # rubocop:disable Performance/CollectionLiteralInLoop
 
         case token
+        when Token::Duration
+          duration = token.value[:raw].to_s.strip
+          duration = "#{duration}s" if token.value[:unit].to_s.strip == ""
+          values << thor.set_color(duration, :cyan)
         when Token::String
-          values << " "
           values << thor.set_color(token.raw, :yellow)
         when Token::Operator
           values << thor.set_color(token.value, :white)
         when Token::Number
-          values << " " unless previous_token.is_a?(Token::Operator)
-          values << " " if preceded_by_comma
-          values << thor.set_color(token.value, :magenta)
-        when Token::Duration
-          values << " " unless previous_token.is_a?(Token::Operator)
-          values << thor.set_color(token.value, :magenta)
+          values << if preceded_by_command_with_duration
+                      thor.set_color("#{token.value}s", :cyan)
+                    else
+                      thor.set_color(token.value, :magenta)
+                    end
         when Token::Regex
-          values << " "
           values << thor.set_color(token.raw, :green)
         when Token::Identifier
-          values << " " if previous_token.is_a?(Token::Identifier)
-          values << thor.set_color(token.value, :blue)
+          values << if preceded_by_group_name
+                      thor.set_color(token.value, :cyan)
+                    else
+                      thor.set_color(token.value, :blue)
+                    end
+        when Token::Space
+          values << " " unless preceded_by_number
+        when Token::Keyword
+          # do nothing
         else
           raise "Unexpected token type: #{token.class.name}"
         end

data/lib/demo_tape/exporter.rb

@@ -214,6 +214,9 @@ module DemoTape
     end
 
     def get_png_dimensions(file_path)
+      return [0, 0] unless file_path
+      return [0, 0] unless File.file?(file_path)
+
       File.open(file_path, "rb") do |f|
         f.read(8)  # Skip PNG signature
         f.read(4)  # Skip chunk length

data/lib/demo_tape/formatter.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module DemoTape
+  class Formatter
+    attr_accessor :buffered_newlines
+
+    def initialize(input)
+      @input = input
+      @buffered_newlines = 0
+    end
+
+    def newline?(token)
+      token.instance_of?(Token::Newline)
+    end
+
+    def call
+      parser = Parser.new
+      tree = parser.parse(@input)
+
+      meta = extract_meta!(tree)
+
+      output = [
+        collect(meta).flatten.compact.join.strip,
+        collect(tree).flatten.compact.join.strip
+      ].reject(&:empty?).join("\n\n")
+
+      "#{output}\n"
+    end
+
+    def extract_meta!(tree, meta = [])
+      tree.each do |node|
+        next unless node.is_a?(Hash)
+
+        if node[:type] == :command
+          first_token = node[:tokens].reject(&:any_space?).first
+          next unless first_token.meta?
+
+          meta << node
+          meta << Token::Newline.new("\n")
+          tree.delete(node)
+        elsif node[:type] == :group
+          extract_meta!(node[:children], meta)
+        end
+      end
+
+      meta
+    end
+
+    def collect(tree, output = [])
+      query = Query.new(tree)
+
+      tree.each_with_index do |node, _index|
+        # Whenever we hit a non-newline, flush buffered newlines (first)
+        # and then process the node. Newlines are clamped to max 2.
+        unless newline?(node)
+          newlines = buffered_newlines.clamp(0, 2)
+          output << ("\n" * newlines)
+          self.buffered_newlines = 0
+        end
+
+        case node
+        when Token::Keyword
+          output << node.value unless node.keyword?("end")
+        when Token::Identifier
+          output << if node.group?
+                      "\n#{node.value}"
+                    else
+                      node.value
+                    end
+        when Token::Duration, Token::Comment
+          output << node.value
+        when Token::Newline
+          self.buffered_newlines += 1
+        when Token::Number
+          value = [node.value.to_s]
+          value << "s" if query.previous_identifier?(node, /Sleep|Wait/)
+          output << value.join
+        when Token::String
+          output << normalize_string(node)
+        when Token::MultilineString
+          output << %["""\n#{node.value.chomp}\n"""\n]
+        when Token::Space
+          output << " "
+        when Token::LeadingSpace
+          next if output.empty?
+          next unless within_group?
+
+          output << "  "
+        when Hash
+          output = [output.flatten.compact.join]
+          output << collect(node[:tokens])
+
+          if node[:type] == :group
+            within_group do
+              output << "\n  "
+              output << collect(node[:children]).join.strip
+              output << "\nend"
+              self.buffered_newlines += 1
+            end
+          end
+        else
+          output << node.raw
+        end
+      end
+
+      output
+    end
+
+    def within_group?
+      @within_group
+    end
+
+    def within_group
+      @within_group = true
+      yield
+    ensure
+      @within_group = false
+    end
+
+    def normalize_string(token)
+      %["#{token.value}"]
+    end
+
+    class Query
+      attr_reader :nodes
+
+      def initialize(nodes)
+        @nodes = nodes
+      end
+
+      def previous_identifier?(current_node, value)
+        index = nodes.index(current_node)
+        return false if index.nil? || index.zero?
+
+        previous_node = nodes[index - 2]
+
+        previous_node.is_a?(Token::Identifier) &&
+          previous_node.value.match?(value)
+      end
+    end
+  end
+end

data/lib/demo_tape/lexer.rb

@@ -2,10 +2,6 @@
 
 module DemoTape
   class Lexer
-    def self.tokenize(content)
-      new.tokenize(content)
-    end
-
     attr_reader :line_map
 
     def tokenize(content)
@@ -39,7 +35,7 @@ module DemoTape
               content: '"""',
               raw: '"""..."""'
             }
-            tokens << [:STRING, multiline_text]
+            tokens << [:MULTILINE_STRING, multiline_text]
             token_index += 1
 
             # Add NEWLINE token after multiline string
@@ -59,25 +55,99 @@ module DemoTape
           next
         end
 
-        # Skip empty lines and comments (but only when not in multiline)
-        next if stripped_line.empty? || stripped_line.start_with?("#")
+        # Handle comments - emit as tokens
+        if stripped_line.start_with?("#")
+          # Emit LEADING_SPACE if there's any
+          leading_space = original_line[/^[ \t]*/]
+          if leading_space && !leading_space.empty?
+            @line_map[token_index] = {
+              line: @line_number,
+              column: 1,
+              content: original_line.chomp,
+              raw: leading_space
+            }
+            tokens << [:LEADING_SPACE, leading_space]
+            token_index += 1
+          end
+
+          # Emit COMMENT token
+          @line_map[token_index] = {
+            line: @line_number,
+            column: leading_space.length + 1,
+            content: original_line.chomp,
+            raw: stripped_line
+          }
+          tokens << [:COMMENT, stripped_line]
+          token_index += 1
+
+          @line_map[token_index] = {
+            line: @line_number,
+            column: 1,
+            content: original_line.chomp
+          }
+          tokens << [:NEWLINE, "\n"]
+          token_index += 1
+          next
+        end
+
+        # Handle empty lines - emit just NEWLINE
+        if stripped_line.empty?
+          @line_map[token_index] = {
+            line: @line_number,
+            column: 1,
+            content: ""
+          }
+          tokens << [:NEWLINE, "\n"]
+          token_index += 1
+          next
+        end
+
+        # Tokenize the original line (preserving all spaces)
+        line_tokens = tokenize_line(line.chomp)
+
+        # Convert first SPACE token to LEADING_SPACE if it exists
+        if line_tokens.any? && line_tokens[0][0] == :SPACE
+          line_tokens[0][0] = :LEADING_SPACE
+        end
+
+        # Special case: if the line is just whitespace followed by 'end', skip
+        # the LEADING_SPACE. This helps the parser avoid shift/reduce conflicts
+        # with group_body rules
+        if line_tokens.length >= 2 &&
+           line_tokens[0][0] == :LEADING_SPACE &&
+           line_tokens[1][0] == :END &&
+           (line_tokens.length == 2 || line_tokens[2][0] == :SPACE)
+          # Skip the leading space token for 'end' keyword
+          line_tokens.shift
+        end
 
-        line_tokens = tokenize_line(stripped_line)
+        # Convert last SPACE token (before end) to TRAILING_SPACE if it exists
+        last_non_newline = line_tokens.length - 1
+
+        while last_non_newline >= 0 &&
+              line_tokens[last_non_newline][0] == :NEWLINE
+          last_non_newline -= 1
+        end
+
+        if last_non_newline >= 0 && line_tokens[last_non_newline][0] == :SPACE
+          line_tokens[last_non_newline][0] = :TRAILING_SPACE
+        end
 
         # Check if any token starts a multiline string
-        multiline_idx = line_tokens.find_index do |t|
+        multiline_index = line_tokens.find_index do |t|
           t[0] == :TRIPLE_QUOTE_START
         end
-        if multiline_idx
+
+        if multiline_index
           # Process tokens before the triple quote
-          line_tokens[0...multiline_idx].each do |token|
+          line_tokens[0...multiline_index].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,
+              content: original_line.chomp,
               raw: raw
             }
 
@@ -86,12 +156,12 @@ module DemoTape
             token_index += 1
           end
 
-          tokens.concat(line_tokens[0...multiline_idx])
+          tokens.concat(line_tokens[0...multiline_index])
 
           # Start multiline mode
           in_multiline = true
           multiline_start_line = @line_number
-          multiline_start_col = line_tokens[multiline_idx][2] || 1
+          multiline_start_col = line_tokens[multiline_index][2] || 1
           multiline_content = []
           next
         end
@@ -104,7 +174,7 @@ module DemoTape
           @line_map[token_index] = {
             line: @line_number,
             column: col,
-            content: original_line.strip,
+            content: original_line.chomp,
             raw: raw
           }
 
@@ -119,7 +189,7 @@ module DemoTape
         @line_map[token_index] = {
           line: @line_number,
           column: 1,
-          content: original_line.strip
+          content: original_line.chomp
         }
 
         tokens << [:NEWLINE, "\n"]
@@ -157,22 +227,36 @@ module DemoTape
 
         # Regex pattern (between forward slashes)
         elsif scanner.scan(%r{/((?:[^/\\]|\\.)*)/})
-          tokens << [:REGEX, scanner[1], col, scanner[0]]
+          result = begin
+            {pattern: Regexp.new(scanner[1])}
+          rescue RegexpError => error
+            {error: error.message.gsub("/#{scanner[1]}/", "").strip.chomp(":")}
+          end
+
+          tokens << [:REGEX, result, col, scanner[0]]
 
         # Duration (number + time unit - any identifier)
-        elsif scanner.scan(/(\d+(?:\.\d+)?|\.\d+)([a-zA-Z]+)/)
+        elsif scanner.scan(/(\d+(?:\.\d+)?|-?\.\d+)([a-zA-Z]+)/)
+          number_part = scanner[1]
+          unit_part = scanner[2]
+          full_match = scanner[0]
           tokens << [
-            :NUMBER,
-            scanner[1].include?(".") ? scanner[1].to_f : scanner[1].to_i,
+            :DURATION,
+            {
+              number: if number_part.include?(".")
+                        number_part.to_f
+                      else
+                        number_part.to_i
+                      end,
+              unit: unit_part,
+              raw: full_match
+            },
             col,
-            scanner[1]
+            full_match
           ]
-          # 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+/)
+        # Number (including negative numbers)
+        elsif scanner.scan(/-?(?:\d+(?:\.\d+)?|\.\d+)/)
           value = scanner[0].include?(".") ? scanner[0].to_f : scanner[0].to_i
           tokens << [:NUMBER, value, col, scanner[0]]
 
@@ -190,14 +274,14 @@ module DemoTape
 
         # 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
+          # Check for keywords
+          value = scanner[0]
+          token_type = case value
+                       when "do" then :DO
+                       when "end" then :END
+                       else :IDENTIFIER
+                       end
+          tokens << [token_type, value, col, value]
         end
       end