whodunit-chronicles 0.1.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 527e3470b4156a28e1972948cc79cbe4ce2ee72ec7582692434e98611c5e0071
+  data.tar.gz: 51302c24757877422d8ec97f894aa4af06561d9d53fa60ac65f6bc94d4b89705
+SHA512:
+  metadata.gz: 5ce050e09a6f0407c2d5c64b2196910f84834fc17408a3477fd082fbab04a346fb69dbc43d28fbd1d8868f25915206c6af6b9ac1ffe52700d7c0b2e9e46916b9
+  data.tar.gz: cea9a584c9fb99306a6cbcbdd8afc87f23f14db4ec6e90f96c8364006defb869ce3abd69fb72a02a4e4a79ce9144494e96c47dacca27e9ef669f4bb0ff44558a

data/.rubocop.yml

@@ -0,0 +1,92 @@
+# Ruby version
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  Exclude:
+    - 'vendor/**/*'
+    - 'tmp/**/*'
+    - 'bin/**/*'
+    - 'node_modules/**/*'
+
+# Use plugins for extensions
+plugins:
+  - rubocop-performance
+  - rubocop-minitest
+
+# Layout cops
+Layout/LineLength:
+  Max: 120
+  AllowedPatterns: ['\A\s*#']
+
+Layout/MultilineMethodCallBraceLayout:
+  Enabled: false
+
+Layout/ArgumentAlignment:
+  EnforcedStyle: with_fixed_indentation
+
+# Metrics cops - relax for complex business logic
+Metrics/ClassLength:
+  Max: 250  # Allow larger classes for database adapters and processors
+  Exclude:
+    - 'test/**/*'  # Test classes can be longer
+
+Metrics/MethodLength:
+  Max: 50  # Allow longer methods for SQL generation and complex logic
+
+Metrics/AbcSize:
+  Max: 40  # Allow higher complexity for database operations
+
+Metrics/CyclomaticComplexity:
+  Max: 15  # Allow more complex conditional logic
+
+Metrics/PerceivedComplexity:
+  Max: 15
+
+Metrics/ParameterLists:
+  Max: 12  # Allow more params for configuration objects and event initialization
+
+# Style cops
+Style/Documentation:
+  Enabled: false  # We have YARD docs
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/HashSyntax:
+  EnforcedStyle: ruby19
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+# Naming
+Naming/FileName:
+  Exclude:
+    - 'lib/whodunit-chronicles.rb'  # Main gem file
+
+# Gemspec
+Gemspec/DevelopmentDependencies:
+  Enabled: false  # We're fine with dev dependencies in gemspec
+
+# Minitest specific cops
+Minitest/MultipleAssertions:
+  Max: 10  # Allow more assertions in comprehensive tests
+
+Minitest/AssertNil:
+  Enabled: false  # Prefer assert_nil over assert_equal(nil, ...)
+
+# Performance cops
+Performance/Casecmp:
+  Enabled: true
+
+Performance/StringReplacement:
+  Enabled: true

data/.yardopts

@@ -0,0 +1,12 @@
+--markup markdown
+--markup-provider kramdown
+--output-dir docs
+--exclude spec/
+--exclude vendor/
+--main README.md
+--title "Whodunit API Documentation"
+--charset utf-8
+lib/**/*.rb
+-
+README.md
+CHANGELOG.md

data/CHANGELOG.md

@@ -0,0 +1,106 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Comprehensive GitHub Actions CI/CD pipeline with multi-Ruby testing
+- Automated security scanning with bundler-audit and CodeQL
+- YARD documentation generation with GitHub Pages deployment
+- Automated gem publishing workflow for tagged releases
+- Structured issue and pull request templates for better contributor experience
+- Dependabot configuration for automated dependency updates
+- Security scanning dependencies (bundler-audit, brakeman)
+- Comprehensive README with architecture diagrams and examples
+- RuboCop configuration with relaxed metrics for test files
+
+### Changed
+
+- Updated dependencies to latest versions with security patches
+- Improved RuboCop configuration to exclude test files from ClassLength limits
+- Enhanced gemspec with proper metadata and security dependencies
+
+## [0.1.0] - 2025-01-21
+
+### Added
+
+- **Core Architecture**: Complete zero-latency audit streaming implementation
+- **PostgreSQL Adapter**: Logical replication streaming with WAL decoding
+- **ChangeEvent System**: Unified change representation across database adapters
+- **AuditProcessor**: Intelligent transformation of changes into audit records
+- **Configuration Management**: Comprehensive settings with validation using dry-configurable
+- **Service Orchestration**: Thread-safe service with error handling and retry logic
+- **Abstract Adapter Pattern**: Extensible design supporting multiple database systems
+- **User Attribution**: Automatic extraction of user information from creator/updater/deleter fields
+- **Batch Processing**: Efficient bulk processing of audit records
+- **Connection Management**: Robust database connection handling with retries
+- **Error Handling**: Comprehensive error recovery and logging
+- **Thread Safety**: Concurrent processing with thread pool management
+
+### Technical Implementation
+
+- **Modern Ruby Support**: Ruby 3.1+ with frozen string literals
+- **Database Features**:
+  - PostgreSQL logical replication with pgoutput plugin
+  - Publication and replication slot management
+  - WAL position tracking and resumption
+  - Connection pooling and management
+- **Event Processing**:
+  - Real-time change capture at database level
+  - Structured change events with metadata
+  - Configurable table and schema filtering
+  - Transaction ID and sequence number tracking
+- **Audit Records**:
+  - Complete before/after data capture
+  - Calculated field-level changes
+  - User attribution from standard columns
+  - Timestamps and version tracking
+  - JSON metadata storage
+
+### Development & Testing
+
+- **Test Coverage**: 94.3% code coverage (447/474 lines)
+- **Testing Framework**: Minitest with shoulda-style assertions and mocha mocking
+- **Test Suite**: 129 tests covering all components with comprehensive error scenarios
+- **Code Quality**: RuboCop compliance with modern Ruby standards
+- **Security**: bundler-audit integration for vulnerability scanning
+- **Documentation**: Inline YARD documentation for all public APIs
+
+### Dependencies
+
+- **Core**: concurrent-ruby, dry-configurable, dry-logger, pg
+- **Development**: minitest, rubocop, simplecov, yard
+- **Testing**: mocha for mocking, pry for debugging
+- **Security**: bundler-audit for vulnerability scanning
+
+### Configuration Options
+
+- Database connection URLs (source and audit)
+- PostgreSQL publication and replication slot names
+- Batch processing sizes and retry policies
+- Table and schema inclusion/exclusion filters
+- Logging levels and output configuration
+- Thread pool and concurrency settings
+
+### Performance Features
+
+- **Zero Application Overhead**: No Rails callbacks or Active Record hooks
+- **Efficient Streaming**: PostgreSQL logical replication optimization
+- **Memory Management**: Streaming processing without dataset loading
+- **Configurable Batching**: Tunable batch sizes for optimal throughput
+- **Connection Reuse**: Persistent connections with automatic recovery
+- **Background Processing**: Non-blocking operation with thread pools
+
+### Production Ready Features
+
+- **Monitoring**: Service status and health checking
+- **Resilience**: Automatic retry logic with exponential backoff
+- **Graceful Shutdown**: Clean service termination
+- **Error Recovery**: Robust error handling with detailed logging
+- **Position Tracking**: WAL position persistence for reliable resumption
+- **Resource Management**: Bounded thread pools and memory usage

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ken C. Demanawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.

data/README.md

@@ -0,0 +1,281 @@
+# 📚 Whodunit Chronicles
+
+[![Gem Version](https://badge.fury.io/rb/whodunit-chronicles.svg)](https://badge.fury.io/rb/whodunit-chronicles)
+[![CI](https://github.com/kanutocd/whodunit-chronicles/workflows/CI/badge.svg)](https://github.com/kanutocd/whodunit-chronicles/actions)
+[![Coverage Status](https://codecov.io/gh/kanutocd/whodunit-chronicles/branch/main/graph/badge.svg)](https://codecov.io/gh/kanutocd/whodunit-chronicles)
+[![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.1.0-ruby.svg)](https://www.ruby-lang.org/en/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> **The complete historical record of your _Whodunit Dun Wat?_ data**
+
+While [Whodunit](https://github.com/kanutocd/whodunit) tracks _who_ made changes, **Chronicles** captures _what_ changed by streaming database events into comprehensive audit trails with **zero Rails application overhead**.
+
+## ✨ Features
+
+- **🚄 Zero-Latency Streaming**: PostgreSQL logical replication
+- **🔄 Zero Application Overhead**: No Rails callbacks or Active Record hooks required
+- **🏗️ Database Agnostic**: Abstract adapter pattern supports PostgreSQL (TODO: MySQL/MariaDB support)
+- **⚡ Thread-Safe**: Concurrent processing with configurable thread pools
+- **🛡️ Resilient**: Built-in error handling, retry logic, and monitoring
+- **📊 Complete Audit Trail**: Captures INSERT, UPDATE, DELETE with full before/after data
+- **🧪 VERY Soon to be Production Ready**: 94%+ test coverage with comprehensive error scenarios
+
+## 🚀 Quick Start
+
+### Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'whodunit-chronicles'
+```
+
+Or install directly:
+
+```bash
+gem install whodunit-chronicles
+```
+
+### Basic Usage
+
+```ruby
+require 'whodunit/chronicles'
+
+# PostgreSQL Configuration
+Whodunit::Chronicles.configure do |config|
+  config.adapter = :postgresql
+  config.database_url = 'postgresql://localhost/myapp_production'
+  config.audit_database_url = 'postgresql://localhost/myapp'
+  config.publication_name = 'myapp_chronicles'
+  config.replication_slot_name = 'myapp_chronicles_slot'
+end
+
+# Create and start the service
+service = Whodunit::Chronicles.service
+service.setup!  # Create publication/replication setup
+service.start   # Begin streaming changes
+
+# Service runs in background threads
+sleep 10
+
+# Stop gracefully
+service.stop
+service.teardown!  # Clean up database objects
+```
+
+## 🏗️ Architecture
+
+Chronicles uses **PostgreSQL logical replication** (TODO: **MySQL/MariaDB binary log streaming**) to capture database changes without impacting your application:
+
+```
+┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
+│   Application   │    │    Chronicles    │    │   Audit Store   │
+│   Database      │───▶│     Service      │───▶│   Database      │
+│                 │    │                  │    │                 │
+│ • Users         │    │ • Stream Adapter │    │ • audit_records │
+│ • Posts         │    │ • Event Parser   │    │ • Searchable    │
+│ • Comments      │    │ • Audit Builder  │    │ • Reportable    │
+└─────────────────┘    └──────────────────┘    └─────────────────┘
+        │                       │
+        │              ┌────────▼────────┐
+        │              │  PostgreSQL     │
+        └──────────────│  Logical        │
+                       │  Replication    │
+                       └─────────────────┘
+```
+
+### Core Components
+
+- **StreamAdapter**: Database-specific change streaming (PostgreSQL, MySQL/MariaDB)
+- **ChangeEvent**: Unified change representation across adapters
+- **AuditProcessor**: Transforms changes into searchable audit records
+- **Service**: Orchestrates streaming with error handling and retry logic
+
+## ⚙️ Configuration
+
+```ruby
+Whodunit::Chronicles.configure do |config|
+  # Database connections
+  config.database_url = ENV['DATABASE_URL']
+  config.audit_database_url = ENV['AUDIT_DATABASE_URL']
+
+  # Database adapter (postgresql, mysql, mariadb)
+  config.adapter = :postgresql
+
+  # PostgreSQL-specific settings
+  config.publication_name = 'whodunit_chronicles'
+  config.replication_slot_name = 'whodunit_chronicles_slot'
+
+  # Performance tuning
+  config.batch_size = 1000
+  config.max_retry_attempts = 5
+  config.retry_delay = 10
+
+  # Table filtering
+  config.include_tables = %w[users posts comments]
+  config.exclude_tables = %w[sessions temp_data]
+  config.include_schemas = %w[public app]
+  config.exclude_schemas = %w[information_schema pg_catalog]
+end
+```
+
+## 📊 Audit Records
+
+Chronicles creates structured audit records for each database change:
+
+```ruby
+{
+  id: 123,
+  table_name: "users",
+  schema_name: "public",
+  record_id: { "id" => 456 },
+  action: "UPDATE",
+  old_data: { "id" => 456, "email" => "old@example.com", "name" => "Old Name" },
+  new_data: { "id" => 456, "email" => "new@example.com", "name" => "New Name" },
+  changes: { "email" => ["old@example.com", "new@example.com"] },
+  user_id: 789,           # From creator_id/updater_id/deleter_id columns
+  user_type: "User",
+  transaction_id: "tx_abc123",
+  sequence_number: 42,
+  occurred_at: 2025-01-21 10:30:00 UTC,
+  created_at: 2025-01-21 10:30:01 UTC,
+  metadata: {
+    table_schema: "public",
+    qualified_table_name: "public.users",
+    changed_columns: ["email"],
+    chronicles_version: "0.1.0"
+  }
+}
+```
+
+## 🔧 Advanced Usage
+
+### Custom Audit Processing
+
+```ruby
+class MyCustomProcessor < Whodunit::Chronicles::AuditProcessor
+  def build_chronicles_record(change_event)
+    super.tap do |record|
+      record[:custom_field] = extract_custom_data(change_event)
+      record[:environment] = Rails.env
+    end
+  end
+
+  private
+
+  def extract_custom_data(change_event)
+    # Your custom logic here
+  end
+end
+
+# Use custom processor
+service = Whodunit::Chronicles::Service.new(
+  processor: MyCustomProcessor.new
+)
+```
+
+### Service Monitoring
+
+```ruby
+service = Whodunit::Chronicles.service
+
+# Check service status
+status = service.status
+puts "Running: #{status[:running]}"
+puts "Adapter Position: #{status[:adapter_position]}"
+puts "Retry Count: #{status[:retry_count]}"
+puts "Active Threads: #{status[:executor_status][:active_count]}"
+
+# Monitor in production
+Thread.new do
+  loop do
+    status = service.status
+    Rails.logger.info "Chronicles Status: #{status}"
+    sleep 60
+  end
+end
+```
+
+## 🧪 Testing
+
+Chronicles includes comprehensive test coverage:
+
+```bash
+# Run test suite
+bundle exec rake test
+
+# Run with coverage
+bundle exec rake test
+open coverage/index.html
+
+# Security scanning
+bundle exec bundler-audit check
+bundle exec brakeman
+```
+
+## 📈 Performance
+
+- **Minimal Overhead**: No Rails callback performance impact
+- **Efficient Streaming**: PostgreSQL logical replication is highly optimized
+- **Configurable Batching**: Process changes in configurable batch sizes
+- **Thread Pool**: Concurrent processing with bounded resource usage
+- **Memory Efficient**: Streaming processing without loading full datasets
+
+## 🛡️ Security
+
+- **Dependency Scanning**: Automated bundler-audit checks
+- **Code Analysis**: GitHub CodeQL integration
+- **Vulnerability Monitoring**: Weekly security scans
+- **Safe Defaults**: Secure configuration out of the box
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes with tests
+4. Ensure tests pass (`bundle exec rake test`)
+5. Ensure RuboCop passes (`bundle exec rubocop`)
+6. Commit your changes (`git commit -m 'Add amazing feature'`)
+7. Push to the branch (`git push origin feature/amazing-feature`)
+8. Open a Pull Request
+
+## 📋 Requirements
+
+- **Ruby**: 3.1.0 or higher
+- **PostgreSQL**: 10.0 or higher (with logical replication enabled)
+
+## 🗺️ Roadmap
+
+- [ ] **MySQL/MariaDB Support**: MySQL/MariaDB databases binlog streaming adapter
+- [ ] **Redis Streams**: Alternative lightweight streaming backend
+- [ ] **Compression**: Optional audit record compression
+- [ ] **Retention Policies**: Automated audit record cleanup
+- [ ] **Web UI**: Management interface for monitoring and configuration
+- [ ] **Prometheus Metrics**: Production monitoring integration
+
+## 📚 Documentation
+
+- **[API Documentation](https://kanutocd.github.io/whodunit-chronicles/)**
+- **[Configuration Guide](docs/configuration-todo.md)**
+- **[Architecture Deep Dive](docs/architecture-todo.md)**
+- **[PostgreSQL Setup](docs/postgresql-setup-todo.md)**
+- **[Production Deployment](docs/production-todo.md)**
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **PostgreSQL Team**: For excellent logical replication functionality
+- **Ruby Community**: For amazing gems and tools that make this possible
+
+---
+
+<div align="center">
+
+**[⭐ Star us on GitHub](https://github.com/kanutocd/whodunit-chronicles)** • **[🐛 Report Bug](https://github.com/kanutocd/whodunit-chronicles/issues)** • **[💡 Request Feature](https://github.com/kanutocd/whodunit-chronicles/issues)**
+
+Made with ❤️ by a Spherical Cow
+
+</div>

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+RuboCop::RakeTask.new
+
+desc 'Run all checks (rubocop, tests)'
+task check: %i[rubocop test]
+
+task default: :check