service_base 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d20e049647526253612ef6cf134c73ce8ab076c69e9a1f3a5524586f035f8ae3
+  data.tar.gz: 8fe635ae9d66b5358030440828f45e0706a2cad092e7eb45f9738af5c53c9896
+SHA512:
+  metadata.gz: '0595ddabc674a039b1dfb3189f4f7a6d8aa2e3a6c694391b94c26235180f7b67475685b3c5e19283c07f8b8e141b6c99b109d35659af6ef7d4e436f74ab0a832'
+  data.tar.gz: a38e09b26353baa8a4b37edb97522d33a2bd95a9209f9b930c109f67dbd5d305623c57aa5508c82bdb574150536c37048a5399cb25eed4df5f5c22838456aac4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Your Name
+
+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,319 @@
+# Service Base
+
+A base service class for Ruby applications that provides common functionality and argument type annotations.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "service_base"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install service_base
+```
+
+# Base Service Pattern
+
+The general concept of a Service Pattern is useful when a you need to execute a set of
+sequential steps. The service encapsulates those steps into a single class with a single action to trigger the steps.
+
+The Base Service Pattern uses a modified [Railway
+Pattern](https://fsharpforfunandprofit.com/posts/recipe-part2/) set up and enforced by the `Service` class,
+which every service inherits from.
+
+## Recommended resources
+
+- Highly recommended video inspiring this pattern: [Service Objects with
+Dry.rb](https://www.youtube.com/watch?v=YXiqzHMmv_o)
+- [Essential
+RubyOnRails patterns — part 1: Service Objects](https://medium.com/selleo/essential-rubyonrails-patterns-part-1-service-objects-1af9f9573ca1)
+- [Ruby
+on Rails pattern: Service Objects](https://dev.to/joker666/ruby-on-rails-pattern-service-objects-b19)
+
+## Advantages
+
+- The action of a service should read as a list of steps which makes
+reading and maintaining the service easy.
+- Instantiation of a service object allows fine grained control over
+the arguments being passed in and reduces the need to pass arguments
+between methods in the same instance.
+- Encapsulation of logic in a service makes for reusable code, simpler
+testing, and extracts logic from other objects that should not be
+responsible for handling that logic.
+- Verb-naming makes the intention of the service explicit.
+- Single service actions reveal a single public interface.
+
+## What defines a service?
+
+- The main difference between a model and a service is that a model
+“models” **what** something is while a service lists
+**how** an action is performed.
+- A service has a single public method, ie. `call`
+- A model is a noun, a service is a verb’ed noun that does the one
+thing the name implies
+    - Ie. `User` (model) versus `User::CreatorService` (service)
+    - Ie. `StripeResponse` (model) versus `PaymentHistoryFetcherService` (service)
+
+## Naming
+
+One of the best ways to use the service pattern is for CRUD services - Ie. `ActiveRecordModel` +
+`::CreateService`, `::UpdateService`,
+`::DeleteService`. This avoids the use of callbacks, mystery guests, and unexpected side effects because all the steps to do a CRUD action are in one place and in order.
+
+## Returning a Result
+
+Each service inheriting from BaseService must define
+`#call` and return a `Success` or
+`Failure`. These types are `Result` Monads from
+the dry-monads gem. Both `Result` types may take any value as
+input, ie. `Success(user)`,
+`Failure(:not_found)`
+
+`Failure` can return any value you’d like the caller to have in order to understand the failure.
+
+The caller of service can unwrap the Success, Failure or like so
+
+```ruby
+MyService.call(name: user.name) do |on|
+	on.success { |value| some_method(value) }
+	on.failure { |error| log_error(error) }
+end
+```
+
+To match different expected values of success or failure, pass the
+value as an argument.
+
+```ruby
+MyService.call(name: user.name) do |on|
+  on.success(:created) { notify_created! }
+  on.failure(ActiveRecord::NotFound) { log_not_found }
+  on.failure(:invalid) { render(code: 422) }
+  on.failure { |error| raise(RuntimeError, error) }
+end
+```
+
+Note that you must define both `on.success` and
+`on.failure` or else an error will be raised in the
+caller.
+
+Note that `raise`ing an error requires an error class
+unless the error itself is an instance of an error class.
+
+Please see [result](https://dry-rb.org/gems/dry-monads/1.3/result/) for
+additional mechanisms used for chaining results and handling
+success/failure values.
+
+A recommended pattern within services is to return a
+`Success` and/or `Failure` from each method and
+yield the result in the caller. This forces you to consider how each
+method could fail and allows for automatic bubbling up of the
+`Failure` via railway-style programming. Examples at [https://dry-rb.org/gems/dry-monads/1.3/do-notation/#adding-batteries](https://dry-rb.org/gems/dry-monads/1.3/do-notation/#adding-batteries)
+
+## Failures vs Exceptions
+
+Failure = a known error case that may happen and should be gracefully
+handled
+
+Raising = an unexpected exception (exceptional circumstances)
+
+Any call that `raise`s is not rescued by default and will
+behave as a typical Ruby exception. This is a good thing. We will be
+alerted when exceptional circumstances arise.
+
+Return a `Failure` instead when you know of a potential
+failure case.
+
+Avoid rescuing major error/exception superclasses such as
+`StandardError`. Doing so will rescue all subclasses of that
+error class. If you need to raise an error for control flow, favor a
+specific error or custom error class.
+
+```ruby
+# bad
+rescue StandardError => e
+  Failure(e)
+end
+
+# good - known failure case
+return Failure("Number #{num} must be positive") if arg.negative?
+
+# good - exception required for control flow
+rescue ActiveRecord::Rollback
+  Failure("Record invalid: #{record.inspect}")
+end
+```
+
+## Arguments
+
+Arguments to a service are defined via the `argument` DSL.
+The positional name and type arguments are required, the other options
+are as follows.
+`argument(:name, String, optional: true, description: "The User's name")`
+
+If an argument is optional and has a default value, simply set
+`default: your_value` but do not also specify
+`optional: true`. Doing so will raise an
+`ArgumentError`. Additionally, be sure to
+`.freeze` any mutable default values, ie.
+`default: {}.freeze`. Failure to do so will raise an
+`ArgumentError`.
+
+Empty strings attempted to coerce into integers will throw an error.
+See [https://github.com/dry-rb/dry-types/issues/344#issuecomment-518743661](https://github.com/dry-rb/dry-types/issues/344#issuecomment-518743661)
+To instead accept `nil`, do the following:
+`argument(:some_integer, Params::Nil | Params::Integer)`
+
+A service should also define a `description`. This is
+recommended for self-documentation, ie.
+
+```ruby
+class MyService < Service
+  description("Does a lot of cool things")
+end
+```
+
+To get the full hash of `argument`s passed into a service,
+use `attributes`. This is a very useful technique for
+services that update an object. For example
+
+```ruby
+class User::UpdateService < Service
+  def call
+    user.update(attributes)
+  end
+end
+```
+
+### ApplicationRecord Args
+
+If you add `ApplicationRecord = Types.Instance(ApplicationRecord)` in a Rails project, you can accept any `ApplicationRecord` via
+
+`argument(:my_record, ApplicationRecord)`
+
+You can also limit the type of AR record via
+
+`argument(:my_record, Types.Instance(MyRecord))`
+
+## Types
+
+Argument types are defined in Types, which can be extended, ie. app/models/types.rb, and are an extension of [Dry.rb’s
+Types](https://dry-rb.org/gems/dry-types/1.2/built-in-types/). In order to access constants outside of the dry.rb namespace,
+or to access a type that collides with one of our defined types, you
+must include `::` to allow a global constant search.
+
+Ie. `::ApplicationRecord...`
+
+`Coercible` and `Params` Types are very
+powerful and recommended for automatic parsing of inputs, ie. controller
+parameters.
+
+For example `argument(:number, Params::Integer)` will
+convert `"12"` ⇒ `12`
+
+Entire hash structures may also be validated and automatically
+parsed, for example:
+
+```ruby
+argument(
+  :line_items,
+  Array(
+    Hash.schema(
+      vintage_year: Params::Integer,
+      number_of_credits: Params::Integer,
+      price_dollars_usd: Params::Float,
+    ),
+  ),
+```
+
+## Working with transactions
+
+⚠️  If your service makes more than one write call to the DB, you
+should wrap all operations in a single transaction with
+`::ApplicationRecord.transaction`.
+
+According to the [Dry
+RB docs](https://dry-rb.org/gems/dry-monads/1.3/do-notation/#transaction-safety):
+
+> Under the hood, Do uses exceptions to halt unsuccessful
+operations…Since yield internally uses exceptions to
+control the flow, the exception will be detected by
+the transaction call and the whole operation will be rolled
+back.
+>
+
+Therefore, `yield`ing a `Failure` will roll
+back the transaction without having to add any explicit exception
+handling via `rescue`.
+
+In Rails 7, using `return` inside a transaction [will
+roll the transaction back](https://www.loyalty.dev/posts/returning-from-transactions-in-rails). Therefore,
+`return Failure(...)` within a transaction will roll back, as well as `yield`ing a `Failure` within a transaction.
+
+## Internal Method Result
+
+The Railway Pattern can be used internally within services via
+`yield` and `do` notation. This forces the
+programmer to think about the success and failure cases within each
+method. See [the dry-monads gem](https://dry-rb.org/gems/dry-monads/1.3/) for more details.
+
+If the internal methods of the service need to unwrap values, those specific methods need to be registered with the result matcher like so.
+
+```ruby
+include Dry::Matcher.for(:method_name, with: Dry::Matcher::ResultMatcher)
+```
+
+Within the service, the registered method can then be pattern matched and unwrapped.
+
+```ruby
+method_name(order:) do |on|
+  on.success(:deleted) { true }
+  on.success(:cancelled) { destroy_order(order:) }
+  on.failure { |error| raise(RuntimeError, error) }
+end
+```
+
+## Gotchas
+
+- `yield`ing does not work inside `concerning`
+blocks or other sub-modules. See [https://github.com/dry-rb/dry-monads/issues/68#issuecomment-1042372398](https://github.com/dry-rb/dry-monads/issues/68#issuecomment-1042372398)
+
+## Misc
+
+- To get a pretty printed description of a service and it’s args, run `ServiceClass.pp`
+
+## Test Support
+
+The following methods are made available by including the base service testing in your test suite.
+
+```ruby
+require "service_base/rspec"
+```
+
+```ruby
+stub_service_success(User::CreateService)
+stub_service_success(User::CreateService, success: true)
+stub_service_success(User::CreateService, success: create(:user))
+
+stub_service_failure(User::CreateService, failure: "error")
+stub_service_failure(User::CreateService failure: :invalid_email, matched: true)
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rspec` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+
+## License
+
+The gem is available as open source under the terms of the MIT License.

data/lib/service_base/argument_type_annotations.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ArgumentTypeAnnotations
+  class << self
+    def extended(klass)
+      if !klass.is_a?(Class) || !klass.ancestors.include?(Dry::Struct)
+        raise(TypeError, "#{name} should be extended on a Dry::Struct subclass")
+      end
+
+      # `Types` overrides default types to help shorthand Type::String.
+      # To access Ruby's native types within a service, use `::`, ie. `::String`
+      klass.include(Types)
+    end
+
+    def included(klass)
+      if !klass.singleton_class? || !klass.attached_object.ancestors.include?(Dry::Struct)
+        raise(TypeError, "#{name} should be included on the singleton class of a Dry::Struct subclass")
+      end
+
+      # `Types` overrides default types to help shorthand Type::String.
+      # To access Ruby's native types within a service, use `::`, ie. `::String`
+      klass.attached_object.include(Types)
+    end
+  end
+
+  # Defines an argument using the ServiceBase DSL.
+  # Under the hood, this uses dry-struct's attribute DSL.
+  def argument(name, type, configuration = {}, &)
+    description = configuration[:description] == "" ? nil : configuration[:description]
+    type = type.meta(description:)
+
+    default = configuration[:default]
+    validate_frozen_default!(name:, default:)
+
+    optional = configuration.fetch(:optional, false)
+    validate_optional_or_default!(optional:, default:, name:)
+
+    type = set_default(type:, default:)
+
+    if optional
+      # attribute? allows the key to be omitted.
+      # .optional allows the value to be nil.
+      # https://dry-rb.org/gems/dry-types/1.2/optional-values/
+      # https://github.com/dry-rb/dry-struct/blob/master/lib/dry/struct/class_interface.rb#L141-L169
+      attribute?(name, type.optional, &)
+    else
+      # https://github.com/dry-rb/dry-struct/blob/master/lib/dry/struct/class_interface.rb#L30-L104
+      attribute(name, type, &)
+    end
+  end
+
+  private
+
+  # Raises a warning from dry-types to avoid memory sharing.
+  # https://github.com/dry-rb/dry-types/blob/master/lib/dry/types/builder.rb#L71-L81
+  def validate_frozen_default!(name:, default:)
+    return if default.frozen?
+
+    raise(
+      ArgumentError,
+      "#{default} provided as a default value for #{name} is mutable. " \
+      "Please `.freeze` your `default:` input.",
+    )
+  end
+
+  # Do not allow setting both a default value and optional: true. If both
+  # are specified, the default will not be used.
+  def validate_optional_or_default!(optional:, default:, name:)
+    return unless optional && !default.nil?
+
+    raise(
+      ArgumentError,
+      "#{name} cannot specify both a default value and optional: true. " \
+      "Only specify a default value if the value is optional.",
+    )
+  end
+
+  # Ensures that provided args are declared as `argument`s
+  def validate_args!(args:)
+    invalid_args = (args.keys - attribute_names)
+    return if invalid_args.empty?
+
+    raise(
+      ArgumentError,
+      "#{self} provided invalid arguments: #{invalid_args.join(', ')}",
+    )
+  end
+
+  # Sets the default value on the type.
+  # For primitive types, the default can be set after initialization.
+  # For enums, the default must be set during initialization. Therefore,
+  # we must check the type of the enum and then reconstruct the enum with
+  # the default value being set.
+  # See "Note" in https://dry-rb.org/gems/dry-types/1.2/enum/
+  def set_default(type:, default:)
+    return type if default.nil?
+
+    if type.is_a?(Dry::Types::Enum)
+      values = type.values
+      type_class = "Types::#{values.first.class}".constantize
+      type_class.default(default).enum(*values)
+    else
+      type.default(default)
+    end
+  end
+end

data/lib/service_base/rspec/service_support.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ServiceSupport
+  # Note that you must have at least one `on.success` and one `on.failure`
+  # matcher for each block-style service call
+  def stub_service_success(service_class, success: nil)
+    block = double(:on)
+    allow(block).to receive(:failure)
+    if success.present?
+      allow(block).to receive(:success).and_yield(success)
+    else
+      allow(block).to receive(:success)
+    end
+    allow(service_class).to receive(:call).and_yield(block)
+  end
+
+  # Note that you must have at least one `on.success` and one `on.failure`
+  # matcher for each block-style service call.
+  # Set `matched: true` for specific `on.failure(:error)` blocks.
+  # Set `matched: true` for catch-all `on.failure` blocks.
+  def stub_service_failure(service_class, failure:, matched: false)
+    block = double(:on)
+    allow(block).to receive(:success)
+    if matched # on.failure(:some_error)
+      allow(block).to receive(:failure) # ignore unmatched on.failure
+      allow(block).to receive(:failure).with(failure).and_yield(failure)
+    else # on.failure
+      # ignore matched on.failure(:some_error)
+      allow(block).to receive(:failure).with(anything)
+      allow(block).to receive(:failure).with(no_args).and_yield(failure)
+    end
+    allow(service_class).to receive(:call).and_yield(block)
+  end
+end
+
+RSpec.configure do |config|
+  config.include ServiceSupport
+end

data/lib/service_base/rspec.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# relative-require all rspec files
+Dir[File.dirname(__FILE__) + '/rspec/*.rb'].each do |file|
+  require 'service_base/rspec/' + File.basename(file, File.extname(file))
+end

data/lib/service_base/service.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'dry-matcher'
+require 'dry-struct'
+require 'dry/matcher/result_matcher'
+require 'dry/monads'
+require 'dry/monads/do'
+require 'memery'
+
+class Service < Dry::Struct
+  extend Dry::Monads::Result::Mixin::Constructors
+  include Dry::Monads::Do.for(:call)
+  include Dry::Monads[:result, :do]
+
+  extend ArgumentTypeAnnotations
+  include Memery
+
+  class ServiceNotSuccessful < StandardError
+    attr_reader(:failure)
+
+    def initialize(failure)
+      super('Failed to call service')
+      @failure = failure
+    end
+  end
+
+  class << self
+    # The public class call method.
+    #
+    # The default empty hash is important to prevent an argument error when
+    # passing no arguments to a service that defines defaults for every argument.
+    def call(args = {}, &block)
+      validate_args!(args: args)
+
+      result = new(args).call
+      match_result(result, &block)
+    end
+
+    def call!(*args)
+      result = call(*args)
+      raise(ServiceNotSuccessful, result.failure) if result.failure?
+
+      result
+    end
+
+    # Pretty prints (pp) the description of the service, ie. `MyService.pp`
+    def pp
+      logger = Logger.new($stdout)
+      logger.info("#{name}: #{service_description}")
+      logger.info('Arguments')
+
+      schema_definition.each do |arg|
+        logger.info("  #{arg[:name]} (#{arg[:type]}): #{arg[:description]}")
+      end
+    end
+
+    # @description getter
+    def service_description
+      @description || 'No description'
+    end
+
+    private
+
+    # Set the description on the service
+    def description(text)
+      @description = text
+    end
+
+    # Employs ResultMatcher to unwrap values using `on.success` & `on.failure`
+    # syntax. If not using block form to extract the result of a service,
+    # ie. `MyService.call.fmap { |result| result + 2 }`, ensure you explictly
+    # handle Failures. See https://dry-rb.org/gems/dry-monads/1.3/result/
+    def match_result(result, &block)
+      # https://medium.com/swlh/better-rails-service-objects-with-dry-rb-702687394e3d
+      if block
+        # raises Dry::Matcher::NonExhaustiveMatchError: cases +failure+ not handled
+        # if `on.failure` is not declared
+        Dry::Matcher::ResultMatcher.call(result, &block)
+      else
+        result
+      end
+    end
+
+    # Introspects the arguments DSL to extract information on each argument
+    def schema_definition
+      attribute_names.each_with_object([]) do |attribute_name, list|
+        dry_type = schema.key(attribute_name)
+        list << {
+          name: attribute_name,
+          description: dry_type.meta[:description],
+          type: dry_type.type.name
+        }
+      end
+    end
+  end
+
+  private
+
+  # The call method that must be defined by every inheriting service class
+  def call
+    raise(NotImplementedError)
+  end
+
+  # A locale lookup helper that uses the name of the service
+  def locale(selector, args = {})
+    class_name = self.class.name.gsub('::', '.').underscore
+    I18n.t(".#{selector}", scope: "services.#{class_name}", **args)
+  end
+
+  # Structured Monad Result Failure type for returning a ResponseError
+  class ResponseFailure < Dry::Monads::Result::Failure
+    def initialize(message, code, trace = Dry::Monads::RightBiased::Left.trace_caller)
+      super(ResponseError.new(message: message, code: code), trace)
+    end
+  end
+end

data/lib/service_base/types.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Defines Dry Types. These Types are included in the ServiceBase for type
+# enforcement when defining `argument`s.
+#
+# For example, you may want to add `ApplicationRecord = Types.Instance(ApplicationRecord)`
+#
+# Add custom types as outlined in
+# https://dry-rb.org/gems/dry-types/1.2/custom-types/
+
+require 'dry-types'
+
+module Types
+  include Dry.Types()
+
+  UpCasedString = Types::String.constructor(&:upcase)
+  Boolean = Bool # alias the built in type, Bool
+end

data/lib/service_base/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ServiceBase
+  VERSION = '1.0.0'
+end

data/lib/service_base.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'service_base/version'
+require_relative 'service_base/types'
+require_relative 'service_base/argument_type_annotations'
+require_relative 'service_base/service'
+
+module ServiceBase
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: service_base
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- James Klein
+bindir: bin
+cert_chain: []
+date: 2025-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-matcher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: memery
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: A base service class for Ruby applications with argument type annotations
+  and railway-oriented programming
+email:
+- kleinjm007@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/service_base.rb
+- lib/service_base/argument_type_annotations.rb
+- lib/service_base/rspec.rb
+- lib/service_base/rspec/service_support.rb
+- lib/service_base/service.rb
+- lib/service_base/types.rb
+- lib/service_base/version.rb
+homepage: https://github.com/kleinjm/service_base
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kleinjm/service_base
+  source_code_uri: https://github.com/kleinjm/service_base
+  changelog_uri: https://github.com/kleinjm/service_base/blob/main/README.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A base service class for Ruby applications
+test_files: []