eksa-mination 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1b4a71a3c02a2d192423b2b171a1cd6752a712ffee7093e611e33a88a1c6e48
+  data.tar.gz: 79f31960ca216c4c3b97d9086b446b495199978046a0d094d62a56faf94df758
+SHA512:
+  metadata.gz: f45bb698967aa92f5ffa516a882100390da7b743865c11a0b1c7738e0e09ad19dedbbee65ed10ffd5230690ae731f1d80ce88545aecd49d69f7978231ca384f4
+  data.tar.gz: 319c76f62089634983380db8e92b3a9049261d022f1666fecb0fa5e0a04292d592239c03e72e105ffdbc8595fd0771c5452749a4f3e95371c2f7960d9c52a0b8

data/.eksa-mination

@@ -0,0 +1 @@
+--format documentation

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IshikawaUta
+
+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,54 @@
+# Eksa-Mination 🚀
+
+A robust, modular, and feature-rich Ruby testing framework inspired by RSpec.
+
+Eksa-Mination provides a familiar DSL for writing expressive tests, comprehensive mocking/stubbing capabilities, and powerful reporting tools—all in a lightweight package.
+
+## ✨ Features
+
+- **Fluent DSL**: `describe`, `it`, `let`, `let!`, `subject`, and `shared_examples`.
+- **Flexible Matchers**: `eq`, `be_a`, `respond_to`, `include`, `match`, `raise_error`, and more.
+- **Advanced Mocking**: Method stubbing (`allow().to receive()`) and **Constant Stubbing** (`stub_const`).
+- **Powerful Filtering**: Run tests by name (`-e`), line number (`file:line`), or **Metadata Tags** (`--tag`).
+- **Rich Reporting**: Built-in formatters for **Progress**, **Documentation**, **JSON**, and **HTML** (Premium Dark Mode).
+- **Configuration**: Automatic loading of defaults from `.eksa-mination`.
+
+## 🚀 Getting Started
+
+### Installation
+Install it as a gem:
+
+```bash
+gem install eksa-mination
+```
+
+Or clone this repository directly to your project.
+
+### Running Tests
+By default, Eksa-Mination looks for files matching `spec/**/*_spec.rb`.
+
+```bash
+# Run all tests
+eksa-mination
+
+# Run with Documentation formatter
+eksa-mination -f documentation
+
+# Run a specific line
+eksa-mination spec/my_spec.rb:15
+
+# Filter by Tag
+eksa-mination --tag focus
+
+# Generate HTML Report
+eksa-mination -f html
+```
+
+## 📋 Project Structure
+
+- `bin/`: The primary executable.
+- `lib/eksa-mination`: Core logic, matchers, and formatters.
+- `spec/`: Example testing files and usage demonstrations.
+
+## 📄 License
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

data/bin/eksa-mination

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/eksa-mination'
+
+# Start the CLI
+EksaMination::CLI.new(ARGV).run

data/lib/calculator.rb

@@ -0,0 +1,18 @@
+class Calculator
+  def add(a, b)
+    a + b
+  end
+
+  def subtract(a, b)
+    a - b
+  end
+
+  def multiply(a, b)
+    a * b
+  end
+
+  def divide(a, b)
+    raise "Division by zero" if b == 0
+    a.to_f / b
+  end
+end

data/lib/eksa-mination/cli.rb

@@ -0,0 +1,118 @@
+require 'optparse'
+
+module EksaMination
+  class CLI
+    def initialize(args)
+      @args = load_config_args + args
+      @options = {
+        pattern: 'spec/**/*_spec.rb'
+      }
+    end
+
+    def run
+      parse_options
+      files = discover_files
+      
+      if files.empty?
+        puts "No spec files found."
+        exit 1
+      end
+
+      files.each do |file|
+        load File.expand_path(file)
+      end
+
+      if @options[:formatter]
+        EksaMination.reporter = @options[:formatter].new
+      end
+      EksaMination.reporter.use_color = @options[:color] unless @options[:color].nil?
+      EksaMination.run(@options)
+      
+      # Exit with status code based on failures
+      exit(EksaMination.reporter.instance_variable_get(:@failures).any? ? 1 : 0)
+    end
+
+    private
+
+    def load_config_args
+      if File.exist?('.eksa-mination')
+        File.read('.eksa-mination').split(/\s+/)
+      else
+        []
+      end
+    end
+
+    def parse_options
+      OptionParser.new do |opts|
+        opts.banner = "Usage: eksa-mination [options] [files or directories]"
+        opts.separator ""
+        opts.separator "  **** Output ****"
+        opts.separator ""
+        
+        opts.on("-v", "--version", "Display the version.") do
+          puts "eksa-mination #{EksaMination::VERSION}"
+          exit
+        end
+
+        opts.on("-h", "--help", "You're looking at it.") do
+          puts opts
+          exit
+        end
+
+        opts.on("-P", "--pattern PATTERN", "Load files matching pattern (default: \"spec/**/*_spec.rb\").") do |p|
+          @options[:pattern] = p
+        end
+
+        opts.on("-f", "--format FORMATTER", "Choose a formatter ([p]rogress, [d]ocumentation, [j]son, [h]tml)") do |f|
+          case f
+          when 'p', 'progress'
+            @options[:formatter] = EksaMination::Formatters::Progress
+          when 'd', 'documentation'
+            @options[:formatter] = EksaMination::Formatters::Documentation
+          when 'j', 'json'
+            @options[:formatter] = EksaMination::Formatters::JSONFormatter
+          when 'h', 'html'
+            @options[:formatter] = EksaMination::Formatters::HTML
+          end
+        end
+
+        opts.on("--[no-]color", "--[no-]colour", "Enable/disable color output") do |c|
+          # logic for color toggle can be added to BaseFormatter
+          @options[:color] = c
+        end
+
+        opts.separator ""
+        opts.separator "  **** Filtering/tags ****"
+        opts.separator ""
+        opts.on("-e", "--example STRING", "Run examples whose full nested names include STRING") do |s|
+          @options[:example] = s
+        end
+
+        opts.on("-t", "--tag TAG", "Run examples with the specified tag") do |t|
+          @options[:tag] = t
+        end
+      end.parse!(@args)
+    end
+
+    def discover_files
+      if @args.empty?
+        Dir.glob(@options[:pattern])
+      else
+        @args.flat_map do |arg|
+          path, line = arg.split(':')
+          if line
+            @options[:line_numbers] ||= {}
+            full_path = File.expand_path(path)
+            @options[:line_numbers][full_path] ||= []
+            @options[:line_numbers][full_path] << line.to_i
+            path
+          elsif File.directory?(path)
+            Dir.glob(File.join(path, "**/*_spec.rb"))
+          else
+            path
+          end
+        end.compact.uniq
+      end
+    end
+  end
+end

data/lib/eksa-mination/dsl.rb

@@ -0,0 +1,175 @@
+module EksaMination
+  module DSL
+    def describe(description, *metadata, &block)
+      # Check if we are inside another describe
+      parent = EksaMination.current_group
+      file_path, line_number = block.source_location
+      options = process_metadata(metadata)
+      group = ExampleGroup.new(description, parent: parent, metadata: options, file_path: file_path, line_number: line_number)
+      
+      EksaMination.current_group = group
+      group.instance_eval(&block)
+      EksaMination.current_group = parent
+      
+      # Only register top-level groups to the main runner
+      EksaMination.register_group(group) unless parent
+    end
+
+    def xdescribe(description, *metadata, &block)
+      file_path, line_number = block.source_location
+      options = process_metadata(metadata).merge(skipped: true)
+      group = ExampleGroup.new(description, parent: EksaMination.current_group, metadata: options, skipped: true, file_path: file_path, line_number: line_number)
+      EksaMination.register_group(group)
+    end
+
+    def shared_examples(name, &block)
+      EksaMination.shared_examples[name] = block
+    end
+
+    private
+
+    def process_metadata(metadata_args)
+      options = {}
+      metadata_args.each do |arg|
+        if arg.is_a?(Symbol)
+          options[arg] = true
+        elsif arg.is_a?(Hash)
+          options.merge!(arg)
+        end
+      end
+      options
+    end
+  end
+
+  class ExampleGroup
+    attr_reader :description, :examples, :before_hooks, :after_hooks, :let_blocks, :let_bang_blocks, :subject_block, :skipped, :parent, :file_path, :line_number, :metadata
+
+    def initialize(description, parent: nil, skipped: false, metadata: {}, file_path: nil, line_number: nil)
+      @description = description
+      @parent = parent
+      @examples = []
+      @before_hooks = []
+      @after_hooks = []
+      @let_blocks = {}
+      @let_bang_blocks = {}
+      @skipped = skipped || (parent && parent.skipped)
+      @metadata = (parent ? parent.metadata.merge(metadata) : metadata)
+      @file_path = file_path
+      @line_number = line_number
+    end
+
+    def it(description, *metadata, &block)
+      file_path, line_number = block.source_location
+      options = process_metadata(metadata)
+      @examples << Example.new(description, block, parent: self, metadata: options, file_path: file_path, line_number: line_number)
+    end
+
+    def xit(description, *metadata, &block)
+      file_path, line_number = block.source_location
+      options = process_metadata(metadata).merge(skipped: true)
+      @examples << Example.new(description, block, parent: self, metadata: options, skipped: true, file_path: file_path, line_number: line_number)
+    end
+
+
+    def let(name, &block)
+      @let_blocks[name] = block
+    end
+
+    def let!(name, &block)
+      @let_bang_blocks[name] = block
+    end
+
+    def subject(&block)
+      @subject_block = block
+    end
+
+    def before(&block)
+      @before_hooks << block
+    end
+
+    def after(&block)
+      @after_hooks << block
+    end
+
+    def full_description
+      @parent ? "#{@parent.full_description} #{@description}" : @description
+    end
+    
+    # Nested groups started from inside this group
+    def describe(description, &block)
+      file_path, line_number = block.source_location
+      group = ExampleGroup.new(description, parent: self, file_path: file_path, line_number: line_number)
+      @examples << group
+      group.instance_eval(&block)
+    end
+
+    def it_behaves_like(name, *args)
+      block = EksaMination.shared_examples[name]
+      raise "Shared examples '#{name}' not found" unless block
+      instance_exec(*args, &block)
+    end
+
+    private
+
+    def process_metadata(metadata_args)
+      options = {}
+      metadata_args.each do |arg|
+        if arg.is_a?(Symbol)
+          options[arg] = true
+        elsif arg.is_a?(Hash)
+          options.merge!(arg)
+        end
+      end
+      options
+    end
+  end
+
+  class Example
+    attr_reader :description, :block, :skipped, :file_path, :line_number, :parent, :metadata
+
+    def initialize(description, block, parent: nil, metadata: {}, skipped: false, file_path: nil, line_number: nil)
+      @description = description
+      @block = block
+      @parent = parent
+      @metadata = (parent ? parent.metadata.merge(metadata) : metadata)
+      @skipped = skipped || @metadata[:skipped]
+      @file_path = file_path
+      @line_number = line_number
+    end
+
+    def full_description
+      @parent ? "#{@parent.full_description} #{@description}" : @description
+    end
+  end
+
+  @groups = []
+  @current_group = nil
+  @shared_examples = {}
+
+  def self.register_group(group)
+    @groups << group
+  end
+
+  def self.groups
+    @groups
+  end
+
+  def self.shared_examples
+    @shared_examples
+  end
+
+  def self.current_group
+    @current_group
+  end
+
+  def self.current_group=(group)
+    @current_group = group
+  end
+
+  def self.reset!
+    @groups = []
+  end
+end
+
+# Global monkeypatch
+Object.include(EksaMination::DSL)

data/lib/eksa-mination/formatters/base.rb

@@ -0,0 +1,78 @@
+module EksaMination
+  module Formatters
+    class Base
+      COLORS = {
+        green: "\e[32m",
+        red: "\e[31m",
+        yellow: "\e[33m",
+        cyan: "\e[36m",
+        reset: "\e[0m",
+        bold: "\e[1m"
+      }
+
+      attr_reader :failures, :skipped, :example_count, :results
+      attr_accessor :use_color
+
+      def initialize
+        @failures = []
+        @skipped = []
+        @results = []
+        @example_count = 0
+        @use_color = true
+      end
+
+      def group_started(group); end
+      def group_finished(group); end
+
+      def report_success(example)
+        @example_count += 1
+        @results << { example: example, status: :passed }
+      end
+
+      def report_failure(example, error)
+        @example_count += 1
+        @failures << { example: example, error: error }
+        @results << { example: example, status: :failed, error: error }
+      end
+
+      def report_skipped(example)
+        @example_count += 1
+        @skipped << example
+        @results << { example: example, status: :pending }
+      end
+
+      def summarize
+        puts "\n\n"
+        if @failures.any?
+          puts colorize("Failures:", :red)
+          @failures.each_with_index do |failure, i|
+            example = failure[:example]
+            error = failure[:error]
+            puts "\n#{i + 1}) #{example.full_description}"
+            if error.respond_to?(:expected) && (error.expected || error.actual)
+              puts "   Failure/Error: #{colorize(error.failure_message, :red)} #{colorize(error.expected.inspect, :green)} (expected) vs #{colorize(error.actual.inspect, :red)} (actual)"
+            else
+              puts "   #{colorize(error.message, :red)}"
+            end
+            # Show file:line from backtrace
+            bt = error.backtrace.find { |l| l.include?('_spec.rb') } || error.backtrace.first
+            puts "   # #{bt}"
+          end
+        end
+
+        puts "\n"
+        color = @failures.any? ? :red : :green
+        summary = "#{@example_count} examples, #{@failures.size} failures"
+        summary += ", #{@skipped.size} pending" if @skipped.any?
+        puts colorize(summary, color)
+      end
+
+      private
+
+      def colorize(text, color)
+        return text unless @use_color
+        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+      end
+    end
+  end
+end

data/lib/eksa-mination/formatters/documentation.rb

@@ -0,0 +1,36 @@
+require_relative 'base'
+
+module EksaMination
+  module Formatters
+    class Documentation < Base
+      def initialize
+        super
+        @level = 0
+      end
+
+      def group_started(group)
+        puts "  " * @level + group.description
+        @level += 1
+      end
+
+      def group_finished(group)
+        @level -= 1
+      end
+
+      def report_success(example)
+        super
+        puts "  " * @level + colorize(example.description, :green)
+      end
+
+      def report_failure(example, error)
+        super
+        puts "  " * @level + colorize(example.description + " (FAILED)", :red)
+      end
+
+      def report_skipped(example)
+        super
+        puts "  " * @level + colorize(example.description + " (PENDING)", :yellow)
+      end
+    end
+  end
+end

data/lib/eksa-mination/formatters/html.rb

@@ -0,0 +1,147 @@
+require_relative 'base'
+
+module EksaMination
+  module Formatters
+    class HTML < Base
+      def summarize
+        report_file = "eksa-report.html"
+        File.open(report_file, "w") do |f|
+          f.puts html_header
+          f.puts "<body>"
+          f.puts dashboard_section
+          f.puts "<div class='container'>"
+          f.puts results_section
+          f.puts "</div>"
+          f.puts footer_section
+          f.puts "</body></html>"
+        end
+        puts "\nHTML report generated: #{colorize(report_file, :cyan)}"
+      end
+
+      private
+
+      def html_header
+        <<~HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <title>Eksa-Mination Test Report</title>
+            <style>
+              :root {
+                --bg: #0f172a;
+                --card-bg: #1e293b;
+                --text: #f1f5f9;
+                --success: #10b981;
+                --failure: #f43f5e;
+                --pending: #f59e0b;
+                --accent: #38bdf8;
+              }
+              body {
+                font-family: 'Inter', sans-serif;
+                background: var(--bg);
+                color: var(--text);
+                margin: 0;
+                padding: 0;
+              }
+              .dashboard {
+                background: linear-gradient(135deg, #1e293b 0%, #0f172a 100%);
+                padding: 40px 20px;
+                text-align: center;
+                border-bottom: 1px solid #334155;
+              }
+              .stats {
+                display: flex;
+                justify-content: center;
+                gap: 30px;
+                margin-top: 20px;
+              }
+              .stat-item {
+                background: var(--card-bg);
+                padding: 20px 40px;
+                border-radius: 12px;
+                box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+              }
+              .stat-value { font-size: 2em; font-weight: bold; }
+              .stat-label { font-size: 0.9em; color: #94a3b8; text-transform: uppercase; letter-spacing: 1px; }
+              
+              .container { max-width: 1000px; margin: 40px auto; padding: 0 20px; }
+              
+              .example-card {
+                background: var(--card-bg);
+                margin-bottom: 15px;
+                border-radius: 8px;
+                padding: 15px 20px;
+                border-left: 4px solid #334155;
+                transition: transform 0.2s;
+              }
+              .example-card:hover { transform: translateX(5px); }
+              .example-card.passed { border-left-color: var(--success); }
+              .example-card.failed { border-left-color: var(--failure); }
+              .example-card.pending { border-left-color: var(--pending); }
+              
+              .description { font-weight: 500; font-size: 1.1em; }
+              .location { font-family: monospace; font-size: 0.8em; color: #64748b; margin-top: 5px; }
+              .error-message {
+                background: #450a0a;
+                color: #fecaca;
+                padding: 15px;
+                border-radius: 6px;
+                margin-top: 10px;
+                font-family: monospace;
+                white-space: pre-wrap;
+                font-size: 0.9em;
+              }
+            </style>
+          </head>
+        HTML
+      end
+
+      def dashboard_section
+        <<~HTML
+          <div class="dashboard">
+            <h1>Eksa-Mination 1.0.0</h1>
+            <div class="stats">
+              <div class="stat-item">
+                <div class="stat-value" style="color: var(--accent)">#{@example_count}</div>
+                <div class="stat-label">Examples</div>
+              </div>
+              <div class="stat-item">
+                <div class="stat-value" style="color: var(--success)">#{@example_count - @failures.size - @skipped.size}</div>
+                <div class="stat-label">Passed</div>
+              </div>
+              <div class="stat-item">
+                <div class="stat-value" style="color: var(--failure)">#{@failures.size}</div>
+                <div class="stat-label">Failed</div>
+              </div>
+            </div>
+          </div>
+        HTML
+      end
+
+      def results_section
+        @results.map do |res|
+          example = res[:example]
+          status_class = res[:status].to_s
+          
+          error_html = ""
+          if res[:status] == :failed
+            error = res[:error]
+            error_html = "<div class='error-message'>#{error.message}\\n\\n#{error.backtrace.first(5).join("\\n")}</div>"
+          end
+
+          <<~HTML
+            <div class="example-card #{status_class}">
+              <div class="description">#{example.full_description}</div>
+              <div class="location">#{example.file_path}:#{example.line_number}</div>
+              #{error_html}
+            </div>
+          HTML
+        end.join("\n")
+      end
+
+      def footer_section
+        "<div style='text-align: center; color: #475569; margin: 40px 0;'>Generated by Eksa-Mination Testing Framework</div>"
+      end
+    end
+  end
+end

data/lib/eksa-mination/formatters/json.rb

@@ -0,0 +1,45 @@
+require 'json'
+require_relative 'base'
+
+module EksaMination
+  module Formatters
+    class JSONFormatter < Base
+      def report_success(example); super; end
+      def report_failure(example, error); super; end
+      def report_skipped(example); super; end
+
+      def summarize
+        data = {
+          version: EksaMination::VERSION,
+          summary: {
+            example_count: @example_count,
+            failure_count: @failures.size,
+            pending_count: @skipped.size
+          },
+          examples: @results.map do |res|
+            example = res[:example]
+            item = {
+              description: example.description,
+              full_description: example.full_description,
+              status: res[:status].to_s,
+              file_path: example.file_path,
+              line_number: example.line_number
+            }
+            
+            if res[:status] == :failed
+              error = res[:error]
+              item[:exception] = {
+                class: error.class.name,
+                message: error.message,
+                backtrace: error.backtrace
+              }
+            end
+            
+            item
+          end
+        }
+        puts JSON.pretty_generate(data)
+      end
+    end
+  end
+end

data/lib/eksa-mination/formatters/progress.rb

@@ -0,0 +1,22 @@
+require_relative 'base'
+
+module EksaMination
+  module Formatters
+    class Progress < Base
+      def report_success(example)
+        super
+        print colorize(".", :green)
+      end
+
+      def report_failure(example, error)
+        super
+        print colorize("F", :red)
+      end
+
+      def report_skipped(example)
+        super
+        print colorize("*", :yellow)
+      end
+    end
+  end
+end

data/lib/eksa-mination/matchers/be.rb

@@ -0,0 +1,11 @@
+module EksaMination
+  module Matchers
+    class BeMatcher
+      attr_reader :expected
+      def initialize(expected); @expected = expected; end
+      def matches?(actual); actual.equal?(@expected); end
+      def failure_message; "is not the same object as"; end
+      def negative_failure_message; "is the same object as"; end
+    end
+  end
+end

data/lib/eksa-mination/matchers/be_a.rb

@@ -0,0 +1,10 @@
+module EksaMination
+  module Matchers
+    class BeAMatcher
+      attr_reader :expected
+      def initialize(expected); @expected = expected; end
+      def matches?(actual); actual.is_a?(@expected); end
+      def failure_message; "is not a kind of"; end
+    end
+  end
+end

data/lib/eksa-mination/matchers/eq.rb

@@ -0,0 +1,11 @@
+module EksaMination
+  module Matchers
+    class EqMatcher
+      attr_reader :expected
+      def initialize(expected); @expected = expected; end
+      def matches?(actual); actual == @expected; end
+      def failure_message; "is not equal to"; end
+      def negative_failure_message; "is equal to"; end
+    end
+  end
+end

data/lib/eksa-mination/matchers/falsey.rb

@@ -0,0 +1,10 @@
+module EksaMination
+  module Matchers
+    class FalseyMatcher
+      def expected; "falsey"; end
+      def matches?(actual); !actual; end
+      def failure_message; "is not falsey"; end
+      def negative_failure_message; "is falsey"; end
+    end
+  end
+end

data/lib/eksa-mination/matchers/include.rb

@@ -0,0 +1,11 @@
+module EksaMination
+  module Matchers
+    class IncludeMatcher
+      attr_reader :expected
+      def initialize(expected); @expected = expected; end
+      def matches?(actual); actual.include?(@expected); end
+      def failure_message; "does not include"; end
+      def negative_failure_message; "includes"; end
+    end
+  end
+end

data/lib/eksa-mination/matchers/match.rb

@@ -0,0 +1,11 @@
+module EksaMination
+  module Matchers
+    class MatchMatcher
+      attr_reader :expected
+      def initialize(expected); @expected = expected; end
+      def matches?(actual); actual =~ @expected; end
+      def failure_message; "does not match pattern"; end
+      def negative_failure_message; "matches pattern"; end
+    end
+  end
+end

data/lib/eksa-mination/matchers/raise_error.rb

@@ -0,0 +1,35 @@
+module EksaMination
+  module Matchers
+    class RaiseErrorMatcher
+      attr_reader :expected, :expected_message
+
+      def initialize(error_class, expected_message)
+        @expected = error_class
+        @expected_message = expected_message
+        @actual_error = nil
+      end
+
+      def matches?(block)
+        return false unless block.respond_to?(:call)
+        begin
+          block.call
+          false
+        rescue @expected => e
+          @actual_error = e
+          @expected_message ? (e.message == @expected_message) : true
+        rescue => e
+          @actual_error = e
+          false
+        end
+      end
+
+      def failure_message
+        @actual_error ? "raised #{@actual_error.class} (#{@actual_error.message}) instead of #{@expected}" : "did not raise #{@expected}"
+      end
+
+      def negative_failure_message
+        "raised #{@expected}"
+      end
+    end
+  end
+end

data/lib/eksa-mination/matchers/respond_to.rb

@@ -0,0 +1,10 @@
+module EksaMination
+  module Matchers
+    class RespondToMatcher
+      attr_reader :expected
+      def initialize(expected); @expected = expected; end
+      def matches?(actual); actual.respond_to?(@expected); end
+      def failure_message; "does not respond to"; end
+    end
+  end
+end

data/lib/eksa-mination/matchers/truthy.rb

@@ -0,0 +1,10 @@
+module EksaMination
+  module Matchers
+    class TruthyMatcher
+      def expected; "truthy"; end
+      def matches?(actual); !!actual; end
+      def failure_message; "is not truthy"; end
+      def negative_failure_message; "is truthy"; end
+    end
+  end
+end

data/lib/eksa-mination/matchers.rb

@@ -0,0 +1,102 @@
+require_relative 'matchers/eq'
+require_relative 'matchers/be'
+require_relative 'matchers/match'
+require_relative 'matchers/include'
+require_relative 'matchers/raise_error'
+require_relative 'matchers/truthy'
+require_relative 'matchers/falsey'
+require_relative 'matchers/be_a'
+require_relative 'matchers/respond_to'
+
+module EksaMination
+  module Expectations
+    def expect(actual = nil, &block)
+      Expectation.new(actual || block)
+    end
+  end
+
+  class Expectation
+    def initialize(actual)
+      @actual = actual
+    end
+
+    def to(matcher)
+      # Some matchers (like raise_error) need the block itself
+      if matcher.matches?(@actual)
+        # Success
+      else
+        expected = matcher.respond_to?(:expected) ? matcher.expected : nil
+        raise MatchError.new(
+          "Expected: #{expected.inspect}\nActual:   #{@actual.inspect}",
+          matcher.failure_message,
+          expected,
+          @actual
+        )
+      end
+    end
+
+    def not_to(matcher)
+      if matcher.matches?(@actual)
+        raise MatchError.new("Expected: not to be #{matcher.expected.inspect}\nActual:   #{@actual.inspect}", matcher.negative_failure_message)
+      end
+    end
+  end
+
+  class MatchError < StandardError
+    attr_reader :detail, :failure_message, :expected, :actual
+
+    def initialize(detail, failure_message = nil, expected = nil, actual = nil)
+      @detail = detail
+      @failure_message = failure_message
+      @expected = expected
+      @actual = actual
+      super(detail)
+    end
+  end
+
+  module Matchers
+    def eq(expected)
+      EqMatcher.new(expected)
+    end
+
+    def be(expected)
+      BeMatcher.new(expected)
+    end
+
+    def match(regex)
+      MatchMatcher.new(regex)
+    end
+
+    def include(expected)
+      IncludeMatcher.new(expected)
+    end
+
+    def raise_error(error_class = StandardError, message = nil)
+      RaiseErrorMatcher.new(error_class, message)
+    end
+
+    def be_a(klass)
+      BeAMatcher.new(klass)
+    end
+
+    def respond_to(method)
+      RespondToMatcher.new(method)
+    end
+
+    def be_nil
+      be(nil)
+    end
+
+    def be_truthy
+      TruthyMatcher.new
+    end
+
+    def be_falsey
+      FalseyMatcher.new
+    end
+  end
+end
+
+# Global monkeypatch
+Object.include(EksaMination::Expectations)
+Object.include(EksaMination::Matchers)

data/lib/eksa-mination/mocks.rb

@@ -0,0 +1,137 @@
+module EksaMination
+  module Mocks
+    def allow(object)
+      Proxy.new(object)
+    end
+
+    def double(name = "Double")
+      Object.new.tap do |obj|
+        obj.define_singleton_method(:to_s) { name }
+        obj.define_singleton_method(:inspect) { "#<Double:#{name}>" }
+      end
+    end
+
+    def stub_const(const_name, value)
+      stub = ConstantStub.new(const_name, value)
+      stub.apply
+      EksaMination::Mocks.register_stub(stub)
+    end
+
+    def self.reset
+      @stubs ||= []
+      @stubs.each(&:restore)
+      @stubs = []
+    end
+
+    def self.register_stub(stub)
+      @stubs ||= []
+      @stubs << stub
+    end
+
+    class Proxy
+      def initialize(object)
+        @object = object
+      end
+
+      def to(matcher)
+        matcher.set_object(@object)
+        matcher
+      end
+    end
+
+    class ReceiveMatcher
+      def initialize(method_name)
+        @method_name = method_name
+        @return_value = nil
+        @object = nil
+      end
+
+      def set_object(object)
+        @object = object
+        apply_stub
+      end
+
+      def and_return(value)
+        @return_value = value
+        apply_stub if @object
+        self
+      end
+
+      private
+
+      def apply_stub
+        stub = Stub.new(@object, @method_name, @return_value)
+        stub.apply
+        EksaMination::Mocks.register_stub(stub)
+      end
+    end
+
+    class Stub
+      def initialize(object, method_name, return_value)
+        @object = object
+        @method_name = method_name
+        @return_value = return_value
+        @original_method = nil
+      end
+
+      def apply
+        @original_method = @object.method(@method_name) if @object.respond_to?(@method_name)
+        
+        return_val = @return_value
+        
+        @object.define_singleton_method(@method_name) do |*args, &block|
+          return_val
+        end
+      end
+
+      def restore
+        if @original_method
+          @object.define_singleton_method(@method_name, &@original_method)
+        else
+          @object.singleton_class.remove_method(@method_name) rescue nil
+        end
+      end
+    end
+
+    class ConstantStub
+      def initialize(name, value)
+        @name = name
+        @value = value
+        @original_value = nil
+        @defined = false
+      end
+
+      def apply
+        parts = @name.split('::')
+        @const_name = parts.pop
+        @parent = parts.empty? ? Object : Object.const_get(parts.join('::'))
+
+        if @parent.const_defined?(@const_name, false)
+          @original_value = @parent.const_get(@const_name, false)
+          @defined = true
+          @parent.send(:remove_const, @const_name)
+        end
+
+        @parent.const_set(@const_name, @value)
+      end
+
+      def restore
+        @parent.send(:remove_const, @const_name) rescue nil
+        @parent.const_set(@const_name, @original_value) if @defined
+      end
+    end
+  end
+
+  def self.reset_mocks
+    Mocks.reset
+  end
+end
+
+module EksaMination::Matchers
+  def receive(method_name)
+    EksaMination::Mocks::ReceiveMatcher.new(method_name)
+  end
+end
+
+# Global monkeypatch
+Object.include(EksaMination::Mocks)

data/lib/eksa-mination/runner.rb

@@ -0,0 +1,120 @@
+module EksaMination
+  class Runner
+    def initialize(groups, reporter, options = {})
+      @groups = groups
+      @reporter = reporter
+      @options = options
+    end
+
+    def run
+      @groups.each do |group|
+        run_group(group)
+      end
+      @reporter.summarize
+    end
+
+    private
+
+    def run_group(group)
+      @reporter.group_started(group)
+      begin
+        group.examples.each do |example|
+          if example.is_a?(ExampleGroup)
+            run_group(example) # Recursive for nested groups
+          elsif group.skipped || example.skipped
+            @reporter.report_skipped(example)
+          else
+            next unless should_run?(example)
+            run_example(group, example)
+          end
+        end
+      ensure
+        @reporter.group_finished(group)
+      end
+    end
+
+    def should_run?(example)
+      # Match tag filter if provided
+      if @options[:tag]
+        tag_key = @options[:tag].to_sym
+        return false unless example.metadata[tag_key]
+      end
+
+      # Match name filter if provided
+      if @options[:example]
+        return false unless example.full_description.include?(@options[:example])
+      end
+
+      # Match line number filter if provided for this file
+      if @options[:line_numbers] && @options[:line_numbers][example.file_path]
+        return false unless @options[:line_numbers][example.file_path].include?(example.line_number)
+      end
+
+      true
+    end
+
+    def run_example(group, example)
+      # Create an instance to run the hooks and example in
+      context = Object.new
+      context.extend(EksaMination::Expectations)
+      context.extend(EksaMination::Matchers)
+      context.extend(EksaMination::Mocks)
+
+      # Collect all let/subject/hooks from hierarchy
+      hierarchy = []
+      current = group
+      while current
+        hierarchy.unshift(current)
+        current = current.parent
+      end
+
+      # Handle let, let!, and subject
+      cache = {}
+      
+      hierarchy.each do |g|
+        # Define let methods from this group
+        g.let_blocks.each do |name, block|
+          context.define_singleton_method(name) do
+            cache[name] ||= context.instance_eval(&block)
+          end
+        end
+
+        # Define let! methods from this group (eagerly evaluated)
+        g.let_bang_blocks.each do |name, block|
+          context.define_singleton_method(name) do
+            cache[name] ||= context.instance_eval(&block)
+          end
+          # Trigger early
+          context.send(name)
+        end
+
+        # Define subject if present in this group
+        if g.subject_block
+          context.define_singleton_method(:subject) do
+            cache[:subject] ||= context.instance_eval(&g.subject_block)
+          end
+        end
+      end
+
+      begin
+        # Run before hooks from outside-in
+        hierarchy.each do |g|
+          g.before_hooks.each { |hook| context.instance_eval(&hook) }
+        end
+        
+        # Execute the test
+        context.instance_eval(&example.block)
+        @reporter.report_success(example)
+      rescue => e
+        @reporter.report_failure(example, e)
+      ensure
+        # Run after hooks from inside-out
+        hierarchy.reverse_each do |g|
+          g.after_hooks.each { |hook| context.instance_eval(&hook) }
+        end
+        # Cleanup stubs if we had any
+        EksaMination.reset_mocks if EksaMination.respond_to?(:reset_mocks)
+      end
+    end
+  end
+end

data/lib/eksa-mination.rb

@@ -0,0 +1,23 @@
+require_relative 'eksa-mination/dsl'
+require_relative 'eksa-mination/matchers'
+require_relative 'eksa-mination/formatters/progress'
+require_relative 'eksa-mination/formatters/documentation'
+require_relative 'eksa-mination/formatters/json'
+require_relative 'eksa-mination/formatters/html'
+require_relative 'eksa-mination/runner'
+require_relative 'eksa-mination/mocks'
+require_relative 'eksa-mination/cli'
+
+module EksaMination
+  VERSION = "1.0.0"
+
+  class << self
+    attr_accessor :reporter
+  end
+
+  self.reporter = Formatters::Progress.new
+
+  def self.run(options = {})
+    Runner.new(groups, reporter, options).run
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: eksa-mination
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- IshikawaUta
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Eksa-Mination provides a familiar DSL, comprehensive mocking/stubbing,
+  and rich reporting tools in a lightweight package.
+email:
+- komikers09@gmail.com
+executables:
+- eksa-mination
+extensions: []
+extra_rdoc_files: []
+files:
+- ".eksa-mination"
+- LICENSE
+- README.md
+- bin/eksa-mination
+- lib/calculator.rb
+- lib/eksa-mination.rb
+- lib/eksa-mination/cli.rb
+- lib/eksa-mination/dsl.rb
+- lib/eksa-mination/formatters/base.rb
+- lib/eksa-mination/formatters/documentation.rb
+- lib/eksa-mination/formatters/html.rb
+- lib/eksa-mination/formatters/json.rb
+- lib/eksa-mination/formatters/progress.rb
+- lib/eksa-mination/matchers.rb
+- lib/eksa-mination/matchers/be.rb
+- lib/eksa-mination/matchers/be_a.rb
+- lib/eksa-mination/matchers/eq.rb
+- lib/eksa-mination/matchers/falsey.rb
+- lib/eksa-mination/matchers/include.rb
+- lib/eksa-mination/matchers/match.rb
+- lib/eksa-mination/matchers/raise_error.rb
+- lib/eksa-mination/matchers/respond_to.rb
+- lib/eksa-mination/matchers/truthy.rb
+- lib/eksa-mination/mocks.rb
+- lib/eksa-mination/runner.rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A robust and lightweight Ruby testing framework inspired by RSpec.
+test_files: []