operandi 5.0.0

data/rbi/operandi.rbi

@@ -0,0 +1,197 @@
+# typed: strict
+# frozen_string_literal: true
+
+# RBI signatures for Operandi gem.
+# These signatures provide Sorbet type checking without requiring sorbet-runtime as a dependency.
+
+module Operandi
+  class Error < StandardError; end
+
+  class RuntimeError < Error
+    sig { params(message: T.nilable(String), service: Operandi::Base).void }
+    def initialize(message = nil, service:); end
+
+    sig { returns(Operandi::Base) }
+    def service; end
+  end
+
+  class ArgTypeError < Error
+    sig { params(message: T.nilable(String), service_class: T.class_of(Operandi::Base)).void }
+    def initialize(message = nil, service_class:); end
+
+    sig { returns(T.class_of(Operandi::Base)) }
+    def service_class; end
+  end
+
+  class Base
+    # Attributes
+    sig { returns(Operandi::Messages) }
+    def errors; end
+
+    sig { returns(Operandi::Messages) }
+    def warnings; end
+
+    # Instance methods
+    sig { returns(T::Boolean) }
+    def success?; end
+
+    sig { returns(T::Boolean) }
+    def successful?; end
+
+    sig { returns(T::Boolean) }
+    def failed?; end
+
+    sig { returns(T::Boolean) }
+    def errors?; end
+
+    sig { returns(T::Boolean) }
+    def warnings?; end
+
+    sig { void }
+    def stop!; end
+
+    sig { returns(T::Boolean) }
+    def stopped?; end
+
+    sig { returns(T.noreturn) }
+    def stop_immediately!; end
+
+    sig { params(message: String).void }
+    def fail!(message); end
+
+    sig { params(message: String).returns(T.noreturn) }
+    def fail_immediately!(message); end
+
+    sig { void }
+    def call; end
+
+    # Class methods
+    class << self
+      sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def class_config; end
+
+      sig { params(class_config: T.nilable(T::Hash[Symbol, T.untyped])).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def class_config=(class_config); end
+
+      sig { params(config: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      def config(config = {}); end
+
+      sig { params(kwargs: T.untyped).returns(T.attached_class) }
+      def run(**kwargs); end
+
+      sig { params(kwargs: T.untyped).returns(T.attached_class) }
+      def run!(**kwargs); end
+
+      sig {
+        params(
+          service_or_config: T.any(Operandi::Base, T::Hash[Symbol, T.untyped]),
+          config: T::Hash[Symbol, T.untyped],
+        ).returns(Operandi::BaseWithContext)
+      }
+      def with(service_or_config, config = {}); end
+    end
+  end
+
+  class BaseWithContext
+    sig {
+      params(
+        service_class: T.class_of(Operandi::Base),
+        parent_service: T.nilable(Operandi::Base),
+        config: T::Hash[Symbol, T.untyped],
+      ).void
+    }
+    def initialize(service_class, parent_service, config); end
+
+    sig { params(kwargs: T.untyped).returns(Operandi::Base) }
+    def run(**kwargs); end
+
+    sig { params(kwargs: T.untyped).returns(Operandi::Base) }
+    def run!(**kwargs); end
+  end
+
+  class Messages
+    sig {
+      params(
+        config: T::Hash[Symbol, T.untyped],
+        service: Operandi::Base,
+      ).void
+    }
+    def initialize(config = {}, service:); end
+
+    sig { params(key: Symbol).returns(T.nilable(T::Array[Operandi::Message])) }
+    def [](key); end
+
+    sig { returns(T::Boolean) }
+    def any?; end
+
+    sig { returns(T::Boolean) }
+    def empty?; end
+
+    sig { returns(Integer) }
+    def size; end
+
+    sig { returns(Integer) }
+    def count; end
+
+    sig { returns(T::Array[Symbol]) }
+    def keys; end
+
+    sig { params(key: Symbol).returns(T::Boolean) }
+    def key?(key); end
+
+    sig { params(key: Symbol).returns(T::Boolean) }
+    def has_key?(key); end
+
+    sig {
+      params(
+        key: Symbol,
+        texts: T.any(String, T::Array[String], Operandi::Message),
+        opts: T::Hash[Symbol, T.untyped],
+      ).void
+    }
+    def add(key, texts, opts = {}); end
+
+    sig { returns(T::Boolean) }
+    def break?; end
+
+    sig { params(entity: T.untyped, opts: T::Hash[Symbol, T.untyped]).void }
+    def copy_from(entity, opts = {}); end
+
+    sig { params(entity: T.untyped, opts: T::Hash[Symbol, T.untyped]).void }
+    def from_record(entity, opts = {}); end
+
+    sig { returns(T::Hash[Symbol, T::Array[String]]) }
+    def to_h; end
+  end
+
+  module Collection
+    class Base
+      sig { params(key: Symbol).returns(T::Boolean) }
+      def key?(key); end
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def to_h; end
+
+      sig { params(key: Symbol, value: T.untyped).returns(T.untyped) }
+      def set(key, value); end
+
+      sig { params(key: Symbol).returns(T.untyped) }
+      def get(key); end
+
+      sig { params(key: Symbol).returns(T.untyped) }
+      def [](key); end
+
+      sig { params(key: Symbol, value: T.untyped).returns(T.untyped) }
+      def []=(key, value); end
+
+      sig { void }
+      def load_defaults; end
+
+      sig { void }
+      def validate!; end
+
+      sig { params(args: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      def extend_with_context(args); end
+    end
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: operandi
+version: !ruby/object:Gem::Version
+  version: 5.0.0
+platform: ruby
+authors:
+- Andrew Kodkod
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Operandi is a simple yet powerful way to organize business logic in Ruby
+  applications. Build services that are easy to test, maintain, and understand.
+email:
+- andrew@kodkod.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".cursor/rules/services-rspec/RULE.md"
+- ".cursor/rules/services/RULE.md"
+- ".github/dependabot.yml"
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".vscode/cspell.json"
+- ".vscode/project-words.txt"
+- AGENTS.md
+- CHANGELOG.md
+- CLAUDE.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- config/default.yml
+- docs/README.md
+- docs/SUMMARY.md
+- docs/arguments.md
+- docs/best-practices.md
+- docs/callbacks.md
+- docs/concepts.md
+- docs/configuration.md
+- docs/context.md
+- docs/crud.md
+- docs/errors.md
+- docs/generators.md
+- docs/outputs.md
+- docs/pundit-authorization.md
+- docs/quickstart.md
+- docs/recipes.md
+- docs/rubocop.md
+- docs/ruby-lsp.md
+- docs/service-rendering.md
+- docs/sorbet-runtime.md
+- docs/steps.md
+- docs/tapioca.md
+- docs/testing.md
+- lib/generators/operandi/install/USAGE
+- lib/generators/operandi/install/install_generator.rb
+- lib/generators/operandi/install/templates/application_service.rb.tt
+- lib/generators/operandi/install/templates/application_service_spec.rb.tt
+- lib/generators/operandi/install/templates/initializer.rb.tt
+- lib/generators/operandi/service/USAGE
+- lib/generators/operandi/service/service_generator.rb
+- lib/generators/operandi/service/templates/service.rb.tt
+- lib/generators/operandi/service/templates/service_spec.rb.tt
+- lib/operandi.rb
+- lib/operandi/base.rb
+- lib/operandi/base_with_context.rb
+- lib/operandi/callbacks.rb
+- lib/operandi/collection.rb
+- lib/operandi/concerns/execution.rb
+- lib/operandi/concerns/parent_service.rb
+- lib/operandi/concerns/state_management.rb
+- lib/operandi/config.rb
+- lib/operandi/constants.rb
+- lib/operandi/dsl/arguments_dsl.rb
+- lib/operandi/dsl/outputs_dsl.rb
+- lib/operandi/dsl/steps_dsl.rb
+- lib/operandi/dsl/validation.rb
+- lib/operandi/exceptions.rb
+- lib/operandi/message.rb
+- lib/operandi/messages.rb
+- lib/operandi/rspec.rb
+- lib/operandi/rspec/matchers/define_argument.rb
+- lib/operandi/rspec/matchers/define_output.rb
+- lib/operandi/rspec/matchers/define_step.rb
+- lib/operandi/rspec/matchers/execute_step.rb
+- lib/operandi/rspec/matchers/have_error_on.rb
+- lib/operandi/rspec/matchers/have_warning_on.rb
+- lib/operandi/rspec/matchers/trigger_callback.rb
+- lib/operandi/rubocop.rb
+- lib/operandi/rubocop/cop/operandi/argument_type_required.rb
+- lib/operandi/rubocop/cop/operandi/condition_method_exists.rb
+- lib/operandi/rubocop/cop/operandi/deprecated_accessors.rb
+- lib/operandi/rubocop/cop/operandi/deprecated_methods.rb
+- lib/operandi/rubocop/cop/operandi/dsl_order.rb
+- lib/operandi/rubocop/cop/operandi/missing_private_keyword.rb
+- lib/operandi/rubocop/cop/operandi/no_direct_instantiation.rb
+- lib/operandi/rubocop/cop/operandi/no_hash_argument.rb
+- lib/operandi/rubocop/cop/operandi/output_type_required.rb
+- lib/operandi/rubocop/cop/operandi/prefer_fail_method.rb
+- lib/operandi/rubocop/cop/operandi/prefer_optional_over_default_nil.rb
+- lib/operandi/rubocop/cop/operandi/redundant_optional.rb
+- lib/operandi/rubocop/cop/operandi/reserved_name.rb
+- lib/operandi/rubocop/cop/operandi/step_method_exists.rb
+- lib/operandi/settings/field.rb
+- lib/operandi/settings/step.rb
+- lib/operandi/utils.rb
+- lib/operandi/version.rb
+- lib/ruby_lsp/operandi/addon.rb
+- lib/ruby_lsp/operandi/definition.rb
+- lib/ruby_lsp/operandi/indexing_enhancement.rb
+- lib/tapioca/dsl/compilers/operandi.rb
+- operandi.gemspec
+- rbi/operandi.rbi
+- sorbet/cache/data.mdb
+- sorbet/cache/lock.mdb
+homepage: https://operandi-docs.vercel.app/
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://operandi-docs.vercel.app/
+  source_code_uri: https://github.com/akodkod/operandi
+  changelog_uri: https://github.com/akodkod/operandi/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Robust service architecture for Ruby/Rails applications
+test_files: []