service_core 0.1.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01d926ff29ac3ea5c0ecb4f7a754ea6531732cfe8bfe33591f17a0827132fd21
-  data.tar.gz: b79448edd6a9a4900430f246b0410362782d197a0b9318add7e6f7d63d71df1b
+  metadata.gz: d9e82b7404a555e1d2b60d559e82b3f37a2cfe829ad947687f5e290252b87712
+  data.tar.gz: a170ee5ab04fe57be88786b027b07ca1db31732fa316eafb0a36b10c827c078c
 SHA512:
-  metadata.gz: b192d8ca5f4439ca1d178697c70ed5ed1e288108c23c72b1aafa8ac1e7a17124f97c6b8f95978615f62e0f58e536c1a1f48cddc6b3e6ab39e5402f314ad3fa36
-  data.tar.gz: b855792ae11ac1a308004437e01374daac234ae4588416dc936eb2d5ac9cf973b03c2435a48d515e3a577cc29016dcbcdd88939d4c4b43d6d98b7b2f0cdd1109
+  metadata.gz: 2a109447da13844396e83db86186849598c0ad4b55b845d07fb6c8c1592aa7a10dc69b135cd84785b407588580871470bf94132158e60c2b237b7a05fdd099ff
+  data.tar.gz: b2a495f969e193f7f6a9403c32fd88cf7586f49150268d61bbb600ea565ed039107aa1edc119cf8c5ebc37614f303a10471230292294c420930d3f19241c6539

data/.rubocop.yml

@@ -1,10 +1,25 @@
+plugins:
+  - rubocop-rake
+
+require:
+  - rubocop-rspec
+
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
+  Exclude:
+    - "gemfiles/**/*"
+    - "vendor/**/*"
 
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: double_quotes
 
+# Per project style, frozen_string_literal magic comments are not used.
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
 Style/StringLiteralsInInterpolation:
   Enabled: true
   EnforcedStyle: double_quotes
@@ -16,4 +31,22 @@ Style/Documentation:
   Enabled: false
 
 Metrics/BlockLength:
-  Enabled: false
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MessageSpies:
+  Enabled: false
+
+RSpec/VerifiedDoubleReference:
+  Enabled: false
+
+# add_error_and_validate is part of the public API and intentionally returns
+# the boolean result of valid?, but its name describes the action it performs.
+Naming/PredicateMethod:
+  AllowedMethods:
+    - add_error_and_validate

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.4.9

data/Appraisals

@@ -0,0 +1,19 @@
+# Each appraisal pins ActiveModel/ActiveSupport to a maintained Rails release.
+# Older Rails versions (6.1, 7.0, 7.1) are still permitted by the gemspec
+# floor but are not exercised here because their upstream support window
+# has ended.
+
+appraise "rails-7.2" do
+  gem("activemodel", "~> 7.2.0")
+  gem("activesupport", "~> 7.2.0")
+end
+
+appraise "rails-8.0" do
+  gem("activemodel", "~> 8.0.0")
+  gem("activesupport", "~> 8.0.0")
+end
+
+appraise "rails-8.1" do
+  gem("activemodel", "~> 8.1.0")
+  gem("activesupport", "~> 8.1.0")
+end

data/CHANGELOG.md

@@ -1,5 +1,83 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
 ## [Unreleased]
 
+## [1.0.0] - 2026-05-14
+
+### Added
+
+- `ServiceCore::Response`: a Hash-compatible value object backing
+  `service.response` / `service.output` and the return of `#call`. Adds
+  named accessors (`response.status`, `response.data`, `response.message`,
+  `response.errors`), Hash-style `[]` / `[]=` / `==`, `dig`, `fetch`,
+  `each_pair`, and `as_json` / `to_json`. Callers that previously
+  reached for `service.output[:key]` on the 0.1.0 Hash output continue
+  to work unchanged.
+- `service.response` as an alias for `service.output`.
+- `ServiceCore::FieldSet`: an immutable snapshot for `service.fields`.
+  Each declared symbol field is exposed as a real method (e.g.
+  `service.fields.first_name`); call `to_h` for a plain Hash.
+- `field` raises `ServiceCore::ReservedFieldName` when the declared name
+  would shadow a ServiceCore method. The reserved names are `:call`,
+  `:errors`, `:fields`, `:output`, `:perform` and `:response`. Previously
+  these names silently overrode gem internals (most dangerously
+  `:errors`, which broke `ActiveModel::Validations`).
+- `ServiceCore::Error` hierarchy with concrete subclasses
+  `ServiceCore::InvalidKey` (raised by `Response#[]` / `[]=` on a
+  non-allowed key) and `ServiceCore::ReservedFieldName`. `Error` itself
+  existed since 0.1.0 but was never raised; `rescue ServiceCore::Error`
+  now actually catches things.
+- Cross-Rails test matrix via `appraisal`: Rails 7.2, 8.0 and 8.1.
+- CI matrix across Ruby 3.3, 3.4 and 4.0 (excluding Ruby 4.0 + Rails 7.2).
+
+### Changed
+
+- The mixin that provides `success_response`, `error_response` and
+  `formatted_response` is renamed from `ServiceCore::Response` to
+  `ServiceCore::Responder`. The `Response` name now refers to the value
+  object; the `Responder` mixin is the builder. Both modules are internal
+  implementation details consumed via `include ServiceCore`, so users
+  who only ever `include ServiceCore` are unaffected. Anyone including
+  `ServiceCore::Response` directly must switch to
+  `include ServiceCore::Responder`.
+- Gemspec: `required_ruby_version` raised to `>= 3.1.0` (Ruby 2.7 and 3.0 are EOL).
+- Gemspec: ActiveModel / ActiveSupport range widened to `>= 6.1, < 9.0`.
+- RuboCop bumped to `~> 1.86` with `rubocop-rake` added as a plugin.
+- Replaced `byebug` (unmaintained on Ruby 3+) with the stdlib `debug` gem.
+- Removed `# frozen_string_literal: true` magic comments project-wide in
+  favour of the project style; `VERSION` is now explicitly `.freeze`d.
+- `add_error_and_validate` now forwards its `options` argument to
+  `add_error` (and through to `ActiveModel::Errors#add`), matching its
+  declared signature.
+- Internal cleanups: `Output#initialize` now calls `super()`, the
+  `StepValidation` validator helpers are private, and `auto_assign_status`
+  no longer has the redundant elsif clauses.
+- The class-level `fields_defined` registry is renamed to `field_names`
+  and is now a `Set` of declared names rather than a Hash mapping names
+  to defaults. Typed defaults are still applied through
+  `ActiveModel::Attributes`; the old Hash was a Set with a confusing
+  name and shape.
+- `service.fields` no longer behaves like a Hash. The new `FieldSet`
+  exposes named accessors plus `to_h`. Callers that did
+  `service.fields[:name]` should use `service.fields.name`; iteration
+  goes through `service.fields.to_h.each`.
+
+### Fixed
+
+- `Output#set_output` no longer drops legitimate falsy values. Previously
+  `false`, `0`, and `""` were silently discarded; only `nil` is now skipped.
+- `Responder#formatted_response` no longer gates its writes on
+  ActiveSupport `present?`. `success_response(data: false)` now records
+  `data: false`.
+- `Base.field` no longer swallows positional defaults of `false` or `nil`.
+  The arity of the positional arguments is used instead of `||`, so
+  `field :enabled, :boolean, false` actually defaults to `false`.
+
 ## [0.1.0] - 2024-07-17
 
-- Initial release
+- Initial release.

data/README.md

@@ -1,27 +1,50 @@
 # ServiceCore
 
-ServiceCore provides a standardized way to define and use service objects in your Ruby and Rails applications. It includes support for defining fields, validations, responses, and logging.
+ServiceCore is a small Ruby gem that gives service objects a shared shape. Every service exposes a single `call` method and returns the same four-key response, regardless of who wrote it. The idea behind the shape is unpacked in [The Shape of a Service Response](https://agnosticlogic.substack.com/p/the-shape-of-a-service-response).
+
+- Four-key response contract: **status**, **data**, **message**, **errors**.
+- Field declarations with types, defaults, and ActiveModel validations.
+- Step-by-step validation that survives `valid?` calls.
+- Hash-compatible value objects (`Response`, `FieldSet`) instead of raw hashes.
+- Works on Ruby >= 3.1 and Rails (ActiveModel/ActiveSupport) 6.1 through 8.x.
 
 ## Installation
-Install the gem and add to the application's Gemfile by executing:
 
 ```sh
 bundle add service_core
 ```
-If bundler is not being used to manage dependencies, install the gem by executing:
+
+Or add it to your Gemfile:
+
+```ruby
+gem "service_core"
+```
+
+If you are not using Bundler:
 
 ```sh
 gem install service_core
 ```
-## Usage
 
-### Defining a Service
+## The four-key response
 
-To define a new service, include the `ServiceCore` module in your service class and define your fields and the perform method.
-```ruby
-# app/services/my_service.rb
+Every service responds with at most four keys:
 
-class MyService
+| Key       | Purpose                                                                |
+| --------- | ---------------------------------------------------------------------- |
+| `status`  | Machine-readable signal (`"success"`, `"error"`, or any custom state). |
+| `data`    | The payload the caller asked for.                                      |
+| `message` | High-level human context, distinct from per-field error detail.        |
+| `errors`  | Structured error detail (Hash, Array, ActiveModel::Errors, ...).       |
+
+The shape is enforced; the value types are not. Writing a key other than these four raises `ServiceCore::InvalidKey`.
+
+## Defining a service
+
+Include `ServiceCore` in your class and implement `perform`:
+
+```ruby
+class GreetService
   include ServiceCore
 
   field :first_name, :string
@@ -29,39 +52,137 @@ class MyService
   field :active, :boolean, default: true
 
   def perform
-    success_response(message: "Hello, World", data: name)
+    success_response(message: "Hello, World", data: full_name)
   end
 
-  def name
+  private
+
+  def full_name
     "#{first_name} #{last_name}"
   end
 end
 ```
 
-### Using a Service
-Instantiate and call the service to execute it. The call method will validate the input, perform the operation, and return the output.
+## Calling a service
+
+You can call a service either via `new(...).call` or via the `.call` shortcut on the class:
+
+```ruby
+response = GreetService.new(first_name: "John", last_name: "Doe").call
+puts response
+# => {status: "success", message: "Hello, World", data: "John Doe"}
+
+service = GreetService.call(first_name: "John", last_name: "Doe")
+service.response
+# => {status: "success", message: "Hello, World", data: "John Doe"}
+```
+
+The instance method returns the response value object. The class-level `.call` returns the service instance, so you can also reach for `service.response` (or `service.output`, which is kept as an alias) after the fact.
+
+## `Response`: the value object
+
+`service.response` (and the value returned from `#call`) is a `ServiceCore::Response`. It exposes both named accessors and Hash-style access, and serialises to JSON like the underlying hash:
+
+```ruby
+response = GreetService.call(first_name: "John", last_name: "Doe").response
+
+response.status   # => "success"
+response.data     # => "John Doe"
+response[:status] # => "success"
+response == { status: "success", message: "Hello, World", data: "John Doe" } # => true
+response.to_json  # => '{"status":"success","message":"Hello, World","data":"John Doe"}'
+```
+
+Writing or reading a key other than the four allowed raises `ServiceCore::InvalidKey`.
+
+## Declaring fields
+
+`field` supports both typed and untyped declarations.
+
+```ruby
+class MyService
+  include ServiceCore
+
+  field :first_name, :string                  # typed (ActiveModel::Attributes)
+  field :active, :boolean, default: true      # typed with keyword default
+  field :enabled, :boolean, false             # typed with positional default
+  field :payload                              # untyped, can be any object/hash/array
+end
+```
+
+Typed fields are backed by `ActiveModel::Attributes` and inherit its casting and default support.
+
+The following names are reserved and cannot be used as field names because they would shadow methods the gem itself defines: `:call`, `:errors`, `:fields`, `:output`, `:perform`, `:response`. Declaring `field :errors` (for example) raises `ServiceCore::ReservedFieldName`.
+
+### Field snapshot via `FieldSet`
+
+After construction, `service.fields` exposes an immutable snapshot of the declared fields and their values as a `ServiceCore::FieldSet`. Each declared symbol field is available as a real method; call `to_h` if you need a plain Hash.
+
+```ruby
+service = GreetService.new(first_name: "John", last_name: "Doe")
+
+service.fields.first_name   # => "John"
+service.fields.to_h         # => { first_name: "John", last_name: "Doe", active: true }
+```
+
+The snapshot is taken at `#initialize`, so it reflects the values at construction time. Live values are still available through each declared accessor (e.g. `service.first_name`).
+
+## Building responses
+
+Three helpers cover almost every case.
+
+### `success_response`
+
+```ruby
+def perform
+  success_response(message: "Hello, World", data: full_name)
+end
+# => {status: "success", message: "Hello, World", data: "John Doe"}
+```
+
+Accepts `message` and `data`. Status is set to `"success"`.
+
+### `error_response`
+
+```ruby
+def perform
+  error_response(message: "validation failure", errors: "last_name can't be blank")
+end
+# => {status: "error", message: "validation failure", errors: "last_name can't be blank"}
+```
+
+Accepts `message` and `errors`. Status is set to `"error"`. `errors` can be a String, Hash, Array, or `ActiveModel::Errors` (which is normalised through `messages`).
+
+### `formatted_response`
+
+For any status that isn't success or error.
+
+```ruby
+def perform
+  formatted_response(status: "processed", message: "Already done", data: existing_record)
+end
+# => {status: "processed", message: "Already done", data: ...}
+```
+
+Accepts `status`, `message`, `data`, and `errors`. Use this for `"pending"`, `"queued"`, `"processed"`, or any domain-specific status.
+
+### `set_output`
+
+For finer-grained control, write a single key at a time:
+
 ```ruby
-service = MyService.new(first_name: "John", last_name: "Doe")
-result = service.call
-puts result
-# Output:
-# {
-#   status: "success",
-#   message: "Hello, World",
-#.  data: "John Doe"
-# }
-
-puts service.output
-# Output:
-# {
-#   status: "success",
-#   message: "Hello, World",
-#.  data: "John Doe"
-# }
-```
-
-### Validations
-You can define validation on the service and  those will be invoked before service logic is invoked
+def perform
+  set_output(:message, "Hello, World")
+  set_output(:data, full_name)
+end
+```
+
+If `status` is not set explicitly, it is auto-assigned to `"success"` when `errors` is blank, and `"error"` otherwise. `nil` is the only value treated as "not set"; `false`, `0`, and `""` are stored as-is.
+
+## Validations
+
+Standard ActiveModel validations run before `perform`. If they fail, the response is filled in for you.
+
 ```ruby
 class MyService
   include ServiceCore
@@ -74,51 +195,43 @@ class MyService
   end
 end
 
-service = MyService.new(name: "")
-result = service.call
-puts result
-# Output:
-#{
-#   status: "error",
-#   message: "validation failure",
-#   errors: { name: ["can't be blank"] }
-# }
+MyService.new(name: "").call
+# => {status: "error", message: "validation failure", errors: {name: ["can't be blank"]}}
 ```
 
-### Step Validation
-You can perform validation at each step of service logic. This is helpful when result of previous step decides next logic.
+### Step validation
+
+When the result of one step decides the next, `add_error_and_validate` lets you accumulate errors mid-`perform` without `valid?` wiping them.
+
 ```ruby
 class MyService
   include ServiceCore
-  
+
   field :first_name, :string
   field :last_name, :string
-  field :user
 
   validates :first_name, presence: true
-  validates :user, presence: true
 
   def perform
     if last_name.blank?
       add_error_and_validate(:last_name, "can't be nil")
       return error_response(message: "validation failure", errors: errors)
     end
-    
-   success_response(data: { user: { id: 1 } })
+
+    success_response(data: { user: { id: 1 } })
   end
 end
 
-MyService.call(first_name: 'abc')
-# output:
-# {
-#   status: "error",
-#   message: "validation failure",
-#   errors: { last_name: ["can't be nil"] }
-# }
+MyService.call(first_name: "abc").response
+# => {status: "error", message: "validation failure", errors: {last_name: ["can't be nil"]}}
 ```
 
-### Logging Errors
-You can log errors using the `log_error` method.
+`add_error_and_validate(attribute, message, options = {})` forwards `options` to `ActiveModel::Errors#add`, so options like `strict: true` are honoured.
+
+## Logging errors
+
+`log_error(exception)` writes through the configured `ServiceCore.logger` and tags the message with the service class name.
+
 ```ruby
 class MyService
   include ServiceCore
@@ -126,80 +239,83 @@ class MyService
   field :name, :string
 
   def perform
-    begin
-      raise StandardError, "Something went wrong"
-    rescue StandardError => e
-      log_error(e)
-      error_response(message: "Failed", errors: { base: [e.message] })
-    end
+    raise StandardError, "Something went wrong"
+  rescue StandardError => e
+    log_error(e)
+    error_response(message: "Failed", errors: { base: [e.message] })
   end
 end
+```
+
+## Exceptions
 
-service = MyService.new(name: "World")
-result = service.call
-puts result
-# Output:
-# {
-#   status: "error",
-#   message: "Failed",
-#   errors: { base: ["Something went wrong"] }
-# }
+All gem-specific exceptions inherit from `ServiceCore::Error`, so a single rescue block can catch anything ServiceCore raises:
 
+```ruby
+begin
+  MyService.call(...)
+rescue ServiceCore::Error => e
+  # any gem-raised error
+end
 ```
 
-### Configuring the Logger
-You can configure the logger for the ServiceCore module.
+The current concrete subclasses are:
+
+- `ServiceCore::InvalidKey` — raised by `response[:not_allowed]` or `response[:not_allowed] = value` when the key is not one of the four allowed response keys.
+- `ServiceCore::ReservedFieldName` — raised by `field :errors` (or any other reserved name) at class-definition time.
+
+Two raises stay on stdlib classes: `Response#fetch` raises `KeyError` to match `Hash#fetch`, and the default `perform` raises `StandardError` until the service overrides it.
+
+## Configuration
+
 ```ruby
 ServiceCore.configure do |config|
-  config.logger = Logger.new(STDOUT)
+  config.logger = Logger.new($stdout)
 end
 ```
 
-### Custom Response
-use `formatted_response` method to return any other status other than `success` or `error`
-```ruby
+If you do not configure a logger, `ServiceCore.logger` defaults to `Rails.logger` when available, and otherwise to an `ActiveSupport::Logger` writing to `$stdout`.
 
-class MyService
-  include ServiceCore
+## Stability
 
-  field :first_name, :string
-  field :last_name, :string
-  field :active, :boolean, default: true
+ServiceCore follows [Semantic Versioning](https://semver.org/). Starting with 1.0.0, the following are part of the public API and changes to them require a major version bump:
 
-  def perform
-    formatted_response(status: 'processed', message: "Hello, World", data: name)
-  end
+- The four-key response contract (`status`, `data`, `message`, `errors`).
+- The Hash-compatible surface of `ServiceCore::Response` (`[]`, `[]=`, `==`, `to_h`, `to_s`, `inspect`, `keys`, `values`, `each`, `dig`, `fetch`, `key?` / `has_key?` / `include?`, `as_json`, `to_json`) and its named accessors (`status`, `data`, `message`, `errors`).
+- The `ServiceCore::FieldSet` API (`to_h` and named accessors per declared symbol field).
+- The service DSL: `include ServiceCore`, `field`, `validates`, `perform`, instance `#call` and class `.call`, `service.fields`, `service.response` / `service.output`.
+- The response builders: `success_response`, `error_response`, `formatted_response`, `set_output`.
+- The step-validation helpers: `add_error`, `add_error_and_validate`.
+- The reserved field names: `:call`, `:errors`, `:fields`, `:output`, `:perform`, `:response`.
+- The exception hierarchy under `ServiceCore::Error`.
+- `ServiceCore.logger` and `ServiceCore.configure`.
 
-  def name
-    "#{first_name} #{last_name}"
-  end
-end
+The internals of `ServiceCore::Output`, the `Responder` mixin shape, and anything not listed above are implementation details and may change between any release.
+
+## Compatibility
+
+- Ruby: 3.1 minimum; tested against 3.3 and 3.4 (and 4.0 against Rails 8.x).
+- ActiveModel / ActiveSupport: `>= 6.1, < 9.0`; tested against Rails 7.2, 8.0, and 8.1 via [appraisal](https://github.com/thoughtbot/appraisal).
 
-service = MyService.new(first_name: "John", last_name: "Doe")
-result = service.call
-puts result
-# Output:
-# {
-#   status: "processed",
-#   message: "Hello, World",
-#.  data: "John Doe"
-# }
+## Development
+
+```sh
+bin/setup
+bundle exec rspec
+bundle exec rubocop
 ```
 
-`formatted_response` accepts following arguments:
-- status
-- message
-- data
-- errors
+To run the spec suite against every supported Rails version:
+
+```sh
+bundle exec appraisal install
+bundle exec appraisal rspec
+```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/sehgalmayank001/service-core. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/sehgalmayank001/service-core/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at [github.com/sehgalmayank001/service-core](https://github.com/sehgalmayank001/service-core). This project follows the [Contributor Covenant code of conduct](https://github.com/sehgalmayank001/service-core/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the ServiceCore project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/sehgalmayank001/service-core/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
@@ -16,6 +14,6 @@ task :release do
   version = `ruby -r ./lib/service_core/version -e "puts ServiceCore::VERSION"`.strip
   # sh "git add ."
   # sh "git commit -m 'Prepare for version #{version} release'"
-  # sh "git tag v#{version}"
-  # sh "git push origin main --tags"
-end
+  sh "git tag v#{version}"
+  sh "git push origin main --tags"
+end

data/gemfiles/rails_7.2.gemfile

@@ -0,0 +1,18 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "activemodel", "~> 7.2.0"
+gem "activesupport", "~> 7.2.0"
+
+group :development, :test do
+  gem "appraisal", "~> 2.5"
+  gem "debug", ">= 1.9"
+  gem "rspec", "~> 3.13"
+  gem "rubocop", "~> 1.86"
+  gem "rubocop-rake", "~> 0.7"
+  gem "rubocop-rspec", "~> 3.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_8.0.gemfile

@@ -0,0 +1,18 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "activemodel", "~> 8.0.0"
+gem "activesupport", "~> 8.0.0"
+
+group :development, :test do
+  gem "appraisal", "~> 2.5"
+  gem "debug", ">= 1.9"
+  gem "rspec", "~> 3.13"
+  gem "rubocop", "~> 1.86"
+  gem "rubocop-rake", "~> 0.7"
+  gem "rubocop-rspec", "~> 3.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_8.1.gemfile

@@ -0,0 +1,18 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "activemodel", "~> 8.1.0"
+gem "activesupport", "~> 8.1.0"
+
+group :development, :test do
+  gem "appraisal", "~> 2.5"
+  gem "debug", ">= 1.9"
+  gem "rspec", "~> 3.13"
+  gem "rubocop", "~> 1.86"
+  gem "rubocop-rake", "~> 0.7"
+  gem "rubocop-rspec", "~> 3.0"
+end
+
+gemspec path: "../"