demotape 0.0.3 → 0.0.4

data/editors/zed/tree-sitter/src/tree_sitter/parser.h

@@ -0,0 +1,224 @@
+#ifndef TREE_SITTER_PARSER_H_
+#define TREE_SITTER_PARSER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define ts_builtin_sym_error ((TSSymbol)-1)
+#define ts_builtin_sym_end 0
+#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
+
+typedef uint16_t TSStateId;
+
+#ifndef TREE_SITTER_API_H_
+typedef uint16_t TSSymbol;
+typedef uint16_t TSFieldId;
+typedef struct TSLanguage TSLanguage;
+#endif
+
+typedef struct {
+  TSFieldId field_id;
+  uint8_t child_index;
+  bool inherited;
+} TSFieldMapEntry;
+
+typedef struct {
+  uint16_t index;
+  uint16_t length;
+} TSFieldMapSlice;
+
+typedef struct {
+  bool visible;
+  bool named;
+  bool supertype;
+} TSSymbolMetadata;
+
+typedef struct TSLexer TSLexer;
+
+struct TSLexer {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  void (*advance)(TSLexer *, bool);
+  void (*mark_end)(TSLexer *);
+  uint32_t (*get_column)(TSLexer *);
+  bool (*is_at_included_range_start)(const TSLexer *);
+  bool (*eof)(const TSLexer *);
+};
+
+typedef enum {
+  TSParseActionTypeShift,
+  TSParseActionTypeReduce,
+  TSParseActionTypeAccept,
+  TSParseActionTypeRecover,
+} TSParseActionType;
+
+typedef union {
+  struct {
+    uint8_t type;
+    TSStateId state;
+    bool extra;
+    bool repetition;
+  } shift;
+  struct {
+    uint8_t type;
+    uint8_t child_count;
+    TSSymbol symbol;
+    int16_t dynamic_precedence;
+    uint16_t production_id;
+  } reduce;
+  uint8_t type;
+} TSParseAction;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+} TSLexMode;
+
+typedef union {
+  TSParseAction action;
+  struct {
+    uint8_t count;
+    bool reusable;
+  } entry;
+} TSParseActionEntry;
+
+struct TSLanguage {
+  uint32_t version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  const uint16_t *parse_table;
+  const uint16_t *small_parse_table;
+  const uint32_t *small_parse_table_map;
+  const TSParseActionEntry *parse_actions;
+  const char * const *symbol_names;
+  const char * const *field_names;
+  const TSFieldMapSlice *field_map_slices;
+  const TSFieldMapEntry *field_map_entries;
+  const TSSymbolMetadata *symbol_metadata;
+  const TSSymbol *public_symbol_map;
+  const uint16_t *alias_map;
+  const TSSymbol *alias_sequences;
+  const TSLexMode *lex_modes;
+  bool (*lex_fn)(TSLexer *, TSStateId);
+  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
+  TSSymbol keyword_capture_token;
+  struct {
+    const bool *states;
+    const TSSymbol *symbol_map;
+    void *(*create)(void);
+    void (*destroy)(void *);
+    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
+    unsigned (*serialize)(void *, char *);
+    void (*deserialize)(void *, const char *, unsigned);
+  } external_scanner;
+  const TSStateId *primary_state_ids;
+};
+
+/*
+ *  Lexer Macros
+ */
+
+#define START_LEXER()           \
+  bool result = false;          \
+  bool skip = false;            \
+  bool eof = false;             \
+  int32_t lookahead;            \
+  goto start;                   \
+  next_state:                   \
+  lexer->advance(lexer, skip);  \
+  start:                        \
+  skip = false;                 \
+  lookahead = lexer->lookahead;
+
+#define ADVANCE(state_value) \
+  {                          \
+    state = state_value;     \
+    goto next_state;         \
+  }
+
+#define SKIP(state_value) \
+  {                       \
+    skip = true;          \
+    state = state_value;  \
+    goto next_state;      \
+  }
+
+#define ACCEPT_TOKEN(symbol_value)     \
+  result = true;                       \
+  lexer->result_symbol = symbol_value; \
+  lexer->mark_end(lexer);
+
+#define END_STATE() return result;
+
+/*
+ *  Parse Table Macros
+ */
+
+#define SMALL_STATE(id) id - LARGE_STATE_COUNT
+
+#define STATE(id) id
+
+#define ACTIONS(id) id
+
+#define SHIFT(state_value)            \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = state_value            \
+    }                                 \
+  }}
+
+#define SHIFT_REPEAT(state_value)     \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = state_value,           \
+      .repetition = true              \
+    }                                 \
+  }}
+
+#define SHIFT_EXTRA()                 \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .extra = true                   \
+    }                                 \
+  }}
+
+#define REDUCE(symbol_val, child_count_val, ...) \
+  {{                                             \
+    .reduce = {                                  \
+      .type = TSParseActionTypeReduce,           \
+      .symbol = symbol_val,                      \
+      .child_count = child_count_val,            \
+      __VA_ARGS__                                \
+    },                                           \
+  }}
+
+#define RECOVER()                    \
+  {{                                 \
+    .type = TSParseActionTypeRecover \
+  }}
+
+#define ACCEPT_INPUT()              \
+  {{                                \
+    .type = TSParseActionTypeAccept \
+  }}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_PARSER_H_

data/exe/demotape

@@ -7,5 +7,6 @@ require_relative "../lib/demo_tape/cli"
 # `run` is reserved with thor 🫠🙄🤦‍♂️
 argv = ARGV.dup
 argv[0] = "_run" if argv[0] == "run"
+argv[1] = "_run" if argv[1] == "run"
 
 DemoTape::CLI.start(argv)

data/lib/demo_tape/cli.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "thor"
+require_relative "ext/thor"
 require "thor/completion"
 
 module DemoTape
@@ -144,8 +145,15 @@ module DemoTape
 
       if file_path == ""
         file_path = "<stdin>"
-        content = $stdin.read
-        options[:output_path] = "stdin.mp4" if options.output_path.empty?
+
+        if $stdin.tty?
+          help
+          exit 1
+        else
+          content = $stdin.read
+        end
+
+        options[:output_path] = ["stdin.mp4"] if options.output_path.empty?
       else
         content = File.read(file_path)
       end

data/lib/demo_tape/command.rb

@@ -15,7 +15,7 @@ module DemoTape
       "Ctrl" => :control,
       "Alt" => :alt,
       "Option" => :alt,
-      "Pause" => :pause,
+      # "Pause" => :pause,
       "Escape" => :escape,
       "Esc" => :escape,
       "Space" => :space,

data/lib/demo_tape/ext/thor.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "thor/parser/argument"
+
+class Thor
+  class Argument
+    def print_default
+      if (@type == :array) && @default.is_a?(Array)
+        @default.map do |item|
+          item.respond_to?(:dump) ? item.dump : item
+        end.join(" ")
+      else
+        @default
+      end
+    end
+  end
+end

data/lib/demo_tape/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DemoTape
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: demotape
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Nando Vieira
@@ -267,18 +267,38 @@ files:
 - demotape.jsonc
 - demotape.y
 - demotape_ascii.rb
-- demotape_new.y.backup
-- demotape_simple_test.y
 - editors/sublime-text/Comments (DemoTape).tmPreferences
 - editors/sublime-text/DemoTape.sublime-completions
 - editors/sublime-text/DemoTape.sublime-syntax
 - editors/vim/README.md
 - editors/vim/ftdetect/demotape.vim
 - editors/vim/syntax/demotape.vim
+- editors/vscode/LICENSE.md
 - editors/vscode/README.md
+- editors/vscode/RELEASE_PROCESS.md
 - editors/vscode/demotape.tmLanguage.json
+- editors/vscode/icon.png
 - editors/vscode/language-configuration.json
 - editors/vscode/package.json
+- editors/zed/extension.toml
+- editors/zed/grammars/demotape.wasm
+- editors/zed/languages/demotape/config.toml
+- editors/zed/languages/demotape/highlights.scm
+- editors/zed/package-lock.json
+- editors/zed/tree-sitter/Cargo.toml
+- editors/zed/tree-sitter/binding.gyp
+- editors/zed/tree-sitter/bindings/node/binding.cc
+- editors/zed/tree-sitter/bindings/node/index.js
+- editors/zed/tree-sitter/bindings/rust/build.rs
+- editors/zed/tree-sitter/bindings/rust/lib.rs
+- editors/zed/tree-sitter/grammar.js
+- editors/zed/tree-sitter/package-lock.json
+- editors/zed/tree-sitter/package.json
+- editors/zed/tree-sitter/queries/highlights.scm
+- editors/zed/tree-sitter/src/grammar.json
+- editors/zed/tree-sitter/src/node-types.json
+- editors/zed/tree-sitter/src/parser.c
+- editors/zed/tree-sitter/src/tree_sitter/parser.h
 - exe/demotape
 - lib/demo_tape.rb
 - lib/demo_tape/bounds.rb
@@ -286,6 +306,7 @@ files:
 - lib/demo_tape/command.rb
 - lib/demo_tape/duration.rb
 - lib/demo_tape/exporter.rb
+- lib/demo_tape/ext/thor.rb
 - lib/demo_tape/formatter.rb
 - lib/demo_tape/generator.rb
 - lib/demo_tape/lexer.rb
@@ -670,10 +691,10 @@ metadata:
   rubygems_mfa_required: 'true'
   homepage_uri: https://github.com/fnando/demotape
   bug_tracker_uri: https://github.com/fnando/demotape/issues
-  source_code_uri: https://github.com/fnando/demotape/tree/v0.0.3
-  changelog_uri: https://github.com/fnando/demotape/tree/v0.0.3/CHANGELOG.md
-  documentation_uri: https://github.com/fnando/demotape/tree/v0.0.3/README.md
-  license_uri: https://github.com/fnando/demotape/tree/v0.0.3/LICENSE.md
+  source_code_uri: https://github.com/fnando/demotape/tree/v0.0.4
+  changelog_uri: https://github.com/fnando/demotape/tree/v0.0.4/CHANGELOG.md
+  documentation_uri: https://github.com/fnando/demotape/tree/v0.0.4/README.md
+  license_uri: https://github.com/fnando/demotape/tree/v0.0.4/LICENSE.md
 rdoc_options: []
 require_paths:
 - lib

data/demotape_new.y.backup

@@ -1,160 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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