infinity_test 1.0.3 → 2.0.0.rc2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6911d2416f7e79b5629dda190203656dad3c90b8b10dae6e8abaf0103412082
+  data.tar.gz: 5434be704db02566f39a2f6272eb238f648956d6396eb95b3ad0da5f44ef6d10
+SHA512:
+  metadata.gz: 3401363f1c87b54b3242a518f7ff70f9c9c401753e22be535a24ea59984f902cda041363777fe32b0b416b168d30b18be4ed76dbdd981d29d67aeab5f7268242
+  data.tar.gz: 46cb6773e7ddce619f210c120b2ab4b88085266af6da383b593d90a4b8bc3430d4baa3386012d35ef7280efeafd8eaf8c40e231ca518d0f66676021b2a2f1a37

data/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches: [master, main]
+  pull_request:
+    branches: [master, main]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        ruby: ['3.1', '3.2', '3.3']
+        include:
+          - os: ubuntu-latest
+            ruby: jruby
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - name: Run tests
+        run: bundle exec rspec

data/.gitignore

@@ -11,3 +11,6 @@ rerun.txt
 *.rbc
 *~
 bin/*.rbc
+.infinity_test_file
+.ruby-version
+Gemfile.lock

data/.rspec

@@ -1,3 +1,3 @@
 --color
---autotest
---require fuubar --format Fuubar
+--tty
+-f d

data/AI_INTEGRATION_IDEAS.md

@@ -0,0 +1,203 @@
+# AI Integration Ideas for Infinity Test
+
+This document outlines ideas for integrating Infinity Test with AI tools and agents, making Ruby development more efficient and intelligent.
+
+## 1. Claude Code Integration
+
+### Direct Integration
+Infinity Test can work seamlessly with [Claude Code](https://claude.ai/claude-code), Anthropic's CLI tool for AI-assisted development.
+
+**How it works:**
+- Run `infinity_test` in one terminal while using Claude Code in another
+- When Claude Code makes changes to your Ruby files, Infinity Test automatically runs the relevant tests
+- Immediate feedback loop: write code → tests run → see results → iterate
+
+**Example workflow:**
+```bash
+# Terminal 1: Start infinity_test
+infinity_test --mode rails
+
+# Terminal 2: Use Claude Code
+claude "Add a validation to the User model that requires email to be present"
+# Infinity Test automatically runs user_spec.rb when user.rb changes
+```
+
+### AI-Powered Test Generation
+Claude Code can generate tests based on your code changes:
+```bash
+claude "Write RSpec tests for the new validation I just added to User model"
+# Tests are created, infinity_test runs them automatically
+```
+
+## 2. MCP (Model Context Protocol) Server
+
+Create an MCP server that exposes Infinity Test functionality to AI agents:
+
+```ruby
+# Example MCP server endpoints
+class InfinityTestMCPServer
+  # Get current test status
+  def get_test_status
+    { last_run: Time.now, failures: 0, pending: 2 }
+  end
+
+  # Run specific tests
+  def run_tests(files:)
+    InfinityTest.run(files)
+  end
+
+  # Get failed tests
+  def get_failures
+    # Return list of failed test files with error messages
+  end
+end
+```
+
+**Benefits:**
+- AI agents can query test results programmatically
+- Agents can trigger test runs for specific files
+- Agents can understand test failures and suggest fixes
+
+## 3. AI-Assisted Debugging
+
+### Failure Analysis
+When tests fail, integrate with AI to:
+- Analyze the failure message
+- Suggest potential fixes
+- Identify related code that might need changes
+
+```ruby
+# INFINITY_TEST configuration
+InfinityTest.setup do |config|
+  config.after(:all) do |results|
+    if results.failures.any?
+      # Send failures to AI for analysis
+      AIHelper.analyze_failures(results.failures)
+    end
+  end
+end
+```
+
+### Smart Test Selection
+Use AI to predict which tests are most likely to fail based on:
+- Which files were changed
+- Historical failure patterns
+- Code complexity metrics
+
+## 4. Natural Language Test Commands
+
+Future idea: Integrate with AI to support natural language commands:
+
+This is just an idea:
+
+```bash
+# Instead of
+infinity_test --focus spec/models/user_spec.rb
+
+# Support natural language
+infinity_test --ai "run tests for user authentication"
+infinity_test --ai "only run the tests that failed yesterday"
+infinity_test --ai "run slow tests in parallel"
+```
+
+## 5. Continuous Learning
+
+### Pattern Recognition
+- Track which code changes tend to break which tests
+- Learn from your project's test patterns
+- Predict test failures before running
+
+### Smart Prioritization
+- Run tests most likely to fail first
+- Skip tests unlikely to be affected by changes
+- Optimize test order for fastest feedback
+
+## 6. Integration with Popular AI Tools
+
+### GitHub Copilot
+- Infinity Test watches files, Copilot suggests code
+- Immediate test feedback on Copilot suggestions
+
+### Cursor IDE
+- Real-time test results in Cursor's AI panel
+- AI can see test output when suggesting fixes
+
+### Cody (Sourcegraph)
+- Cody understands your test patterns
+- Suggests tests based on code context
+
+## 7. Hooks for AI Agents
+
+Add hooks that AI agents can use:
+
+```ruby
+InfinityTest.setup do |config|
+  # Hook for AI to process before each test run
+  config.before(:all) do
+    AIAgent.notify(:test_starting)
+  end
+
+  # Hook for AI to process test results
+  config.after(:all) do |results|
+    AIAgent.process_results(results)
+  end
+
+  # Custom AI-powered heuristics
+  config.ai_heuristics do |changed_file|
+    AIAgent.predict_tests_to_run(changed_file)
+  end
+end
+```
+
+## 8. Test Quality Analysis
+
+Use AI to analyze test quality:
+- Identify flaky tests
+- Suggest missing test cases
+- Detect duplicate tests
+- Recommend test refactoring
+
+## 9. Documentation Generation
+
+After tests pass, AI can:
+- Generate documentation from test descriptions
+- Update README with usage examples from tests
+- Create API documentation from request specs
+
+## 10. Future Vision: Autonomous Testing
+
+The ultimate goal - AI agents that:
+1. Watch you code
+2. Understand your intent
+3. Write appropriate tests
+4. Run those tests via Infinity Test
+5. Suggest improvements based on results
+6. Iterate until code is solid
+
+---
+
+## Getting Started
+
+To integrate Infinity Test with Claude Code today:
+
+1. Install both tools:
+```bash
+gem install infinity_test
+npm install -g @anthropic/claude-code
+```
+
+2. Start Infinity Test in watch mode:
+```bash
+infinity_test
+```
+
+3. Use Claude Code in another terminal:
+```bash
+claude "Help me write a new feature for my Rails app"
+```
+
+4. Watch the magic happen!
+
+---
+
+*This document is part of the Infinity Test project. Contributions and ideas welcome!*

data/Gemfile

@@ -1,17 +1,5 @@
-#!/usr/bin/env ruby
+source 'https://rubygems.org'
 
-source :rubygems
+gem 'notifiers', github: 'tomas-stefano/notifiers', branch: 'main'
 
-gem 'watchr', '0.7'
-gem 'notifiers', '1.1.0'
-
-group :test do
-  gem 'rspec', ">= 2.1.0"
-  gem 'cucumber', '0.9.0'
-  gem 'aruba', '0.2.1'
-  gem 'fuubar'
-end
-
-group :development do
-  gem 'jeweler'
-end
+gemspec

data/HISTORY.md

@@ -0,0 +1,84 @@
+# History
+
+## 2.0.0
+
+### New Features
+
+- **Elixir Support**: Added ExUnit test framework, ElixirMix and Phoenix frameworks, and ElixirDefault strategy
+  - Auto-discovers Elixir projects by detecting `mix.exs`
+  - Phoenix framework: detects `lib/*_web` directory, watches all lib subdirectories
+  - ElixirMix framework: for standard Mix projects
+  - Watches `lib/**/*.ex` and `test/**/*.exs` files
+  - Parses ExUnit output (tests, failures, skipped)
+
+- **Python Support**: Added Pytest test framework, PythonPackage framework, and PythonDefault strategy
+  - Auto-discovers Python projects by detecting `pyproject.toml`, `setup.py`, or `setup.cfg`
+  - Watches `src/`, `lib/`, and package directories with `__init__.py`
+  - Watches `tests/` or `test/` directories for test files
+  - Parses Pytest output (passed, failed, skipped)
+
+- **Django Framework**: Full support for Django projects
+  - Auto-discovers Django projects by detecting `manage.py` with Django imports
+  - Watches Django app directories (models.py, views.py, apps.py)
+  - Maps app files to their corresponding tests
+
+- **FastAPI Framework**: Support for FastAPI/ML API projects
+  - Auto-discovers FastAPI projects by detecting FastAPI imports in main.py
+  - Watches `app/`, `src/`, `routers/`, `api/`, `endpoints/` directories
+  - Perfect for ML model serving APIs
+
+- **Rust Support**: Added CargoTest test framework, RustCargo and Rocket frameworks, and RustDefault strategy
+  - Auto-discovers Rust projects by detecting `Cargo.toml`
+  - Rocket framework: detects `rocket` dependency in Cargo.toml
+  - Watches `src/*.rs` files and runs tests matching module names
+  - Watches `tests/*.rs` for integration tests
+  - Parses cargo test output (passed, failed, ignored)
+
+- **Modern Observers**: Replaced watchr with listen and filewatcher observers
+  - `listen` (default): Event-driven, uses native OS notifications
+  - `filewatcher`: Polling-based, works in VMs/NFS environments
+
+- **RVM and RbEnv Strategies**: Multi-version Ruby testing support
+  - Run tests against multiple Ruby versions simultaneously
+  - Gemset support for RVM
+
+- **Callbacks System**: Before/after hooks for test runs
+  - `before(:all)`, `after(:all)` for all test runs
+  - `before(:each_ruby)`, `after(:each_ruby)` for each Ruby version
+
+- **Focus Mode**: Run specific tests with `--focus` option
+  - `--focus=:failures` to run only previously failed tests
+  - `--focus=path/to/file` to run specific test file
+
+- **Just Watch Mode**: `--just-watch` option to skip initial test run
+
+- **Auto-discover App Directories**: Automatically detect and watch Rails/Padrino app subdirectories (models, controllers, components, etc.)
+
+- **Start Banner**: Display configuration summary on startup
+
+- **Bundler Support**: Automatic `bundle exec` wrapping when Gemfile is present
+
+- **Colored Output**: Preserve terminal colors with PTY and verbose command display
+
+- **CLI Options**: Added `--notifications` and `--mode` options for desktop notifications
+
+### Improvements
+
+- **Modern Notifications**: Updated to use modern notifiers gem with support for:
+  - macOS: terminal-notifier, osascript
+  - Linux: notify-send, dunstify
+
+- **Priority Ordering**: Auto-discover now respects priority order for strategies, frameworks, and test frameworks
+
+- **Rails and Padrino Heuristics**: Improved file watching patterns for Rails and Padrino applications
+
+- **GitHub Actions**: Replaced Travis CI with GitHub Actions for CI/CD
+
+- **Configuration File**: Renamed config file to `INFINITY_TEST`
+
+### Compatibility
+
+- Updated for Ruby 3.x compatibility
+- Updated for ActiveSupport 7.0+ compatibility
+- Updated for modern RSpec syntax (replaced deprecated `stub` with `allow().to receive()`)
+- Improved test descriptions by removing 'should' prefix

data/History.markdown

@@ -1,4 +1,86 @@
+v2.0.0
+======
+
+This is a major release with a complete rewrite of the library, modernization of dependencies, and many new features.
+
+Breaking Changes
+----------------
+- Configuration file renamed from `.infinity_test` to `INFINITY_TEST`
+- Removed Bacon test framework support
+- Removed Growl notification support (use notifiers gem instead)
+- The #before_env method in the configuration file was removed
+- The #before_run and #after_run methods were removed. Use before(:all) and after(:all) instead
+
+New Features
+------------
+- **Modern Notifications**: Integration with the notifiers gem supporting:
+  - osascript (macOS built-in)
+  - terminal_notifier (macOS)
+  - notify_send (Linux libnotify)
+  - dunstify (Linux dunst)
+  - auto_discover (automatic detection)
+  - New CLI options: `--notifications` and `--mode` for image themes
+
+- **Callbacks System**: Full callback support with before/after hooks
+  - `before(:all)` - Run before all tests
+  - `after(:all)` - Run after all tests
+  - `before(:each_ruby)` - Run before each Ruby version
+  - `after(:each_ruby)` - Run after each Ruby version
+
+- **Multi-Ruby Support**:
+  - RVM strategy: Run tests across multiple Ruby versions with gemset support
+  - RbEnv strategy: Run tests with RBENV_VERSION environment variable
+  - RubyDefault strategy: Run on current Ruby version
+
+- **Just Watch Mode**: `--just-watch` (-j) option to skip initial test run
+  - Useful for large applications where startup is slow
+  - Only watches for file changes and runs tests on change
+
+- **Focus Mode**: `--focus` (-f) option for running specific tests
+  - `--focus failures` - Run only previously failed tests
+  - `--focus path/to/spec.rb` - Run only specified file
+
+- **Framework Heuristics**:
+  - Rails: Watches models, controllers, helpers, mailers, jobs, lib
+  - Padrino: Similar to Rails with Padrino-specific paths
+  - Rubygems: Watches lib and test/spec directories
+
+- **Auto Discovery Priority**: Smart prioritization when auto-discovering
+  - Strategies: RVM > RbEnv > RubyDefault
+  - Frameworks: Rails > Padrino > Rubygems
+  - Test Frameworks: RSpec > Test::Unit
+
+- **Test Framework Improvements**:
+  - Complete Test::Unit/Minitest implementation with output parsing
+  - RSpec improvements: test_dir=, pending?, and .run? methods
+
+- **Modern File Watching**:
+  - Listen gem (default) - Event-driven, uses native OS notifications
+  - Filewatcher gem - Polling-based, works everywhere including VMs/NFS
+
+- **AI Integration Ideas**: Documentation for integrating with Claude Code and other AI tools
+
+Bug Fixes
+---------
+- Fixed signal handler blocking issue in observer base
+- Fixed ActiveSupport autoload issues
+- Replaced deprecated stub with allow().to receive() in specs
+
+Dependencies
+------------
+- Replaced watchr with listen and filewatcher observers
+- Updated to modern notifiers gem (from GitHub main branch)
+- Removed growl dependency
+
+Internal Changes
+----------------
+- Rewrite of the entire library with separated responsibilities
+- Shared examples for creating custom strategies, frameworks, and observers
+- Updated all specs to modern RSpec syntax
+- Comprehensive test coverage (250+ examples)
+
 v1.0.1
+======
 
 - Fix a serious bug for Test::unit users (just run one test file instead of all tests)
 

data/{.infinity_test → INFINITY_TEST}

@@ -1,8 +1,11 @@
-#!/usr/bin/env ruby
+#InfinityTest.setup do |config|
+#  config.strategy       = :ruby_default
+#  config.test_framework = :rspec
+#end
 
-infinity_test do
-  
-  use :rubies => ['1.8.7', '1.9.2', 'jruby', 'ree', 'rbx'], :gemset => 'infinity_test', :test_framework => :rspec
+# infinity_test do
+
+  # use :rubies => ['1.9.2', 'jruby', 'ree', 'rbx'], :gemset => 'infinity_test', :test_framework => :rspec
 
   # Maybe with block is better ...
   #
@@ -13,15 +16,15 @@ infinity_test do
   #   application_framework = :rails
   # end
 
-  heuristics do
-    add '^lib/infinity_test/dependencies.rb' do |file|
-      run :all => :files
-    end
-  end
-  
-  after(:all) do
-    system('rake clean_without_verbose')
-  end
+  # heuristics do
+  #   add '^lib/infinity_test/dependencies.rb' do |file|
+  #     run :all => :files
+  #   end
+  # end
+
+#  after(:all) do
+#    system('rake clean_without_verbose')
+#  end
 
   # heuristics do
   #
@@ -36,10 +39,10 @@ infinity_test do
   #   application_library.watch :dir => 'app/models' do |file|
   #     run :test => "spec/models/"
   #   end
-  #   
+  #
   #   watch(%r%^(test|spec)/fixtures/(.*).yml$%) do |m|
   #     "test/test_#{m[1]}.rb"
   #   end
   # end
 
-end
+# end

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2010 Tomás D'Stefano
+Copyright (c) 2010-2014 Tomás D'Stefano
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -19,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.