service_actor 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a16f2ccd8bf0d2e83d5cb9ec163c81b9df3be06515cb716138049f9d33420759
+  data.tar.gz: bfb6c4dca34cb64fa3c8ce84b085faa85547c1a554f241ccf49d92a7a67d012b
+SHA512:
+  metadata.gz: 18df62d093865eefd2acd8a9d3567c1379be5c097c087b6c2d2eee1dc8cf0485e5b0b6f712b11a19492eca3465b48ba0281de7b88130e170681923ec3cc2086c
+  data.tar.gz: 80df1b4cc8269802cfe217663fa16ed907103a1b3e4b8ee42d1d01ac08c47a571f4993439f27d1065fbbb38738132be459b042aadfd04bdfe229bb6a2a4dbc27

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Sunny Ripert
+
+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,298 @@
+# Actor
+
+![Tests](https://github.com/sunny/actor/workflows/Tests/badge.svg)
+
+Ruby service objects. Lets you move your application logic into small
+building blocs to keep your controllers and your models thin.
+
+## Installation
+
+Add these lines to your application's Gemfile:
+
+```rb
+# Service objects to keep the business logic
+gem 'service_actor'
+```
+
+
+## Usage
+
+Actors are single-purpose actions in your application that represent your
+business logic. They start with a verb, inherit from `Actor` and implement a
+`call` method.
+
+```rb
+# app/actors/send_notification.rb
+class SendNotification < Actor
+  def call
+    # …
+  end
+end
+```
+
+Use `.call` to use them in your application:
+
+```rb
+SendNotification.call
+```
+
+### Inputs
+
+Actors can accept arguments with `input`:
+
+```rb
+class GreetUser < Actor
+  input :user
+
+  def call
+    puts "Hello #{user.name}!"
+  end
+end
+```
+
+And receive them as arguments to `call`:
+
+```rb
+GreetUser.call(user: User.first)
+```
+
+### Outputs
+
+Use `output` to declare what your actor can return, then assign them to your
+context.
+
+```rb
+class BuildGreeting < Actor
+  output :greeting
+
+  def call
+    context.greeting = "Have a wonderful day!"
+  end
+end
+```
+
+Calling an actor returns a context:
+
+```rb
+result = BuildGreeting.call
+result.greeting # => "Have a wonderful day!"
+```
+
+### Defaults
+
+Inputs can have defaults:
+
+```rb
+class PrintWelcome < Actor
+  input :user
+  input :adjective, default: "wonderful"
+  input :length_of_time, default: -> { ["day", "week", "month"].sample }
+
+  output :greeting
+
+  def call
+    context.greeting = "Hello #{name}! Have a #{adjective} #{length_of_time}!"
+  end
+end
+```
+
+### Types
+
+Inputs can define a type, or an array of possible types it must match:
+
+```rb
+class UpdateUser < Actor
+  input :user, type: 'User'
+  input :age, type: %w[Integer Float]
+
+  # …
+end
+```
+
+### Conditions
+
+If types don't cut it, you can add small conditions with the name of your choice
+under `must`:
+
+```rb
+class UpdateAdminUser < Actor
+  input :user,
+        must: {
+          be_an_admin: ->(user) { user.admin? }
+        }
+end
+```
+
+### Result
+
+All actors are successful by default. To stop its execution and mark is as
+having failed, use `fail!`:
+
+```rb
+class UpdateUser
+  input :user
+  input :attributes
+
+  def call
+    user.attributes = attributes
+
+    fail!(error: "Invalid user") unless user.valid?
+
+    # …
+  end
+end
+```
+
+You can then test for the success by calling your actor with `.result` instead
+of `.call`. This will let you test for `success?` or `failure?` on the context
+instead of raising an exception.
+
+For example in a Rails controller:
+
+```rb
+# app/controllers/users_controller.rb
+class UsersController < ApplicationController
+  def create
+    result = UpdateUser.result(user: user, attributes: user_attributes)
+    if result.success?
+      redirect_to result.user
+    else
+      render :new, notice: result.error
+    end
+  end
+end
+```
+
+### Play
+
+An actor can call actors in sequence by using `play`. Each actor will hand over
+the context to the next actor.
+
+```rb
+class PlaceOrder < Actor
+  play CreateOrder,
+       Pay,
+       SendOrderConfirmation,
+       NotifyAdmins
+end
+```
+
+### Rollback
+
+When using `play`, if one of the actors calls `fail!`, the following actors will
+not be called.
+
+Also, any _previous_ actor that succeeded will call the `rollback` method, if
+you defined one.
+
+```rb
+class CreateOrder < Actor
+  def call
+    context.order = Order.create!(…)
+  end
+
+  def rollback
+    context.order.destroy
+  end
+end
+```
+
+### Early success
+
+When using `play` you can use `succeed!` so that the following actors will not
+be called, but still consider the actor to be successful.
+
+### Lambdas
+
+You can call inline actions using lambdas:
+
+```rb
+class Pay
+  play ->(ctx) { ctx.payment_provider = "stripe" },
+       CreatePayment,
+       ->(ctx) { ctx.user_to_notify = ctx.payment.user },
+       SendNotification
+end
+```
+
+### Before, after and around
+
+To do actions before or after actors, use lambdas or simply override `call` and
+use `super`. For example:
+
+```rb
+class Pay
+  # …
+
+  def call
+    Time.with_timezone('Paris') do
+      super
+    end
+  end
+end
+```
+
+### Play conditions
+
+Some actors in a play can be called conditionaly:
+
+```rb
+class PlaceOrder < Actor
+  play CreateOrder,
+       Pay
+  play NotifyAdmins, if: ->(ctx) { ctx.order.amount > 42 }
+end
+```
+
+## Influences
+
+This gem is heavily influenced by
+[Interactor](https://github.com/collectiveidea/interactor) ♥.
+However there a a few key differences which make `actor` unique:
+
+- Defaults to raising errors on failures. Actor uses `call` and `result` instead of `call!` and `call`. This way, the default is to raise an error and failures are not hidden away.
+- Does not [hide errors when an actor fails inside another actor](https://github.com/collectiveidea/interactor/issues/170).
+- You can use lambdas inside organizers.
+- Requires you to document the arguments with `input` and `output`.
+- Type checking of inputs and outputs.
+- Inputs and outputs can be required.
+- Defaults for inputs.
+- Conditions on inputs.
+- Shorter fail syntax: `fail!` vs `context.fail!`.
+- Trigger early success in organisers with `succeed!`.
+- Shorter setup syntax: inherit from `< Actor` vs having to `include Interactor` or `include Interactor::Organizer`.
+- Multiple organizers.
+- Conditions inside organizers.
+- No `before`, `after` and `around` hooks. Prefer simply overriding `call` with `super` which allows wrapping the whole method.
+- [Does not rely on `OpenStruct`](https://github.com/collectiveidea/interactor/issues/183)
+- Does not print warnings on Ruby 2.7.
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then
+run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/sunny/actor. This project is intended to be a safe,
+welcoming space for collaboration, and contributors are expected to adhere to
+the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## 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 Test project’s codebases, issue trackers, chat
+rooms and mailing lists is expected to follow the
+[code of conduct](https://github.com/sunny/actor/blob/master/CODE_OF_CONDUCT.md).

data/lib/actor/attributable.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Actor
+  # DSL to document the accepted attributes.
+  #
+  #   class CreateUser < Actor
+  #     input :name
+  #     output :name
+  #   end
+  module Attributable
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.prepend(PrependedMethods)
+    end
+
+    module ClassMethods
+      def inherited(child)
+        super
+
+        child.inputs.merge!(inputs)
+        child.outputs.merge!(outputs)
+      end
+
+      def input(name, **arguments)
+        inputs[name] = arguments
+
+        define_method(name) do
+          context.public_send(name)
+        end
+
+        private name
+      end
+
+      def inputs
+        @inputs ||= {}
+      end
+
+      def output(name, **arguments)
+        outputs[name] = arguments
+      end
+
+      def outputs
+        @outputs ||= { error: { type: 'String' } }
+      end
+    end
+
+    module PrependedMethods
+      # rubocop:disable Naming/MemoizedInstanceVariableName
+      def context
+        @filtered_context ||= Actor::FilteredContext.new(
+          super,
+          readers: self.class.inputs.keys,
+          setters: self.class.outputs.keys,
+        )
+      end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
+    end
+  end
+end

data/lib/actor/conditionable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Actor
+  # Add boolean checks to inputs, by calling lambdas starting with `must*`.
+  #
+  # Example:
+  #
+  #   class Pay < Actor
+  #     input :provider,
+  #           must: {
+  #             exist: ->(provider) { PROVIDERS.include?(provider) }
+  #           }
+  #
+  #     output :user, required: true
+  #   end
+  module Conditionable
+    def before
+      super
+
+      self.class.inputs.each do |key, options|
+        next unless options[:must]
+
+        options[:must].each do |name, check|
+          value = @context[key]
+          next if check.call(value)
+
+          name = name.to_s.sub(/^must_/, '')
+          raise ArgumentError,
+                "Input #{key} must #{name} but was #{value.inspect}."
+        end
+      end
+    end
+  end
+end

data/lib/actor/context.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+class Actor
+  # Represents the result of an action.
+  class Context
+    def self.to_context(data)
+      return data if data.is_a?(self)
+
+      new(data)
+    end
+
+    def initialize(data = {})
+      @data = data.dup
+    end
+
+    def ==(other)
+      other.class == self.class && data == other.data
+    end
+
+    def inspect
+      "<ActorContext #{data.inspect}>"
+    end
+
+    def fail!(context = {})
+      merge!(context)
+      data[:failure?] = true
+      raise Actor::Failure, self
+    end
+
+    def succeed!(context = {})
+      merge!(context)
+      data[:failure?] = false
+      raise Actor::Success, self
+    end
+
+    def success?
+      !failure?
+    end
+
+    def failure?
+      data.fetch(:failure?, false)
+    end
+
+    def merge!(context)
+      data.merge!(context)
+
+      self
+    end
+
+    def key?(name)
+      data.key?(name)
+    end
+
+    def [](name)
+      data[name]
+    end
+
+    # Redefined here to override the method on `Object`.
+    def display
+      data.fetch(:display)
+    end
+
+    protected
+
+    attr_reader :data
+
+    private
+
+    # rubocop:disable Style/MethodMissingSuper
+    def method_missing(name, *arguments, **)
+      if name =~ /=$/
+        key = name.to_s.sub('=', '').to_sym
+        data[key] = arguments.first
+      else
+        data[name]
+      end
+    end
+    # rubocop:enable Style/MethodMissingSuper
+
+    def respond_to_missing?(*_arguments)
+      true
+    end
+
+    def context_get(key)
+      data[key]
+    end
+
+    def context_set(key, value)
+      data[key] = value
+    end
+  end
+end

data/lib/actor/defaultable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Actor
+  # Adds the `default:` option to inputs. Accepts regular values and lambdas.
+  #
+  # Example:
+  #
+  #   class MultiplyThing < Actor
+  #     input :counter, default: 1
+  #     input :multiplier, default: -> { rand(1..10) }
+  #   end
+  module Defaultable
+    def before
+      self.class.inputs.each do |name, input|
+        next if !input.key?(:default) || @context.key?(name)
+
+        default = input[:default]
+        default = default.call if default.respond_to?(:call)
+        @context.merge!(name => default)
+      end
+
+      super
+    end
+  end
+end

data/lib/actor/failure.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Actor
+  # Error raised when using `fail!` inside an actor.
+  class Failure < StandardError
+    def initialize(context)
+      @context = context
+
+      error = context.respond_to?(:error) ? context.error : nil
+
+      super(error)
+    end
+
+    attr_reader :context
+  end
+end

data/lib/actor/filtered_context.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Actor
+  # Represents the result of an action, tied to inputs and outputs.
+  class FilteredContext
+    def initialize(context, readers:, setters:)
+      @context = context
+      @readers = readers
+      @setters = setters
+    end
+
+    def inspect
+      "<#{self.class.name} #{context.inspect} " \
+        "readers: #{readers.inspect} " \
+        "setters: #{setters.inspect}>"
+    end
+
+    def fail!(**arguments)
+      context.fail!(**arguments)
+    end
+
+    def succeed!(**arguments)
+      context.fail!(**arguments)
+    end
+
+    private
+
+    attr_reader :context, :readers, :setters
+
+    def method_missing(name, *arguments, **options)
+      return super unless context.respond_to?(name)
+
+      unless available_methods.include?(name)
+        raise ArgumentError, "Cannot call #{name} on #{inspect}"
+      end
+
+      context.public_send(name, *arguments)
+    end
+
+    def respond_to_missing?(name, *_arguments)
+      available_methods.include?(name)
+    end
+
+    def available_methods
+      @available_methods ||=
+        readers + setters.map { |key| "#{key}=".to_sym }
+    end
+  end
+end

data/lib/actor/playable.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class Actor
+  # DSL to call a series of actors with the same context. On failure, calls
+  # rollback on any actor that succeeded.
+  #
+  #   class CreateUser < Actor
+  #     play SaveUser,
+  #          CreateSettings,
+  #          SendWelcomeEmail
+  #   end
+  module Playable
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.prepend(PrependedMethods)
+    end
+
+    module ClassMethods
+      def inherited(child)
+        super
+
+        play_actors.each do |actor|
+          child.play_actors << actor
+        end
+      end
+
+      def play(*actors, **options)
+        actors.each do |actor|
+          play_actors.push({ actor: actor, **options })
+        end
+      end
+
+      def play_actors
+        @play_actors ||= []
+      end
+    end
+
+    module PrependedMethods
+      def call
+        self.class.play_actors.each do |options|
+          next if options[:if] && !options[:if].call(@context)
+
+          play_actor(options[:actor])
+        end
+      rescue Actor::Failure
+        rollback
+        raise
+      end
+
+      def rollback
+        return unless @played
+
+        @played.each do |actor|
+          next unless actor.respond_to?(:rollback)
+
+          actor.rollback
+        end
+      end
+
+      private
+
+      def play_actor(actor)
+        if actor.respond_to?(:new)
+          actor = actor.new(@context)
+          actor.run
+        else
+          actor.call(@context)
+        end
+
+        (@played ||= []).unshift(actor)
+      end
+    end
+  end
+end

data/lib/actor/requireable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Actor
+  # Adds `required:` checking to inputs and outputs.
+  #
+  # Example:
+  #
+  #   class CreateUser < Actor
+  #     input :name, required: true
+  #     output :user, required: true
+  #   end
+  module Requireable
+    def before
+      super
+
+      check_required_definitions(self.class.inputs, kind: 'Input')
+    end
+
+    def after
+      super
+
+      check_required_definitions(self.class.outputs, kind: 'Output')
+    end
+
+    private
+
+    def check_required_definitions(definitions, kind:)
+      definitions.each do |key, options|
+        next unless options[:required] && @context[key].nil?
+
+        raise ArgumentError,
+              "#{kind} #{key} on #{self.class} is required but was nil."
+      end
+    end
+  end
+end

data/lib/actor/success.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Actor
+  # Raised when using `succeed!` to halt the progression of an organizer.
+  class Success < StandardError; end
+end

data/lib/actor/type_checkable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Actor
+  # Adds `type:` checking to inputs and outputs. Accepts strings that should
+  # match an ancestor. Also accepts arrays.
+  #
+  # Example:
+  #
+  #   class ReduceOrderAmount < Actor
+  #     input :order, type: 'Order'
+  #     input :amount, type: %w[Integer Float]
+  #     input :bonus_applied, type: %w[TrueClass FalseClass]
+  #   end
+  module TypeCheckable
+    def before
+      super
+
+      check_type_definitions(self.class.inputs, kind: 'Input')
+    end
+
+    def after
+      super
+
+      check_type_definitions(self.class.outputs, kind: 'Output')
+    end
+
+    private
+
+    def check_type_definitions(definitions, kind:)
+      definitions.each do |key, options|
+        type_definition = options[:type] || next
+        value = @context[key] || next
+
+        types = Array(type_definition).map { |name| Object.const_get(name) }
+        next if types.any? { |type| value.is_a?(type) }
+
+        error = "#{kind} #{key} on #{self.class} must be of type " \
+                "#{types.join(', ')} but was #{value.class}"
+        raise ArgumentError, error
+      end
+    end
+  end
+end

data/lib/actor/version.rb

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

data/lib/service_actor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'actor/failure'
+require 'actor/success'
+require 'actor/context'
+require 'actor/filtered_context'
+
+require 'actor/playable'
+require 'actor/attributable'
+require 'actor/defaultable'
+require 'actor/type_checkable'
+require 'actor/requireable'
+require 'actor/conditionable'
+
+# Actors should start with a verb, inherit from Actor and implement a `call`
+# method.
+class Actor
+  include Attributable
+  include Playable
+  prepend Defaultable
+  prepend TypeCheckable
+  prepend Requireable
+  prepend Conditionable
+
+  class << self
+    # Call an actor with a given context. Returns the context.
+    #
+    #   CreateUser.call(name: 'Joe')
+    def call(context = {}, **arguments)
+      context = Actor::Context.to_context(context).merge!(arguments)
+      new(context).run
+      context
+    rescue Actor::Success
+      context
+    end
+
+    alias call! call
+
+    # Call an actor with a given context. Returns the context and does not raise
+    # on failure.
+    #
+    #   CreateUser.result(name: 'Joe')
+    def result(context = {}, **arguments)
+      call(context, **arguments)
+    rescue Actor::Failure => e
+      e.context
+    end
+  end
+
+  # :nodoc:
+  def initialize(context)
+    @context = context
+  end
+
+  # To implement in your actors.
+  def call; end
+
+  # To implement in your actors.
+  def rollback; end
+
+  # :nodoc:
+  def before; end
+
+  # :nodoc:
+  def after; end
+
+  # :nodoc:
+  def run
+    before
+    call
+    after
+  end
+
+  private
+
+  # Returns the current context from inside an actor.
+  attr_reader :context
+
+  # Can be called from inside an actor to stop execution and mark as failed.
+  def fail!(**arguments)
+    @context.fail!(**arguments)
+  end
+
+  # Can be called from inside an actor to stop execution early.
+  def succeed!(**arguments)
+    @context.succeed!(**arguments)
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: service_actor
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Sunny Ripert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Service objects for your application logic
+email:
+- sunny@sunfox.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- lib/actor/attributable.rb
+- lib/actor/conditionable.rb
+- lib/actor/context.rb
+- lib/actor/defaultable.rb
+- lib/actor/failure.rb
+- lib/actor/filtered_context.rb
+- lib/actor/playable.rb
+- lib/actor/requireable.rb
+- lib/actor/success.rb
+- lib/actor/type_checkable.rb
+- lib/actor/version.rb
+- lib/service_actor.rb
+homepage: https://github.com/sunny/actor
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sunny/actor
+  source_code_uri: https://github.com/sunny/actor
+  changelog_uri: https://github.com/sunny/actor/blob/master/CHANGELOG.md
+post_install_message: 
+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.1.2
+signing_key: 
+specification_version: 4
+summary: Service objects for your application logic
+test_files: []