exhaustive_case 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1b92a48ea165ce23641008c4d72179fd6da4c7c31d02c7ba36424ec9a943d22
-  data.tar.gz: e16ff9171f2572d832b6868639b4b9d9b2b17c6315b117ad9ca2132cdfeed7f6
+  metadata.gz: 432d6c2b8f4efcd0eacd5b70b49851a73c6e9f5ba46ef7b5ae8c1f56ac542d4d
+  data.tar.gz: 6ecfe98e2467fa36012721d1d637a19e454c97e929eff39056502125343a8597
 SHA512:
-  metadata.gz: a9a8894a657c585bca18b9682e76dc68be60ba194fdbc260ff8aca9b9e7a1de2f00f5ba88782a9aac18ada65b589fb0324d676b85eefa72286879e15b6c4ded0
-  data.tar.gz: b4b38e8823633e5fb6f143d2b975ccbc927988cceee3df92d82b23fa1a37c6e7d8d45665bd48bcfa79cc9f4fd3590462c3df53c938d82fc804b560202a66dcd4
+  metadata.gz: 2338d003b512ecf30157dc6f5a5c773e6f5a94ef12100a61af12ae47405465fbdd9c3306709a68307d08d31b3a54e3a3c9ac037304d71348385a09b804003924
+  data.tar.gz: f18a5b6ddf5b400c2d5bdb6e0554abe7d1c17e4b681c445299f09eee1f49cc52631488f5e7f99a152e7512a628908711c00523d8b5af3be22c5d413756348324

data/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.1] - 2025-08-03
+
+### Added
+- `DuplicateCaseError` - raised when the same case value is declared more than once
+- Duplicate case detection prevents declaring the same value across multiple `on` clauses
+- Comprehensive test coverage for duplicate case scenarios
+- Documentation for `DuplicateCaseError` in README with examples
+
+### Technical
+- Enhanced case validation with duplicate detection logic
+- Maintained 100% test coverage with new duplicate case test suite
+
 ## [1.0.0] - 2025-08-02
 
 ### Added
@@ -37,6 +49,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - RuboCop linting configuration
 - Development scripts (`bin/setup`, `bin/console`)
 
-[Unreleased]: https://github.com/yourusername/exhaustive_case/compare/v1.0.0...HEAD
+[Unreleased]: https://github.com/yourusername/exhaustive_case/compare/v1.0.1...HEAD
+[1.0.1]: https://github.com/yourusername/exhaustive_case/releases/tag/v1.0.1
 [1.0.0]: https://github.com/yourusername/exhaustive_case/releases/tag/v1.0.0
 [0.1.0]: https://github.com/yourusername/exhaustive_case/releases/tag/v0.1.0

data/README.md

@@ -1,9 +1,36 @@
 # Exclusive Case
 
+Exhaustive case statements for Ruby to prevent bugs from unhandled cases when enumerated values are added to or removed a system.
+
 [![Gem Version](https://badge.fury.io/rb/exhaustive_case.svg)](https://badge.fury.io/rb/exhaustive_case)
 [![CI](https://github.com/ajsharma/exhaustive_case/actions/workflows/ci.yml/badge.svg)](https://github.com/ajsharma/exhaustive_case/actions/workflows/ci.yml)
 
-Exhaustive case statements for Ruby to prevent bugs from unhandled cases when new values are added to a system.
+
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Installation](#installation)
+- [Usage](#usage)
+- [The Problem](#the-problem)
+- [The Solution](#the-solution)
+- [Enhanced Validation with `of:` Parameter](#enhanced-validation-with-of-parameter)
+- [Error Handling](#error-handling)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Quick Start
+
+```ruby
+require 'exhaustive_case'
+include ExhaustiveCase
+
+# Simple exhaustive case - will raise error if user_status doesn't match any case
+result = exhaustive_case user_status do
+  on(:active) { "User is active" }
+  on(:inactive) { "User is inactive" }
+  on(:pending) { "User is pending approval" }
+end
+```
 
 ## Installation
 
@@ -25,6 +52,10 @@ Or install it yourself as:
 $ gem install exhaustive_case
 ```
 
+## Requirements
+
+- Ruby 2.7 or higher
+
 ## Usage
 
 Include the module to get access to the `exhaustive_case` method:
@@ -60,7 +91,7 @@ class UserRenderer
 end
 ```
 
-## The problem
+## The Problem
 
 If/else statements can easily lead to mistake flows when introducing new cases across the systems.
 
@@ -68,11 +99,11 @@ For instance, with a constant set of inputs `['A', 'B', 'C']`:
 
 ```ruby
 if letter == 'A'
-  // handle a
+  # handle a
 elsif letter == 'B'
-  // handle b
-else // implicit c
-  // handle c 
+  # handle b
+else # implicit c
+  # handle c 
 end
 ```
 
@@ -80,11 +111,11 @@ However, if a new entry `D` is introduced to the system, now:
 
 ```ruby
 if letter == 'A'
-  // code to handle a (whoops!)
+  # code to handle a (whoops!)
 elsif letter == 'B'
-  // code to handle b (whoops!)
-else // implicit c and d
-  // code to handle c  (whoops!)
+  # code to handle b (whoops!)
+else # implicit c and d
+  # code to handle c  (whoops!)
 end
 ```
 
@@ -94,11 +125,11 @@ We can address this with a more explicit initial switch:
 
 ```ruby
 if letter == 'A'
-  // handle a
+  # handle a
 elsif letter == 'B'
-  // handle b
+  # handle b
 elsif letter == 'C'
-  // handle c
+  # handle c
 else 
   raise "Unknown letter #{letter}"
 end
@@ -111,11 +142,11 @@ Note: for these examples, we're using an if/elsif/else chain, but the same conce
 ```ruby
 case letter
 when 'A'
-  // handle a
+  # handle a
 when 'B'
-  // handle b
+  # handle b
 when 'C'
-  // handle c
+  # handle c
 else 
   raise "Unknown letter #{letter}"
 end
@@ -126,7 +157,7 @@ This new syntax is better, but leaves some gaps:
 1. Engineers taught to use the class `if/else` structure constantly introduce these problems.
 2. The final raise statement is often "impossible" to access via testing, it's nature preventing access without mocking (especially when these types of clauses are part of private functions).
 
-## The solution
+## The Solution
 
 But what if had a new type of case statement that could both ensure that all cases are correctly implemented and provide feedback if a new case has been introduced but not implemented?
 
@@ -134,9 +165,9 @@ Enter exhaustive case:
 
 ```ruby
 exhaustive_case letter do 
-  on('A') { // handle A }
-  on('B') { // handle B }
-  on('C') { // handle C }
+  on('A') { # handle A }
+  on('B') { # handle B }
+  on('C') { # handle C }
 end
 ```
 
@@ -147,8 +178,8 @@ with the new syntax, `exhaustive_case` handles the final else statement and rais
 
 ```ruby
 exhaustive_case letter do 
-  on('A') { // handle A }
-  on('B', 'C') { // handle B or C }
+  on('A') { # handle A }
+  on('B', 'C') { # handle B or C }
 end
 ```
 
@@ -168,9 +199,9 @@ For even stronger guarantees, you can specify the complete list of acceptable in
 VALID_LETTERS = ['A', 'B', 'C'].freeze
 
 exhaustive_case letter, of: VALID_LETTERS do 
-  on('A') { // handle A }
-  on('B') { // handle B }
-  on('C') { // handle C }
+  on('A') { # handle A }
+  on('B') { # handle B }
+  on('C') { # handle C }
 end
 ```
 
@@ -208,9 +239,52 @@ if a new status is added to `STATUSES` a test suite should reveal that a case is
 
 The following are the expected errors when using the gem:
 
-- **`UnhandledCaseError`** - Raised when the input value doesn't match any `on` clause
-- **`InvalidCaseError`** - Raised when using `of:` and an `on` clause contains a value not in the allowed list
-- **`MissingCaseError`** - Raised when using `of:` and not all allowed values have corresponding `on` clauses
+### `UnhandledCaseError`
+Raised when the input value doesn't match any `on` clause:
+```ruby
+exhaustive_case :unknown_status do
+  on(:active) { "active" }
+  on(:inactive) { "inactive" }
+end
+# => ExhaustiveCase::UnhandledCaseError: No case matched for value: :unknown_status
+```
+
+### `InvalidCaseError` 
+Raised when using `of:` and an `on` clause contains a value not in the allowed list:
+```ruby
+exhaustive_case status, of: [:active, :inactive] do
+  on(:active) { "active" }
+  on(:pending) { "pending" }  # :pending not in allowed list
+end
+# => ExhaustiveCase::InvalidCaseError: Case :pending is not in the allowed list: [:active, :inactive]
+```
+
+### `MissingCaseError`
+Raised when using `of:` and not all allowed values have corresponding `on` clauses:
+```ruby
+exhaustive_case status, of: [:active, :inactive, :pending] do
+  on(:active) { "active" }
+  # Missing :inactive and :pending cases
+end
+# => ExhaustiveCase::MissingCaseError: Missing cases for: [:inactive, :pending]
+```
+
+### `DuplicateCaseError`
+Raised when the same case value is declared more than once:
+```ruby
+exhaustive_case status do
+  on(:active) { "first active" }
+  on(:active) { "second active" }  # Duplicate case
+end
+# => ExhaustiveCase::DuplicateCaseError: Duplicate case(s): :active. Each case value can only be declared once.
+
+# Also applies when values appear across multiple on clauses
+exhaustive_case status do
+  on(:active, :pending) { "first group" }
+  on(:pending, :inactive) { "second group" }  # :pending is duplicated
+end
+# => ExhaustiveCase::DuplicateCaseError: Duplicate case(s): :pending. Each case value can only be declared once.
+```
 
 ## Contributing
 

data/lib/exhaustive_case/case_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module ExhaustiveCase
   # CaseBuilder handles the construction and execution of exhaustive case statements.
   # It validates cases against an optional 'of' list and ensures all required cases are handled.
@@ -11,15 +13,20 @@ module ExhaustiveCase
       @of = of
       @cases = []
       @matched = false
+      @declared_matchers = Set.new
     end
 
     def on(*matchers, &block)
-      validate_matchers(matchers) if @of
+      ensure_only_of_matchers(matchers) if @of
+      ensure_unique_matchers(matchers)
       @cases << { matchers: matchers, block: block }
     end
 
     def execute
-      validate_completeness if @of
+      # Important! Make sure this is run before executing a matcher, we need to validate
+      # that the case structure is complete so we don't execute branches for an invalid
+      # exhaustive case
+      ensure_completeness if @of
 
       @cases.each do |case_def|
         if case_def[:matchers].any? { |matcher| matcher == @value }
@@ -33,7 +40,7 @@ module ExhaustiveCase
 
     private
 
-    def validate_matchers(matchers)
+    def ensure_only_of_matchers(matchers)
       invalid_matchers = matchers.reject { |matcher| @of.include?(matcher) }
       return if invalid_matchers.empty?
 
@@ -41,7 +48,18 @@ module ExhaustiveCase
                               "Must be one of: #{@of.map(&:inspect).join(", ")}"
     end
 
-    def validate_completeness
+    def ensure_unique_matchers(matchers)
+      duplicate_matchers = matchers.select { |matcher| @declared_matchers.include?(matcher) }
+
+      unless duplicate_matchers.empty?
+        raise DuplicateCaseError, "Duplicate case(s): #{duplicate_matchers.map(&:inspect).join(", ")}. " \
+                                  "Each case value can only be declared once."
+      end
+
+      @declared_matchers.merge(matchers)
+    end
+
+    def ensure_completeness
       declared_cases = @cases.flat_map { |case_def| case_def[:matchers] }.uniq
       missing_cases = @of - declared_cases
       return if missing_cases.empty?

data/lib/exhaustive_case/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ExhaustiveCase
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/lib/exhaustive_case.rb

@@ -35,6 +35,9 @@ module ExhaustiveCase
   # implemented
   class MissingCaseError < Error; end
 
+  # Indicates that a case value was declared more than once
+  class DuplicateCaseError < Error; end
+
   def exhaustive_case(value, of: nil, &block)
     builder = CaseBuilder.new(value, of)
     builder.instance_eval(&block)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exhaustive_case
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Ajay Sharma