demotape 0.0.2 → 0.0.3

data/demotape_new.y.backup

@@ -0,0 +1,160 @@
+class DemoTape::Parser
+rule
+  # Top level: document is a flat list of tokens and contexts
+  document: items { result = val[0].flatten.compact }
+          | /* empty */ { result = [] }
+
+  items: item { result = [val[0]] }
+       | items item { result = val[0] << val[1] }
+
+  # An item can be a token or a context
+  item: COMMENT { result = make_token(:comment, val[0], @token_index - 1) }
+      | NEWLINE { result = make_token(:newline, val[0], @token_index - 1) }
+      | LEADING_SPACE { result = make_token(:leading_space, val[0], @token_index - 1) }
+      | TRAILING_SPACE { result = make_token(:trailing_space, val[0], @token_index - 1) }
+      | command_line { result = val[0] }
+      | group_context { result = val[0] }
+
+  # A command line: tokens terminated by newline
+  command_line: command_tokens NEWLINE {
+                  result = [{
+                    type: :command,
+                    tokens: val[0],
+                    line: line_for_token_at(@command_start_index),
+                    column: column_for_token_at(@command_start_index)
+                  }, make_token(:newline, val[1], @token_index - 1)]
+                }
+
+  leading_space: LEADING_SPACE { result = make_token(:leading_space, val[0], @token_index - 1) }
+
+  trailing_space: TRAILING_SPACE { result = make_token(:trailing_space, val[0], @token_index - 1) }
+
+  # Group context: Group name do ... end
+  group_context: IDENTIFIER SPACE IDENTIFIER SPACE DO NEWLINE group_body END {
+                   @command_start_index = @token_index - 8
+                   result = {
+                     type: :group,
+                     name: val[2],
+                     tokens: [
+                       make_token(:identifier, val[0], @token_index - 8),
+                       make_token(:space, val[1], @token_index - 7),
+                       make_token(:identifier, val[2], @token_index - 6),
+                       make_token(:space, val[3], @token_index - 5),
+                       make_token(:keyword, "do", @token_index - 4)
+                     ],
+                     body: val[6],
+                     line: line_for_token_at(@token_index - 8),
+                     column: column_for_token_at(@token_index - 8)
+                   }
+                 }
+
+  group_body: /* empty */ { result = [] }
+            | group_body item { result = val[0] << val[1] }
+
+  # Command tokens: any sequence of tokens until newline
+  command_tokens: command_token { @command_start_index = @token_index - 1; result = [val[0]] }
+                | command_tokens SPACE command_token { result = val[0] << make_token(:space, val[1], @token_index - 2) << val[2] }
+                | command_tokens optional_space COMMA optional_space command_token {
+                    result = val[0]
+                    result << make_token(:space, val[1], @token_index - 4) if val[1]
+                    result << make_token(:operator, ",", @token_index - 3)
+                    result << make_token(:space, val[3], @token_index - 2) if val[3]
+                    result << val[4]
+                  }
+                | command_tokens PLUS command_token {
+                    result = val[0] << make_token(:operator, "+", @token_index - 2) << val[2]
+                  }
+                | command_tokens AT duration {
+                    result = val[0] << make_token(:operator, "@", @token_index - 2) << val[2]
+                  }
+
+  optional_space: SPACE { result = val[0] }
+                | /* empty */ { result = nil }
+
+  command_token: IDENTIFIER { result = make_token(:identifier, val[0], @token_index - 1) }
+               | STRING { result = make_token(:string, val[0], @token_index - 1) }
+               | NUMBER { result = make_token(:number, val[0], @token_index - 1) }
+               | REGEX { result = make_token(:regex, val[0], @token_index - 1) }
+
+  duration: NUMBER TIME_UNIT {
+              result = make_token(:duration, "#{val[0]}#{val[1]}", @token_index - 2)
+            }
+
+---- header
+  require_relative "token"
+  require_relative "lexer"
+  require_relative "ast"
+
+---- inner
+  def parse(str, file: "<unknown>")
+    @file = file
+    @lexer = DemoTape::Lexer.new
+    @tokens = @lexer.tokenize(str)
+    @token_index = 0
+    do_parse
+  end
+
+  def next_token
+    token = @tokens.shift
+    @current_token_index = @token_index
+    @token_index += 1
+    token
+  end
+
+  def make_token(type, value, index)
+    line_info = @lexer.line_map[index] || {}
+    token_class = case type
+                  when :identifier then DemoTape::Token::Identifier
+                  when :string then DemoTape::Token::String
+                  when :number then DemoTape::Token::Number
+                  when :duration then DemoTape::Token::Duration
+                  when :regex then DemoTape::Token::Regex
+                  when :time_unit then DemoTape::Token::TimeUnit
+                  when :operator then DemoTape::Token::Operator
+                  when :space then DemoTape::Token::Space
+                  when :leading_space then DemoTape::Token::LeadingSpace
+                  when :trailing_space then DemoTape::Token::TrailingSpace
+                  when :keyword then DemoTape::Token::Keyword
+                  when :comment then DemoTape::Token::Comment
+                  when :newline then DemoTape::Token::Newline
+                  else DemoTape::Token::Base
+                  end
+
+    token_class.new(
+      value,
+      line: line_info[:line],
+      column: line_info[:column],
+      raw: line_info[:raw]
+    )
+  end
+
+  def line_for_token_at(index)
+    line_info = @lexer.line_map[index] || {}
+    line_info[:line]
+  end
+
+  def column_for_token_at(index)
+    line_info = @lexer.line_map[index] || {}
+    line_info[:column]
+  end
+
+  def collect_tokens(*values)
+    values.flatten.compact.select { |v| v.is_a?(DemoTape::Token::Base) }
+  end
+
+  def on_error(token_id, token_value, value_stack)
+    line_info = @lexer.line_map[@current_token_index] || {}
+    line_num = line_info[:line] || "?"
+    col_num = line_info[:column] || 1
+    line_content = line_info[:content] || ""
+
+    token_name = token_to_str(token_id) || token_id.to_s
+
+    error_msg = "Unexpected token #{token_name.inspect} at #{@file}:#{line_num}:#{col_num}:\n"
+    error_msg += "  #{line_content.strip}\n"
+    error_msg += "  #{' ' * (col_num - line_content.length + line_content.strip.length - 1)}^"
+
+    raise DemoTape::ParseError, error_msg
+  end
+
+---- footer

data/demotape_simple_test.y

@@ -0,0 +1,32 @@
+class DemoTape::SimpleParser
+rule
+  # Match lines - each line is either comment+newline or command tokens+newline  
+  document: lines { result = val[0].flatten }
+          | /* empty */ { result = [] }
+  
+  lines: line { result = [val[0]] }
+       | lines line { result = val[0] + val[1] }
+  
+  # A line ends with NEWLINE
+  line: COMMENT NEWLINE { result = [[:comment, val[0]], [:newline, val[1]]] }
+      | NEWLINE { result = [[:newline, val[0]]] }
+      | line_tokens NEWLINE { result = [{ type: :command, tokens: val[0] }, [:newline, val[1]]] }
+  
+  # Line tokens: anything that's not a newline
+  line_tokens: line_token { result = [val[0]] }
+             | line_tokens line_token { result = val[0] << val[1] }
+  
+  line_token: IDENTIFIER { result = [:id, val[0]] }
+            | STRING { result = [:str, val[0]] }
+            | SPACE { result = [:sp, val[0]] }
+            | LEADING_SPACE { result = [:lsp, val[0]] }
+
+---- inner
+  def parse(tokens)
+    @tokens = tokens
+    do_parse
+  end
+  
+  def next_token
+    @tokens.shift
+  end

data/editors/sublime-text/DemoTape.sublime-completions

@@ -6,6 +6,8 @@
     { "trigger": "Type@", "contents": "Type@${1:50ms} \"${2:text}\"" },
     { "trigger": "TypeFile", "contents": "TypeFile \"${1:path/to/file}\"" },
     { "trigger": "TypeFile@", "contents": "TypeFile@${1:50ms} \"${2:path/to/file}\"" },
+    { "trigger": "Run", "contents": "Run \"${1:command}\"" },
+    { "trigger": "Run@", "contents": "Run@${1:1s} \"${2:command}\"" },
     { "trigger": "Copy", "contents": "Copy \"${1:text}\"" },
     { "trigger": "Paste", "contents": "Paste \"${1:text}\"" },
     { "trigger": "Send", "contents": "Send \"${1:text}\"" },
@@ -56,6 +58,8 @@
     { "trigger": "Set variable_typing", "contents": "Set variable_typing ${1:true}" },
     { "trigger": "Set loop", "contents": "Set loop ${1:true}" },
     { "trigger": "Set loop_delay", "contents": "Set loop_delay ${1:2s}" },
+    { "trigger": "Set run_enter_delay", "contents": "Set run_enter_delay ${1:300ms}" },
+    { "trigger": "Set run_sleep", "contents": "Set run_sleep ${1:1s}" },
 
     // Theme color overrides
     { "trigger": "Set theme.background", "contents": "Set theme.background \"${1:#222222}\"" },

data/editors/sublime-text/DemoTape.sublime-syntax

@@ -11,6 +11,23 @@ variables:
 contexts:
   main:
     - include: comments
+    - include: blocks
+    - include: commands
+
+  blocks:
+    # Group blocks
+    - match: '\b(Group)\s+([a-z_][a-z0-9_]*)\s+(do)\b'
+      captures:
+        1: keyword.control.demotape
+        2: entity.name.function.demotape
+        3: keyword.control.demotape
+      push: group_body
+
+  group_body:
+    - match: '\b(end)\b'
+      scope: keyword.control.demotape
+      pop: true
+    - include: comments
     - include: commands
 
   comments:
@@ -18,8 +35,13 @@ contexts:
       scope: comment.line.number-sign.demotape
 
   commands:
+    # Group invocations (lowercase identifiers)
+    - match: '^(\s*)([a-z_][a-z0-9_]*)(\s*)$'
+      captures:
+        2: entity.name.function.demotape
+
     # Commands with @ duration/speed
-    - match: '\b(Type|TypeFile|WaitUntil)\b'
+    - match: '\b(Type|TypeFile|WaitUntil|Run)\b'
       scope: keyword.control.demotape
       push: command_with_speed_or_timeout
 
@@ -132,7 +154,7 @@ contexts:
       pop: true
 
   set_command:
-    - match: '\b(border_radius|shell|theme|width|height|font_size|font_family|line_height|cursor_blink|cursor_width|cursor_style|letter_spacing|padding|margin|margin_fill|fps|typing_speed|loop|loop_delay|variable_typing)(\.[a-z_]+)?\b'
+    - match: '\b(border_radius|shell|theme|width|height|font_size|font_family|line_height|cursor_blink|cursor_width|cursor_style|letter_spacing|padding|margin|margin_fill|fps|typing_speed|loop|loop_delay|variable_typing|run_enter_delay|run_sleep)(\.[a-z_]+)?\b'
       captures:
         1: variable.parameter.demotape
         2: variable.other.member.demotape

data/editors/vim/syntax/demotape.vim

@@ -11,9 +11,18 @@ endif
 syn match demotapeComment "#.*$"
 
 " Commands
-syn keyword demotapeCommand Type TypeFile WaitUntil Set Output Copy Paste Send Include Screenshot
+syn keyword demotapeCommand Type TypeFile WaitUntil Run Set Output Copy Paste Send Include Screenshot
 syn keyword demotapeCommand Wait Sleep Require Pause Resume Clear nextgroup=demotapeString,demotapeDuration,demotapeNumber skipwhite
 
+" Group blocks
+syn keyword demotapeCommand Group nextgroup=demotapeGroupName skipwhite
+syn match demotapeGroupName "\<[a-z_][a-z0-9_]*\>" contained nextgroup=demotapeGroupDo skipwhite
+syn keyword demotapeGroupDo do contained
+syn keyword demotapeGroupEnd end
+
+" Group invocations (lowercase identifiers on their own line)
+syn match demotapeGroupInvocation "^\s*\zs[a-z_][a-z0-9_]*\ze\s*$"
+
 " Special keys
 syn keyword demotapeKey Enter Return Tab Backspace Delete Escape Esc Space
 syn keyword demotapeKey Up Down Left Right Home End PageUp PageDown Insert
@@ -33,7 +42,8 @@ syn match demotapeOperator "@"
 syn keyword demotapeOption border_radius shell theme width height font_size font_family
 syn keyword demotapeOption line_height cursor_blink cursor_width cursor_style letter_spacing
 syn keyword demotapeOption padding margin margin_fill fps typing_speed loop loop_delay variable_typing
-syn match demotapeOption "\<\(border_radius\|shell\|theme\|width\|height\|font_size\|font_family\|line_height\|cursor_blink\|cursor_width\|cursor_style\|letter_spacing\|padding\|margin\|margin_fill\|fps\|typing_speed\|loop_delay\|loop\|variable_typing\)\.\w\+\>"
+syn keyword demotapeOption run_enter_delay run_sleep
+syn match demotapeOption "\<\(border_radius\|shell\|theme\|width\|height\|font_size\|font_family\|line_height\|cursor_blink\|cursor_width\|cursor_style\|letter_spacing\|padding\|margin\|margin_fill\|fps\|typing_speed\|loop_delay\|loop\|variable_typing\|run_enter_delay\|run_sleep\)\.\w\+\>"
 
 " Strings
 syn region demotapeString start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=demotapeEscape
@@ -64,6 +74,10 @@ syn match demotapeSeparator ","
 " Highlight groups
 hi def link demotapeComment Comment
 hi def link demotapeCommand Keyword
+hi def link demotapeGroupName Function
+hi def link demotapeGroupDo Keyword
+hi def link demotapeGroupEnd Keyword
+hi def link demotapeGroupInvocation Function
 hi def link demotapeKey Function
 hi def link demotapeModifier Special
 hi def link demotapeOperator Operator

data/editors/vscode/demotape.tmLanguage.json

@@ -3,8 +3,29 @@
   "name": "DemoTape",
   "scopeName": "source.demotape",
   "fileTypes": ["tape"],
-  "patterns": [{ "include": "#comments" }, { "include": "#commands" }],
+  "patterns": [{ "include": "#comments" }, { "include": "#blocks" }, { "include": "#commands" }],
   "repository": {
+    "blocks": {
+      "patterns": [
+        {
+          "comment": "Group blocks",
+          "begin": "\\b(Group)\\s+([a-z_][a-z0-9_]*)\\s+(do)\\b",
+          "end": "\\b(end)\\b",
+          "beginCaptures": {
+            "1": { "name": "keyword.control.demotape" },
+            "2": { "name": "entity.name.function.demotape" },
+            "3": { "name": "keyword.control.demotape" }
+          },
+          "endCaptures": {
+            "1": { "name": "keyword.control.demotape" }
+          },
+          "patterns": [
+            { "include": "#comments" },
+            { "include": "#commands" }
+          ]
+        }
+      ]
+    },
     "comments": {
       "patterns": [
         {
@@ -15,9 +36,16 @@
     },
     "commands": {
       "patterns": [
+        {
+          "comment": "Group invocations (lowercase identifiers)",
+          "match": "^\\s*([a-z_][a-z0-9_]*)\\s*$",
+          "captures": {
+            "1": { "name": "entity.name.function.demotape" }
+          }
+        },
         {
           "comment": "Commands with @ duration/speed",
-          "match": "\\b(Type|TypeFile|WaitUntil)\\b",
+          "match": "\\b(Type|TypeFile|WaitUntil|Run)\\b",
           "name": "keyword.control.demotape",
           "captures": {
             "1": { "name": "keyword.control.demotape" }
@@ -83,7 +111,7 @@
         },
         {
           "comment": "Set command options",
-          "match": "\\b(border_radius|shell|theme|width|height|font_size|font_family|line_height|cursor_blink|cursor_width|cursor_style|letter_spacing|padding|margin|margin_fill|fps|typing_speed|loop|loop_delay|variable_typing)(\\.[a-z_]+)?\\b",
+          "match": "\\b(border_radius|shell|theme|width|height|font_size|font_family|line_height|cursor_blink|cursor_width|cursor_style|letter_spacing|padding|margin|margin_fill|fps|typing_speed|loop|loop_delay|variable_typing|run_enter_delay|run_sleep)(\\.[a-z_]+)?\\b",
           "captures": {
             "1": { "name": "variable.parameter.demotape" },
             "2": { "name": "variable.other.member.demotape" }

data/lib/demo_tape/cli.rb

@@ -127,6 +127,14 @@ module DemoTape
            type: :boolean,
            default: false,
            desc: "Take a single screenshot at the end of the session"
+    option :run_enter_delay,
+           type: :numeric,
+           default: 1,
+           desc: "Delay (in seconds) before pressing Enter"
+    option :run_sleep,
+           type: :numeric,
+           default: 3,
+           desc: "Delay (in seconds) after running each command"
     def _run(file_path = "")
       options = self.options.dup
       options[:padding] =
@@ -172,6 +180,34 @@ module DemoTape
       )
     end
 
+    desc "format", "Formats a demo tape script"
+    option :write,
+           type: :boolean,
+           default: false,
+           desc: "Overwrite the original files with the formatted content"
+    def format(*paths)
+      paths = paths.flat_map {|path| Dir.glob(path) }
+
+      if paths.size > 1 && !options.write
+        shell.say(
+          "Error: --write must be specified when formatting multiple files.",
+          :red
+        )
+
+        exit 1
+      end
+
+      paths.each do |path|
+        formatted = Formatter.new(File.read(path)).call
+
+        if options.write
+          File.write(path, formatted)
+        else
+          puts formatted
+        end
+      end
+    end
+
     no_commands do
       # Add helper methods here
     end