markdown_exec 3.5.0 → 3.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a4c6bcbb464222e907cb93cc549ef294d45b83f0f8be5e88e603b87c64eb7a4
-  data.tar.gz: dfce2b71eb6c954e3d438b6036b6543da7bcfe63178ca56971ddb198f49852db
+  metadata.gz: 70772e4552a37222c8f9655c19d0c4938ef57a2abc786987d4b8220608aeb3b5
+  data.tar.gz: 7afe1c005a8d079e0d55ba36ccfd83e669665d038182c2d465e027ba5e7f46f7
 SHA512:
-  metadata.gz: c7b2076de902483e3f2362b8319d99f1876c7f41e7ffd1815e92278803d55776f700df721dc16700064c890c7c48628657ef2bf4003ba989b7c6eee1c27a9088
-  data.tar.gz: ed8705a9687dc56cbef235fe0821065653852d5b1e1c05293a9ea53baf08a7a12c24fdc5e909e9dd04047378d664ddb0b8e7d644e38d54c753ef1a470138ce60
+  metadata.gz: b5ce74d1d56a732a6877d6dca7fd188e33b87fdbeccc6f3762281edfef9d53c525bcefb293931ec1cefa0e9176e45ef83d9a0c285589051169c15c8f2305a07d
+  data.tar.gz: 3798f4dfb87aeabb8e450bbb8790a72903a181f1171028042725f6231b90cc59605a88445c59a9e5178789a6b7d456060407ace48639f8b11b2b1ec385b8c23b

data/.ai-agent-instructions

@@ -0,0 +1,54 @@
+# AI Agent Instructions - Read First!
+
+## ⚠️ CRITICAL: Mandatory Acknowledgment
+
+**YOU MUST** preface EVERY response with:
+
+**"Observing AI principles!"**
+
+This confirms you have read and will follow the AI-First Principles.
+
+## 📋 Required Actions at Start of Each Session
+
+1. **Acknowledge**: Preface response with "Observing AI principles!"
+2. **Read**: `ai-principles.md` - Complete principles and process guide
+3. **Review**: `semantic-tokens.md` - Token registry
+4. **Check**: `tasks.md` - Active task tracking
+5. **Understand**: Priority levels (P0 > P1 > P2 > P3)
+
+## 🎯 Core Requirements
+
+- Use semantic tokens `[REQ:*]`, `[ARCH:*]`, `[IMPL:*]` throughout
+- Expand requirements into pseudo-code BEFORE coding
+- Break work into trackable tasks with priorities
+- Cross-reference everything using semantic tokens
+- Follow priority order: Tests > Code > Basic Functions > Infrastructure
+
+## 📚 Key Files
+
+- `ai-principles.md` - **READ THIS FIRST**
+- `requirements.md` - Requirements with `[REQ:*]` tokens
+- `architecture-decisions.md` - **Semantic-token-linked architecture decisions dependent on requirements**
+  - Records all `[ARCH:*]` tokens
+  - Cross-references `[REQ:*]` tokens
+- `implementation-decisions.md` - **Semantic-token-linked implementation decisions dependent on architecture and requirements**
+  - Records all `[IMPL:*]` tokens
+  - Cross-references both `[ARCH:*]` and `[REQ:*]` tokens
+- `semantic-tokens.md` - Token registry
+- `tasks.md` - Task tracking
+- `.cursorrules` - Cursor IDE rules (auto-loaded)
+
+## ✅ Example Response Format
+
+```
+Observing AI principles!
+
+I have read ai-principles.md and will follow all documented processes.
+
+[Your response here using semantic tokens and following the process]
+```
+
+---
+
+**This file is a reminder. The complete rules are in `ai-principles.md` and `.cursorrules`.**
+

data/.cursorrules

@@ -0,0 +1,198 @@
+# Cursor AI Agent Rules for STDD Projects
+
+**STDD Methodology Version**: 1.0.0
+
+## 🎯 Semantic Token-Driven Development (STDD)
+
+This project follows **Semantic Token-Driven Development (STDD)**, where semantic tokens (`[REQ:*]`, `[ARCH:*]`, `[IMPL:*]`) are the central mechanism for preserving intent throughout the development lifecycle. Semantic tokens create a traceable chain of intent from requirements → architecture → implementation → tests → code, ensuring the original purpose and reasoning are never lost.
+
+## ⚠️ MANDATORY: AI Principles Acknowledgment
+
+**YOU MUST** acknowledge that you have read and will follow the AI principles at the start of EVERY response by prefacing with:
+
+**"Observing AI principles!"**
+
+Then proceed to:
+1. Read `ai-principles.md` if not already read in this session
+2. Check `semantic-tokens.md` for existing tokens
+3. Review `tasks.md` for active tasks
+4. Follow all principles throughout your response
+
+## 🎯 Core Principles
+
+1. **Always Reference ai-principles.md**
+   - Read `ai-principles.md` at the start of each session
+   - Acknowledge with "Observing AI principles!" at the start of every response
+   - Follow the documented development process
+   - Use semantic tokens consistently
+
+2. **Semantic Token System** (Core to STDD)
+   - Semantic tokens are the mechanism that preserves intent throughout the development lifecycle
+   - Use semantic tokens for all cross-referencing
+   - Format: `[TYPE:IDENTIFIER]` (e.g., `[REQ:MONITOR]`, `[IMPL:ASYNC_EXECUTION]`)
+   - Reference tokens in code comments, test names, and documentation
+   - Update `semantic-tokens.md` when creating new tokens
+   - Maintain traceability: Requirements → Architecture → Implementation → Tests → Code
+
+3. **Development Process**
+   - **Phase 1**: Expand requirements into pseudo-code and decisions (NO code changes)
+   - **Phase 2**: Break down into trackable tasks with priorities
+   - **Phase 3**: Implement tasks, starting with highest priority
+   - Always cross-reference using semantic tokens
+
+4. **Task Management**
+   - Break work into trackable tasks in `tasks.md`
+   - Assign priorities: P0 (Critical) > P1 (Important) > P2 (Nice-to-have) > P3 (Future)
+   - Remove subtasks when parent task completes
+   - Always include semantic token references
+
+5. **Priority Order**
+   - **Most Important**: Tests, Code, Basic Functions
+   - **Least Important**: Environment Orchestration, Enhanced Security, Automated Deployment
+
+## 📝 Documentation Requirements
+
+### ⚠️ CRITICAL: Documentation is MANDATORY, Not Optional
+
+**Documentation updates are REQUIRED at every stage of development. They are not optional or deferrable.**
+
+### Required Sections in All Documentation
+
+1. **Requirements** - with `[REQ:*]` tokens (in `requirements.md`)
+2. **Architecture Decisions** - with `[ARCH:*]` tokens (in `architecture-decisions.md`)
+   - **MUST** be recorded in `architecture-decisions.md` IMMEDIATELY when made
+   - **MUST** cross-reference `[REQ:*]` tokens
+   - Architecture decisions are dependent on requirements
+   - **DO NOT** defer architecture documentation - record it as you make decisions
+3. **Implementation Decisions** - with `[IMPL:*]` tokens (in `implementation-decisions.md`)
+   - **MUST** be recorded in `implementation-decisions.md` IMMEDIATELY when made
+   - **MUST** cross-reference both `[ARCH:*]` and `[REQ:*]` tokens
+   - Implementation decisions are dependent on both architecture and requirements
+   - **DO NOT** defer implementation documentation - record it as you make decisions
+4. **Semantic Token Registry** - maintained in `semantic-tokens.md`
+   - **MUST** be updated immediately when creating new tokens
+5. **Task Planning** - maintained in `tasks.md`
+   - **MUST** be updated when planning new work
+   - **MUST** be updated when completing tasks
+   - **MUST** include semantic token references
+6. **Code References** - semantic tokens in code comments
+7. **Test References** - semantic tokens in test names/comments
+
+### Documentation Update Checklist (MANDATORY)
+
+**When making ANY architectural decision:**
+- [ ] Record in `architecture-decisions.md` with `[ARCH:*]` token
+- [ ] Cross-reference relevant `[REQ:*]` tokens
+- [ ] Update `semantic-tokens.md` if new token created
+
+**When making ANY implementation decision:**
+- [ ] Record in `implementation-decisions.md` with `[IMPL:*]` token
+- [ ] Cross-reference relevant `[ARCH:*]` and `[REQ:*]` tokens
+- [ ] Update `semantic-tokens.md` if new token created
+
+**When planning new work:**
+- [ ] Create tasks in `tasks.md` BEFORE starting implementation
+- [ ] Assign priorities to all tasks
+- [ ] Include semantic token references in task descriptions
+- [ ] Break down into subtasks if needed
+
+**When completing work:**
+- [ ] Mark tasks complete in `tasks.md`
+- [ ] Remove completed subtasks
+- [ ] Verify all documentation is up-to-date
+- [ ] Ensure all semantic tokens are documented
+
+### Cross-Reference Format
+
+When referencing tokens:
+```go
+// [REQ:DUPLICATE_PREVENTION] Skip if text matches lastText
+// [IMPL:DUPLICATE_PREVENTION] [REQ:DUPLICATE_PREVENTION]
+```
+
+Test names:
+```go
+func TestDuplicatePrevention_REQ_DUPLICATE_PREVENTION(t *testing.T)
+```
+
+## 🔄 Before Starting Work
+
+1. **MANDATORY**: Read `ai-principles.md`
+2. **MANDATORY**: Check `semantic-tokens.md` for existing tokens
+3. **MANDATORY**: Review `tasks.md` for active tasks
+4. **MANDATORY**: Review `architecture-decisions.md` for existing architecture decisions
+5. **MANDATORY**: Review `implementation-decisions.md` for existing implementation decisions
+6. Understand priority levels
+7. **MANDATORY**: Plan work in `tasks.md` BEFORE writing any code
+
+## ⚙️ During Work
+
+1. Use semantic tokens in all code comments
+2. Use semantic tokens in test names/comments
+3. Cross-reference: Requirements → Architecture → Implementation → Tests
+4. **MANDATORY**: Break work into trackable tasks in `tasks.md` BEFORE starting implementation
+5. **MANDATORY**: Assign appropriate priorities to all tasks
+6. **MANDATORY**: Update documentation AS YOU WORK:
+   - Record architecture decisions in `architecture-decisions.md` immediately when made
+   - Record implementation decisions in `implementation-decisions.md` immediately when made
+   - Update `tasks.md` when planning new work or completing tasks
+   - Update `semantic-tokens.md` when creating new tokens
+   - **DO NOT** defer documentation updates until the end
+
+## ✅ After Completing Work
+
+1. **MANDATORY**: All semantic tokens documented in `semantic-tokens.md`
+2. **MANDATORY**: Documentation updated with implementation status:
+   - `architecture-decisions.md` updated with any new `[ARCH:*]` decisions
+   - `implementation-decisions.md` updated with any new `[IMPL:*]` decisions
+   - Both must cross-reference `[REQ:*]` tokens
+3. **MANDATORY**: Tests reference semantic tokens
+4. **MANDATORY**: Tasks marked complete in `tasks.md`
+5. **MANDATORY**: Subtasks removed from completed tasks
+6. **MANDATORY**: All documentation reflects current state (no stale information)
+
+## 🚫 What NOT to Do
+
+- Don't write code before expanding requirements into pseudo-code
+- Don't skip semantic token cross-referencing
+- Don't create tasks without priorities
+- Don't leave subtasks after parent task completes
+- Don't implement P2/P3 features before P0/P1 are complete
+
+## 📚 Key Files
+
+**Note**: These file names refer to your project's files. Copy the corresponding `.template.md` files from the STDD repository to your project.
+
+- `ai-principles.md` - Complete principles and process guide (reference from STDD repository)
+- `requirements.md` - Requirements with `[REQ:*]` tokens (copy from `requirements.template.md`)
+- `architecture-decisions.md` - **Semantic-token-linked record of architecture decisions dependent on requirements** (copy from `architecture-decisions.template.md`)
+  - All `[ARCH:*]` tokens must be documented here
+  - Must cross-reference `[REQ:*]` tokens
+- `implementation-decisions.md` - **Semantic-token-linked record of implementation decisions dependent on architecture and requirements** (copy from `implementation-decisions.template.md`)
+  - All `[IMPL:*]` tokens must be documented here
+  - Must cross-reference both `[ARCH:*]` and `[REQ:*]` tokens
+- `semantic-tokens.md` - Central registry of all tokens (copy from `semantic-tokens.template.md`)
+- `tasks.md` - Active task tracking (copy from `tasks.template.md`)
+
+## 🎯 Example Workflow
+
+1. **User Request**: "Add disk space checking"
+2. **AI Response (Planning Phase - NO CODE YET)**: 
+   - Creates `[REQ:DISK_SPACE_CHECK]` token in `requirements.md`
+   - Expands into pseudo-code and decisions
+   - **IMMEDIATELY** documents architecture decisions in `architecture-decisions.md` with `[ARCH:*]` tokens cross-referencing `[REQ:DISK_SPACE_CHECK]`
+   - **IMMEDIATELY** documents implementation decisions in `implementation-decisions.md` with `[IMPL:*]` tokens cross-referencing both `[ARCH:*]` and `[REQ:*]` tokens
+   - **IMMEDIATELY** updates `semantic-tokens.md` with all new tokens
+   - **IMMEDIATELY** creates tasks in `tasks.md` with P1 priority and semantic token references
+   - **NO code changes yet**
+3. **User Approval**: User reviews and approves planning documents
+4. **Implementation Phase**: 
+   - AI implements tasks, starting with highest priority
+   - **DURING implementation**: Updates documentation as decisions are made or refined
+   - **DURING implementation**: Updates `tasks.md` as subtasks are completed
+5. **Completion Phase**: 
+   - **MANDATORY**: Verifies all documentation is up-to-date
+   - **MANDATORY**: Marks tasks complete in `tasks.md`
+   - **MANDATORY**: Removes completed subtasks
+   - **MANDATORY**: Ensures all semantic tokens are documented
+

data/.rubocop.wide.yml

@@ -0,0 +1,5 @@
+inherit_from:
+  - .rubocop.yml
+
+Layout/LineLength:
+  Max: 200

data/.rubocop.yml

@@ -14,10 +14,15 @@ Layout/LineContinuationLeadingSpace:
   Enabled: false
 
 Layout/LineLength:
+  AllowHeredoc: true          # optional
+  AllowURI: true              # optional
+  AllowedPatterns:
+    - '^\s*#'
+    - '^[^#]*#'
   # Enabled: false
+  # IgnoreComments: true        # ← THIS is what you want
+  IgnoreCopDirectives: true   # optional, but useful
   Max: 80
-  # Max: 96
-  # Max: 120
 
 Lint/Debugger:
   Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [3.5.2]
+
+### Added
+
+- Option for hiding shebang lines.
+
+### Changed
+
+- Fix inherited code from activated UX blocks.
+- Improve BATS test names.
+
+## [3.5.1] - 2025-11-14
+
+### Added
+
+- Docker testing environment.
+
+### Changed
+
+- Correct tests for Docker environment.
+- Uses env split mode to parse the shell command.
+
 ## [3.5.0] - 2025-11-13
 
 ### Added
@@ -972,7 +994,7 @@ e.g. `MDE_OUTPUT_VIEWER_OPTIONS="-a '/Applications/Sublime Text.app'" mde --sele
 
 | YAML Name | Environment Variable | Default |
 | :--- | :--- | :--- |
-| block_name_hidden_match | MDE_BLOCK_NAME_HIDDEN_MATCH  | `^\(.+\)$` |
+| block_name_hide_custom_match | MDE_BLOCK_NAME_HIDE_CUSTOM_MATCH  | `^\(.+\)$` |
 | block_name_match | MDE_BLOCK_NAME_MATCH  | `:(?<title>\S+)( \|$)` |
 | block_required_scan | MDE_BLOCK_REQUIRED_SCAN  | `\+\S+` |
 | fenced_start_and_end_regex | MDE_FENCED_START_AND_END_REGEX  | ``^`{3,}`` |

data/Dockerfile.test

@@ -0,0 +1,42 @@
+FROM ruby:3.3-bookworm
+
+ENV LANG C.UTF-8
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential \
+        bsdmainutils \
+        gawk \
+        git \
+        tree \
+        vim
+
+# `markdown_exec` is the name expected by some BATS tests
+WORKDIR /markdown_exec
+
+# Clone the repository (shallow clone for faster builds)
+ARG GIT_BRANCH=main
+RUN git clone --depth 1 --branch ${GIT_BRANCH} https://github.com/fareedst/markdown_exec.git .
+
+# Initialize and update git submodules
+RUN git submodule update --init --recursive
+
+# Install dependencies
+RUN bundle install
+
+# Add aliases
+RUN echo 'alias batsv="bats --verbose-run --show-output-of-passing-tests"' >> ~/.bashrc && \
+    echo 'alias be="bundle exec"' >> ~/.bashrc && \
+    echo 'alias bmde="bin/bmde"' >> ~/.bashrc && \
+    echo 'alias ll="ls -FGlAhp"' >> ~/.bashrc
+
+RUN git submodule add https://github.com/bats-core/bats-core.git test/bats && \
+    git submodule add https://github.com/bats-core/bats-support.git test/test_helper/bats-support && \
+    git submodule add https://github.com/bats-core/bats-assert.git test/test_helper/bats-assert
+
+# make dirs, file for BATS tests
+RUN mkdir -p logs
+RUN mkdir -p docs/research
+RUN echo '04:31 e' > logs/mde_site.local_2024-07-31-20-04-01___examples_save_md_~_test_.out.txt
+RUN ln -s /markdown_exec/test/bats/bin/bats /usr/local/bin/
+
+CMD ["bash"]

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    markdown_exec (3.5.0)
+    markdown_exec (3.5.2)
       clipboard (~> 1.3.6)
       open3 (~> 0.1.1)
       optparse (~> 0.1.1)
@@ -107,6 +107,8 @@ GEM
     mocha (2.4.5)
       ruby2_keywords (>= 0.0.5)
     mutex_m (0.2.0)
+    nokogiri (1.16.6-aarch64-linux)
+      racc (~> 1.4)
     nokogiri (1.16.6-arm64-darwin)
       racc (~> 1.4)
     open3 (0.1.2)
@@ -224,6 +226,7 @@ GEM
     zeitwerk (2.6.16)
 
 PLATFORMS
+  aarch64-linux
   arm64-darwin-21
 
 DEPENDENCIES

data/README.md

@@ -269,36 +269,7 @@ mde --save-executed-script 1 --user-must-approve 1 --config my-config.yml
 
 ## Tab Completion
 
-### Install tab completion
-
-Append a command to load the completion script to your shell configuration file. `mde` must be executable for the command to be composed correctly.
-
-```bash
-echo "source $(mde --pwd)/bin/tab_completion.sh" >> ~/.bash_profile
-```
-
-### Behavior
-
-Press tab for completions appropriate to the current input.
-`mde <...> <prior word> <current word><TAB>`
-
-Completions are calculated based on the current word and the prior word. 
-1. If the current word starts with `-`, present matching options, eg `--version` for the current word `--v`.
-2. Else, if the current word is empty and the prior word is an option that takes an argument, present the type of the argument, eg `.BOOL.` for the option `--user-must-approve`.
-3. Else, if the current word is the type of argument, from the rule above, present the default value for the option. e.g. `1` for the type `.BOOL.` for the option `--user-must-approve`.
-4. Else, if the current word is non-empty, list matching files and folders.
-
-### Example Completions
-
-In the table below, tab is indicated by `!`
-| Input | Completions |
-| :--- | :--- |
-| `mde !` | local files and folders |
-| `mde -!` | all options |
-| `mde --!` | all options |
-| `mde --v!` | `mde --version` |
-| `mde --user-must-approve !` | `mde --user-must-approve .BOOL.`|
-| `mde --user-must-approve .BOOL.!` | `mde --user-must-approve 1` |
+See [Tab Completion Documentation](docs/tab-completion.md) for installation and usage instructions.
 
 ## Example: Interactive Workflow
 
@@ -351,7 +322,29 @@ vars:
 
 # Testing
 
-Execute tests for individual libraries.
+## Docker Testing Environment
+
+For a complete testing environment with all dependencies, use the Docker testing container:
+
+```bash
+# Build the test environment
+docker build -f Dockerfile.test -t markdown-exec-test .
+
+# Run all tests (RSpec, Minitest, and BATS)
+docker run -it markdown-exec-test bash -c 'bundle exec rake test'
+
+# Run individual test suites
+docker run -it markdown-exec-test bash -c 'bundle exec rspec'          # RSpec only
+docker run -it markdown-exec-test bash -c 'bundle exec rake minitest'  # Minitest only
+docker run -it markdown-exec-test bash -c 'bundle exec rake bats'      # BATS tests only
+
+# Enter the container interactively
+docker run --rm -it markdown-exec-test bash
+```
+
+## Local Testing
+
+Execute tests for individual libraries locally:
 
 `bundle exec rake minitest`
 

data/Rakefile

@@ -77,25 +77,25 @@ end
 def execute_with_error_handling(iterator)
   all_error_level = 0
   all_failed_files = []
-  
+
   iterator.each do |item|
     command = yield(item)
     next unless command # Skip if command is nil
-    
-    result = system(command)
+
+    system(command)
     error_level = $?.exitstatus
 
-    if error_level != 0
-      puts "Error: Command '#{command}' failed with exit status #{error_level}."
-      all_error_level = error_level
-      all_failed_files << command
-    end
-  end
+    next unless error_level != 0
 
-  if all_error_level != 0
-    puts "Error: #{all_failed_files.join(', ')} failed."
-    exit all_error_level
+    puts "Error: Command '#{command}' failed with exit status #{error_level}."
+    all_error_level = error_level
+    all_failed_files << command
   end
+
+  return unless all_error_level != 0
+
+  puts "Error: #{all_failed_files.join(', ')} failed."
+  exit all_error_level
 end
 
 desc 'bats'
@@ -114,22 +114,31 @@ task :listtests do
   puts `find lib -name '*.rb' -type f | xargs grep '< Minitest::Test' -l | sort`
 end
 
-desc 'minitest'
-task :minitest do
-  commands = [
-    './lib/argument_processor.rb --verbose',
-    './lib/block_label.rb --verbose',
-    './lib/cached_nested_file_reader.rb --verbose',
-    './lib/collapser.rb --verbose',
+def dev_test_commands
+  dev_dir = File.join(__dir__, 'lib', 'dev')
+  return [] unless Dir.exist?(dev_dir)
+
+  [
     './lib/dev/ansi_codes.rb --verbose',
     './lib/dev/append_to_bash_history.rb --verbose',
     './lib/dev/generate_transition_codes.rb --verbose',
     './lib/dev/hierarchy.rb --verbose',
     './lib/dev/process_command.rb --verbose',
     './lib/dev/process_template.rb --test --verbose',
-    './lib/dev/visibility-controller.rb --verbose',
+    './lib/dev/visibility-controller.rb --verbose'
+  ]
+end
+
+desc 'minitest'
+task :minitest do
+  commands = dev_test_commands + [
+    './lib/argument_processor.rb --verbose',
+    './lib/block_label.rb --verbose',
+    './lib/cached_nested_file_reader.rb --verbose',
+    './lib/collapser.rb --verbose',
     './lib/directory_searcher.rb --verbose',
     './lib/evaluate_shell_expressions.rb --verbose',
+    './lib/executed_shell_command.rb --verbose',
     './lib/fcb.rb --verbose',
     './lib/filter.rb --verbose',
     './lib/find_files.rb',
@@ -147,6 +156,7 @@ task :minitest do
     './lib/saved_files_matcher.rb --verbose',
     './lib/table_extractor.rb --verbose',
     './lib/text_analyzer.rb --verbose',
+    './lib/transformed_shell_command.rb --verbose',
     './lib/ww.rb --verbose'
   ]
 
@@ -164,26 +174,26 @@ end
 desc 'test'
 task :test do
   success = true
-  
+
   # Run all tests and track failures
   rspec_success = system('bundle exec rspec')
   success = false unless rspec_success
-  
+
   Rake::Task['minitest'].invoke
   minitest_success = $?.success?
   success = false unless minitest_success
-  
+
   Rake::Task['bats'].invoke
   bats_success = $?.success?
   success = false unless bats_success
-  
+
   # Report failures and exit with non-zero status if any test failed
   unless success
     failed_tests = []
     failed_tests << 'RSpec' unless rspec_success
     failed_tests << 'Minitest' unless minitest_success
     failed_tests << 'Bats' unless bats_success
-    
+
     puts "\nThe following test suites failed: #{failed_tests.join(', ')}"
     exit 1
   end
@@ -213,7 +223,7 @@ task :update_menu_yml do
   File.write(MENU_YML, menu_options.to_yaml)
   puts `stat #{MENU_YML}`
 end
-task :menu => 'update_menu_yml'
+task menu: 'update_menu_yml'
 
 # write tab_completion.sh with erb
 #