tryouts 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8f095071e066f97f3b04680aa28ca1cd98bfb2f40006937b08a59dd8d5fc04c
-  data.tar.gz: bb5b18a0d0b703fa07fd4aad746b9bac66765fa23929571152b8f047bf310887
+  metadata.gz: 2b560848d9f29bcfe84ae8984317c4c9d87eaff34f9ebd91141ad7bfc0af1ca8
+  data.tar.gz: 87c833052a1267da1f0e8a6786565baf0cd880280ca676951aaeddde7aa0601a
 SHA512:
-  metadata.gz: 633e4c03eb25ae604be0ea2d18d78f40917893182d9105e55f98ded0ee9f0d1c1505896976bd4d635ebd60ed69a297396db4e70fca28aa37b83e2610a110623b
-  data.tar.gz: 7ba9e3714720b3e5546a8f5962d553ed8f20a94e1ea46ca9da0650302fe4b399158cbd2765a404ab2735c7840417c0643c318ef008f1edf74ed3479d5201ebbc
+  metadata.gz: 72a738d41925f4e24ffc233d4e1e5f3dc96f7eaa9ee72eca9ab181da10ec3a283dd5b85b14b91c436acb777a005cb3529a1958c97fdc5f30c13f642de3466551
+  data.tar.gz: 0102df1a296fa62e04e05fd97c0e21ea83e4e2e718885cde380047c784c8ef0304e64182fee7ae45aa2c8ccac585fe7df6f21f527a2cb11a7e88d33d912028eb

data/README.md

@@ -1,78 +1,44 @@
-# Tryouts v3.0.0-pre
+# Tryouts v3.1
 
 **Ruby tests that read like documentation.**
 
 A modern test framework for Ruby that uses comments to define expectations. Tryouts are meant to double as documentation, so the Ruby code should be plain and reminiscent of real code.
 
 > [!WARNING]
-> Version 3.0 uses Ruby's Prism parser and pattern matching, requiring Ruby 3.4+
+> Version 3.0+ uses Ruby's Prism parser and pattern matching, requiring Ruby 3.4+
 
 ## Key Features
 
 - **Documentation-style tests** using comment-based expectations (`#=>`)
-- **Framework integration** with RSpec and Minitest translators
-- **Modern Ruby architecture** using Prism parser and pattern matching
-- **Immutable data structures** with `Data.define` classes
+- **Great expectation syntax** for more expressive assertions (`#==>` for true, `#=/=>` for false, `#=:>` for class/module)
+- **Framework integration** write with tryouts syntax, run with RSpec or Minitest
 - **Enhanced error reporting** with line numbers and context
 
 ## Installation
 
-Add to your Gemfile:
 ```ruby
-gem 'tryouts', '~> 3.0.0-pre'
+# Add to your Gemfile:
+gem 'tryouts'
 ```
 
-Or install directly:
 ```bash
-gem install tryouts --pre
+# Or install directly:
+$ gem install tryouts
 ```
 
-From source:
-```bash
-git clone https://github.com/delano/tryouts.git
-cd tryouts
-bundle install
-```
-
-## Requirements
-
-- **Ruby >= 3.4.4** (for Prism parser and pattern matching)
-- **RSpec** or **Minitest** (optional, for framework integration)
-
 ## Usage
 
-### Basic Commands
-
 ```bash
 # Auto-discover and run all tests
 try
 
 # Run specific test file
-try try/proof1_try.rb
-
-# Framework integration
-try --rspec try/proof1_try.rb      # Run with RSpec
-try --minitest try/proof1_try.rb   # Run with Minitest
-
-# Code generation only
-try --generate-rspec try/proof1_try.rb
-try --generate-minitest try/proof1_try.rb
-
-# Output options
-try -v    # verbose (includes source code and return values)
-try -q    # quiet mode
-try -f    # show failures only
-try -D    # debug mode
+try try/core/basic_syntax_try.rb
 ```
 
-### Exit Codes
-
-- `0`: All tests pass
-- `1+`: Number of failing tests
-
 ## Writing Tests
 
-Tryouts use a unique comment-based expectation syntax:
+Tryouts use a comment-based syntax for expecations:
 
 ```ruby
 # Setup code runs before all tests
@@ -111,56 +77,60 @@ puts 'Cleanup complete'
 
 ### Test Structure
 
-- **Setup Section**: Code before first test case (accessible via instance variables)
+Each test file is made up of three sections:
+- **Setup**: Code before first test case
 - **Test Cases**: Description lines (`##`), Ruby code, and expectations (`#=>`)
-- **Teardown Section**: Code after last test case
+- **Teardown**: Code after last test case
 
-## Framework Integration
+### Great Expectations System
 
-Version 3.0 introduces framework translators that convert tryouts into established test frameworks:
+  | Syntax | Description                | Example                             | Context       |
+  |--------|----------------------------|-------------------------------------|---------------|
+  | `#=>`  | Traditional value equality | `#=> [1, 2, 3]`                     | result, _     |
+  | `#==>` | Must be exactly true       | `#==> result.include?(2)`            | result, _     |
+  | `#=/=>`| Must be exactly false      | `#=/=> _.empty?`                     | result, _     |
+  | `#=\|>` | Must be true OR false     | `#=\|> 0.positive?`                   | result, _     |
+  | `#=!>` | Must raise an exception    | `#=!> error.is_a?(ZeroDivisionError)` | error         |
+  | `#=:>` | Must match result type     | `#=:> String`                         | result, _     |
+  | `#=~>` | Must match regex pattern   | `#=~> /^[^@]+@[^@]+\.[^@]+$/`         | result, _     |
+  | `#=%>` | Must complete within time  | `#=%> 2000 # in milliseconds`         | result, _     |
+  | `#=1>` | Match content in STDOUT    | `#=1> "You have great success"`       | result, _     |
+  | `#=2>` | Match content in STDERR    | `#=2> /[a-zA-Z0-9]+-?[0-9]{1,5}`      | result, _     |
+  | `#=<>` | Fails on purpose           | `#==<> result.include?(4)`            | result, _     |
 
-### RSpec Integration
 
-```bash
-try --rspec file_try.rb
-```
+### Using other test runners
 
-Generates RSpec `describe/it` blocks with full RSpec ecosystem support including:
-- Mocking and stubbing
-- Custom matchers
-- Parallel execution
-- IDE integration
-
-### Minitest Integration
+Version 3 introduces framework translators that convert tryouts into the equivalent tests in popular test tools, like RSpec and Minitest.
 
 ```bash
-try --minitest file_try.rb
-```
-
-Creates Minitest classes with `test_*` methods for:
-- Standard assertions
-- Custom test cases
-- CI/CD integration
-- Debugging support
+# Framework integration
+try --rspec try/core/basic_syntax_try.rb      # Run with RSpec
+try --minitest try/core/basic_syntax_try.rb   # Run with Minitest
 
-### Direct Mode
+# Code generation only
+try --generate-rspec try/core/basic_syntax_try.rb > spec/basic_syntax_spec.rb
+try --generate-minitest try/core/basic_syntax_try.rb > test/basic_syntax_test.rb
 
-```bash
-try file_try.rb  # Original tryouts execution
+# Output options
+try -v    # verbose (includes source code and return values)
+try -q    # quiet mode
+try -f    # show failures only
+try -D    # debug mode
 ```
 
-Uses shared execution context with all tests running in the same environment.
+### Exit Codes
 
-## File Discovery
+- `0`: All tests pass
+- `1+`: Number of failing tests
 
-Auto-discovers test files matching these patterns:
-- `./try/*_try.rb`
-- `./tryouts/*_try.rb`
-- `./*_try.rb`
 
-Files are processed in lexical order.
+## Requirements
+
+- **Ruby >= 3.2+** (for Prism parser and pattern matching)
+- **RSpec** or **Minitest** (optional, for framework integration)
 
-## Modern Architecture (v3.0)
+## Modern Architecture (v3+)
 
 ### Core Components
 
@@ -169,47 +139,13 @@ Files are processed in lexical order.
 - **Framework Translators**: Convert tryouts to RSpec/Minitest format
 - **CLI**: Modern command-line interface with framework selection
 
-### Ruby 3.4+ Features
-
-- **Pattern matching** throughout parsing and classification logic
-- **Prism native parser** (no external grammar compilation)
-- **Data.define classes** for immutable data structures
-- **Enhanced error context** with line numbers and suggestions
-
-## Development
-
-### Running Tests
-
-```bash
-# Test framework using itself
-try try/*_try.rb
-
-# With coverage
-COVERAGE=1 try try/*_try.rb
-```
-
-### Code Quality
-
-```bash
-bundle exec rubocop        # Check style
-bundle exec rubocop -A     # Auto-fix issues
-```
-
-## Migration from v2.x
-
-Version 3.0 represents a complete modernization:
-
-- **Parser**: Tree-sitter → Prism (native Ruby)
-- **Execution**: Custom runner → Framework delegation
-- **Data**: Traditional classes → `Data.define` immutable structures
-- **Syntax**: Standard Ruby → Pattern matching throughout
-- **Ruby**: 2.7+ → 3.4+ requirement
 
-## Examples
+## Live Examples
 
 For real-world usage examples, see:
 - [Onetimesecret tryouts](https://github.com/onetimesecret/onetimesecret/)
-- Test files in this repository: `try/*_try.rb` and `doc/`
+- [Rhales](https://github.com/onetimesecret/rhales)
+- [Familia](https://github.com/delano/familia)
 
 ## AI Development Assistance
 

data/exe/try

@@ -1,4 +1,4 @@
-#!/usr/bin/env /Users/d/.rbenv/shims/ruby
+#!/usr/bin/env ruby
 
 # Coverage tracking (must be first)
 if ENV['COVERAGE'] || ENV['SIMPLECOV']
@@ -42,12 +42,33 @@ Tryouts.update_load_path(lib_glob) if Tryouts.respond_to?(:update_load_path)
 begin
   files, options = Tryouts::CLI.parse_args(ARGV)
 
+  # Expand files if directories are given
+  expanded_files = []
+  files.each do |file_or_dir|
+    if File.directory?(file_or_dir)
+      # If it's a directory, find all *_try.rb files within it
+      dir_files = Dir.glob('**/*_try.rb', base: file_or_dir)
+      expanded_files.concat(dir_files.map { |f| File.join(file_or_dir, f) })
+    else
+      # If it's a file, add it as-is
+      expanded_files << file_or_dir
+    end
+  end
+  files          = expanded_files
+
   # Default file discovery if no files specified
   if files.empty?
-    files = Dir.glob(
-      ['./{try,tryouts,.}/*_try.rb'],
+    raw_files = Dir.glob(
+      ['{app,apps,lib,try,tryouts}/**/*_try.rb', './*_try.rb'],
       base: Dir.pwd,
-    ).sort
+    )
+
+    # Normalize paths so that slight variations are ignored
+    # e.g. ./test_try.rb and ././test_try.rb
+    files     = raw_files.map { |f| File.expand_path(f, Dir.pwd) }.uniq.sort
+  else
+    # Normalize paths for explicitly specified files/directories
+    files = files.map { |f| File.expand_path(f, Dir.pwd) }.uniq.sort
   end
 
   cli = Tryouts::CLI.new

data/lib/tryouts/cli/formatters/base.rb

@@ -7,91 +7,103 @@ class Tryouts
   class CLI
     # Enhanced interface for all test output formatting
     module FormatterInterface
+
+      attr_reader :current_indent
+
       # Phase-level output (major sections)
-      def phase_header(message, file_count = nil, level = 0)
+      def phase_header(message, file_count = nil, level = 0, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #phase_header"
       end
 
       # File-level operations
-      def file_start(file_path, context_info = {})
+      def file_start(file_path, context_info = {}, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #file_start"
       end
 
-      def file_parsed(file_path, test_count, setup_present: false, teardown_present: false)
+      def file_end(file_path, context_info = {}, io = $stdout)
+        raise NotImplementedError, "#{self.class} must implement #file_end"
+      end
+
+      def file_parsed(file_path, test_count, io = $stdout, setup_present: false, teardown_present: false)
         raise NotImplementedError, "#{self.class} must implement #file_parsed"
       end
 
-      def file_execution_start(file_path, test_count, context_mode)
+      def file_execution_start(file_path, test_count, context_mode, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #file_execution_start"
       end
 
-      def file_result(file_path, total_tests, failed_count, error_count, elapsed_time)
+      def file_result(file_path, total_tests, failed_count, error_count, elapsed_time, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #file_result"
       end
 
       # Test-level operations
-      def test_start(test_case, index, total)
+      def test_start(test_case, index, total, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #test_start"
       end
 
-      def test_result(test_case, result_status, actual_results = [], elapsed_time = nil)
+      def test_end(test_case, index, total, io = $stdout)
+        raise NotImplementedError, "#{self.class} must implement #test_end"
+      end
+
+      def test_result(result_packet, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #test_result"
       end
 
-      def test_output(test_case, output_text)
+      def test_output(test_case, output_text, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #test_output"
       end
 
       # Setup/teardown operations
-      def setup_start(line_range)
+      def setup_start(line_range, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #setup_start"
       end
 
-      def setup_output(output_text)
+      def setup_output(output_text, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #setup_output"
       end
 
-      def teardown_start(line_range)
+      def teardown_start(line_range, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #teardown_start"
       end
 
-      def teardown_output(output_text)
+      def teardown_output(output_text, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #teardown_output"
       end
 
       # Summary operations
-      def batch_summary(total_tests, failed_count, elapsed_time)
+      def batch_summary(total_tests, failed_count, elapsed_time, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #batch_summary"
       end
 
-      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time)
+      def grand_total(total_tests, failed_count, error_count, successful_files, total_files, elapsed_time, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #grand_total"
       end
 
       # Debug and diagnostic output
-      def debug_info(message, level = 0)
+      def debug_info(message, level = 0, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #debug_info"
       end
 
-      def trace_info(message, level = 0)
+      def trace_info(message, level = 0, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #trace_info"
       end
 
-      def error_message(message, details = nil)
+      def error_message(message, details = nil, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #error_message"
       end
 
       # Utility methods
-      def raw_output(text)
+      def raw_output(text, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #raw_output"
       end
 
-      def separator(style = :light)
+      def separator(style = :light, io = $stdout)
         raise NotImplementedError, "#{self.class} must implement #separator"
       end
 
-      def indent_text(text, level)
-        indent = '  ' * level
+      def indent_text(text, level = nil)
+        level ||= current_indent || 0
+        indent  = '  ' * level
         "#{indent}#{text}"
       end