solid-process 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3b27456b398dffc893e5034953dcb74baa2406beeafd8d88f1be31c26611d90
-  data.tar.gz: ac372ee023cc5730e80d00951dda408634efdcc0d25322406d4fe37c85313edf
+  metadata.gz: 973ae538a96362750bac5c31245c2e8390144c4d67688940fa8b28f2ee27e538
+  data.tar.gz: 057c4bbbd8e2c4fc955c548a714fdb7fbe4396e1b8d624dc7702cc4750e929fa
 SHA512:
-  metadata.gz: '09a4852a76e0e47ef0b3dd02554805647d33b500efb939cc1221f1ff48d538220db9ffa426df2774855d5a014a7de49d28e9e3e7660aca8bab4e12aa85286214'
-  data.tar.gz: 2074bc2fef703376047a43e273e138ec038dba78b228a5ec14655351954ecf5b5ad71e50a306480b0dda37d85c6b60920bff0a210581507469709ba52817c0f8
+  metadata.gz: 20c3a43c503dfc26560ca25cb20a3d4d53f2014de3f9883bfbd872e7759881fc636da985f335d53f9c9c81b730b797f9759649543b49644ddf2e774222a4d2cc
+  data.tar.gz: 3802c1bab8d942f351099e0510f9cfae3d86b110508cea3d96b61c4bd4eb5953c249b2280d4565bc3b02990744d908f229267edffc88eab38100664bebe83959

data/CHANGELOG.md

@@ -1,9 +1,88 @@
 ## [Unreleased]
 
+## [0.4.0] - 2024-06-23
+
+### Added
+
+- Add `Solid::Process.configuration(freeze: true)`.
+
+- Add `Solid::Process::EventLogs::BasicLoggerListener`.
+
+- Add `Solid::Process::BacktraceCleaner`.
+
+- Add `Solid::Process.configure` as an alias to `Solid::Process.configuration`.
+
+- Add `Solid::Value` to allow defining a value object.
+
+- `Solid::Model`
+  - Add `after_initialize` callback.
+  - Add `#[]` to access instance attributes.
+
+- `solid/validators`
+  - Add `id_validator`, to check if the value is a positive integer or a string that represents a positive integer.
+  - Add `is_validator`, to check if the value satisfy the given predicate methods.
+
+### Changed
+
+- Replace the usage of `deep_symbolize_keys` with `symbolize_keys` to perform the call more efficiently.
+
+- Change `email_validator` and `uuid_validator` to use `I18n` messages.
+
+- Relax `ActiveModel` dependency to `>= 6.0`.
+
+### Removed
+
+- Remove some validators:
+  - `bool_validator`
+  - `is_a_validator`
+  - `persisted_validator`
+
 ## [0.3.0] - 2024-04-14
 
+### Changed
+
+- Replace `bcdd-result` gem `solid-result` gem. This change removes the constant aliases `Solid::Output` and `Solid::Result`, as they are no longer needed.
+
 ## [0.2.0] - 2024-03-18
 
+### Added
+
+- Add `Solid::Process#success?`, `Solid::Process#failure?` that delegate to `Solid::Process#output.success?` and `Solid::Process#output.failure?`.
+
+- Add `Solid::Process#with` method to create a new process instance with new dependencies.
+
+- Add `Solid::Process#new` method. It's similar to `Solid::Process#with` but does not require passing the dependencies. If nothing is passed, it will use the same dependencies.
+
+- Add `rescue_from` (from `::ActiveSupport::Rescuable`) method to `Solid::Process` to rescue exceptions and return a `Solid::Output`.
+
+- Add `Solid::Process.config` and `Solid::Process.configuration` methods to define a configuration for all processes.
+
+### Changed
+
+- Move `Solid::Input` features to `Solid::Model` module. This change does not promote breaking changes.
+
 ## [0.1.0] - 2024-03-16
 
-- Initial release
+### Added
+
+- Add `Solid::Model` module to define a model with attributes and validations.
+  - It includes `ActiveModel::Api`, `ActiveModel::Access`, `ActiveModel::Attributes`, `ActiveModel::Dirty`, `ActiveModel::Validations::Callbacks`.
+
+- Add `Solid::Input` class (which includes `Solid::Model`) to define an input object with attributes and validations.
+
+- Add `Solid::Output` and `Solid::Result` as constant aliases of `BCDD::Context`.
+
+- Add `Solid::Success()` and `Solid::Failure()` methods to create `BCDD::Context` instances.
+
+- Add `Solid::Process` class to be inherited and define a process with inputs, outputs, and steps.
+
+- Add several ActiveModel validations to be used in `Solid::Model` and `Solid::Input` classes.
+  - `bool_validator`
+  - `email_validator`
+  - `instance_of_validator`
+  - `is_a_validator`
+  - `kind_of_validator`
+  - `persisted_validator`
+  - `respond_to_validator`
+  - `singleton_validator`
+  - `uuid_validator`

data/README.md

@@ -1,6 +1,6 @@
 <p align="center">
-  <h1 align="center" id="-solidprocess">🚄 Solid::Process</h1>
-  <p align="center"><i>Write self-documenting and self-observable business processes in Ruby/Rails.</i></p>
+  <h1 align="center" id="-solidprocess">⚛️ Solid::Process</h1>
+  <p align="center"><i>Write business logic for Ruby/Rails that scales.</i></p>
   <p align="center">
     <a href="https://codeclimate.com/github/solid-process/solid-process/maintainability"><img src="https://api.codeclimate.com/v1/badges/643a53e99bb591321c9f/maintainability" /></a>
     <a href="https://codeclimate.com/github/solid-process/solid-process/test_coverage"><img src="https://api.codeclimate.com/v1/badges/643a53e99bb591321c9f/test_coverage" /></a>
@@ -22,6 +22,26 @@ This library is tested against:
 | 3.3          | ✅  | ✅  | ✅  | ✅   | ✅   |
 | Head         |    |    |    | ✅   | ✅   |
 
+## Introduction
+
+`solid-process` is a Ruby/Rails library designed to encapsulate business logic into manageable processes. It simplifies writing, testing, maintaining, and evolving your code, ensuring it remains clear and approachable as your application scales.
+
+**Key Objectives:**
+
+1. **Seamless Rails integration:** Designed to fully complement the Ruby on Rails framework, this library integrates smoothly without conflicting with existing Rails conventions and capabilities.
+
+2. **Support progressive mastery:** Offers an intuitive entry point for novices while providing robust, advanced features that cater to experienced developers.
+
+3. **Promote conceptual integrity and rapid onboarding:** By maintaining a consistent design philosophy, `solid-process` reduces the learning curve for new developers, allowing them to contribute more effectively and quickly.
+
+4. **Minimize technical debt:** Facilitate smoother transitions and updates as your application expands and your team size increases.
+
+5. **Enhanced observability:** Equipped with sophisticated instrumentation mechanisms, the library enables detailed logging and tracing without compromising clarity, even when processes are nested. This ensures the code is both easy to understand and to observe.
+
+### Examples
+
+Checkout the [solid-rails-app](https://github.com/solid-process/solid-rails-app) for a full example of how to use `solid-process` in a Rails application. Or take a look at the [examples](examples) folder in this repository.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/solid/input.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "model"
-
 class Solid::Input
   include ::Solid::Model
 end

data/lib/solid/model.rb

@@ -5,6 +5,16 @@ require_relative "model/access"
 module Solid::Model
   extend ::ActiveSupport::Concern
 
+  module ClassMethods
+    def [](...)
+      new(...)
+    end
+
+    def inherited(subclass)
+      subclass.include(::Solid::Model)
+    end
+  end
+
   included do
     include ::ActiveModel.const_defined?(:Api, false) ? ::ActiveModel::Api : ::ActiveModel::Model
     include ::ActiveModel.const_defined?(:Access, false) ? ::ActiveModel::Access : ::Solid::Model::Access
@@ -12,19 +22,21 @@ module Solid::Model
     include ::ActiveModel::Attributes
     include ::ActiveModel::Dirty
     include ::ActiveModel::Validations::Callbacks
+
+    extend ActiveModel::Callbacks
+
+    define_model_callbacks :initialize, only: :after
   end
 
-  module ClassMethods
-    def [](...)
-      new(...)
-    end
+  def initialize(...)
+    super
 
-    def inherited(subclass)
-      subclass.include(::Solid::Model)
-    end
+    run_callbacks(:initialize)
   end
 
   def inspect
     "#<#{self.class.name} #{attributes.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>"
   end
+
+  alias_method :[], :public_send
 end

data/lib/solid/output.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "solid/result"
+
+module Solid
+  def self.Success(...)
+    ::Solid::Output::Success(...)
+  end
+
+  def self.Failure(...)
+    ::Solid::Output::Failure(...)
+  end
+end

data/lib/solid/process/backtrace_cleaner.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Solid::Process::BacktraceCleaner < ActiveSupport::BacktraceCleaner
+  def initialize
+    super
+
+    add_blocks_silencer
+  end
+
+  private
+
+  BLOCKS_PATTERN = /in [`']block in|in `then'|internal:kernel|block \(\d+ levels?\) in/.freeze
+
+  def add_blocks_silencer
+    add_silencer { |line| line.match?(BLOCKS_PATTERN) }
+  end
+end

data/lib/solid/process/caller.rb

@@ -16,7 +16,7 @@ class Solid::Process
             elsif input.invalid?
               Failure(:invalid_input, input: input)
             else
-              super(input.attributes.deep_symbolize_keys)
+              super(input.attributes.symbolize_keys)
             end
         rescue ::Exception => exception
           rescue_with_handler(exception) || raise

data/lib/solid/process/event_logs/basic_logger_listener.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class Solid::Process::EventLogs::BasicLoggerListener
+  include ActiveSupport::Configurable
+  include Solid::Result::EventLogs::Listener
+
+  config_accessor(:logger, :backtrace_cleaner)
+
+  self.logger = ActiveSupport::Logger.new($stdout)
+  self.backtrace_cleaner = Solid::Process::BacktraceCleaner.new
+
+  module MessagesNesting
+    MAP_STEP_METHOD = lambda do |record_result|
+      kind, type, value = record_result.values_at(:kind, :type, :value)
+
+      value_keys = "#{value.keys.join(":, ")}:"
+      value_keys = "" if value_keys == ":"
+
+      case type
+      when :_given_ then "Given(#{value_keys})"
+      when :_continue_ then "Continue(#{value_keys})"
+      else "#{kind.capitalize}(:#{type}, #{value_keys})"
+      end
+    end
+
+    MAP_STEP_MESSAGE = lambda do |record|
+      step = MAP_STEP_METHOD[record[:result]]
+
+      method_name = record.dig(:and_then, :method_name)
+
+      " * #{step} from method: #{method_name}".chomp("from method: ").chomp(" ")
+    end
+
+    MAP_IDS_WITH_MESSAGES = lambda do |records|
+      process_ids = []
+
+      records.each_with_object([]) do |record, messages|
+        current = record[:current]
+
+        current_id = current[:id]
+
+        unless process_ids.include?(current_id)
+          process_ids << current_id
+
+          id, name, desc = current.values_at(:id, :name, :desc)
+
+          messages << [current_id, "##{id} #{name} - #{desc}".chomp("- ").chomp(" ")]
+        end
+
+        messages << [current_id, MAP_STEP_MESSAGE[record]]
+      end
+    end
+
+    def self.map(event_logs)
+      ids_level_parent = event_logs.dig(:metadata, :ids, :level_parent)
+
+      messages = MAP_IDS_WITH_MESSAGES[event_logs[:records]]
+
+      messages.map { |(id, msg)| "#{"   " * ids_level_parent[id].first}#{msg}" }
+    end
+  end
+
+  def on_finish(event_logs:)
+    messages = MessagesNesting.map(event_logs)
+
+    logger.info messages.join("\n")
+  end
+
+  def before_interruption(exception:, event_logs:)
+    messages = MessagesNesting.map(event_logs)
+
+    logger.info messages.join("\n")
+
+    cleaned_backtrace = backtrace_cleaner.clean(exception.backtrace).join("\n  ")
+
+    logger.error "\nException:\n  #{exception.message} (#{exception.class})\n\nBacktrace:\n  #{cleaned_backtrace}"
+  end
+end

data/lib/solid/process/event_logs.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Solid::Process
+  module EventLogs
+    require_relative "event_logs/basic_logger_listener"
+  end
+end

data/lib/solid/process/version.rb

@@ -2,6 +2,6 @@
 
 module Solid
   class Process
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/solid/process.rb

@@ -2,18 +2,12 @@
 
 require "active_support/all"
 require "active_model"
-require "solid/result"
 
 module Solid
-  require "solid/input"
-
-  def self.Success(...)
-    ::Solid::Output::Success(...)
-  end
-
-  def self.Failure(...)
-    ::Solid::Output::Failure(...)
-  end
+  require_relative "model"
+  require_relative "value"
+  require_relative "input"
+  require_relative "output"
 
   class Process
     require "solid/process/version"
@@ -23,6 +17,8 @@ module Solid
     require "solid/process/callbacks"
     require "solid/process/class_methods"
     require "solid/process/active_record"
+    require "solid/process/backtrace_cleaner"
+    require "solid/process/event_logs"
 
     extend ClassMethods
 
@@ -40,15 +36,17 @@ module Solid
       new.call(arg)
     end
 
-    def self.configuration(&block)
+    def self.config
+      Config.instance
+    end
+
+    def self.configuration(freeze: true, &block)
       yield config
 
-      config.freeze
+      config.tap { _1.freeze if freeze }
     end
 
-    def self.config
-      Config.instance
-    end
+    singleton_class.alias_method :configure, :configuration
 
     attr_reader :output, :input, :dependencies
 

data/lib/solid/validators/email_validator.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 class EmailValidator < ActiveModel::EachValidator
-  def validate_each(obj, attribute, value)
+  def validate_each(model, attribute, value)
+    return model.errors.add(attribute, :blank, **options) if value.blank?
+
     return if value.is_a?(String) && URI::MailTo::EMAIL_REGEXP.match?(value)
 
-    obj.errors.add attribute, (options[:message] || "is not an email")
+    model.errors.add(attribute, :invalid, **options)
   end
 end

data/lib/solid/validators/id_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "solid/validators"
+
+class IdValidator < ActiveModel::EachValidator
+  OPTIONS = {only_integer: true, greater_than: 0}.freeze
+
+  def validate_each(model, attribute, value)
+    opts = OPTIONS.merge(options.except(*OPTIONS.keys))
+
+    opts[:attributes] = attribute
+
+    ::ActiveModel::Validations::NumericalityValidator.new(opts).validate_each(model, attribute, value)
+  end
+
+  private_constant :OPTIONS
+end

data/lib/solid/validators/instance_of_validator.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
+require "solid/validators"
+
 class InstanceOfValidator < ActiveModel::EachValidator
-  def validate_each(obj, attribute, value)
+  def validate_each(model, attribute, value)
     with_option = Array.wrap(options[:with] || options[:in])
 
     return if with_option.any? { |type| value.instance_of?(type) }
 
-    expectation = with_option.map(&:name).join(" | ")
+    message = "is not an instance of #{with_option.map(&:name).join(" | ")}"
 
-    obj.errors.add(attribute, (options[:message] || "is not an instance of #{expectation}"))
+    Solid::Validators.add_error(model, attribute, message, options)
   end
 end

data/lib/solid/validators/is_validator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "solid/validators"
+
+class IsValidator < ActiveModel::EachValidator
+  def validate_each(model, attribute, value)
+    with_option = Array.wrap(options[:with] || options[:in])
+
+    return if with_option.all? do |predicate|
+      raise ArgumentError, "expected a predicate method, got #{predicate.inspect}" unless predicate.end_with?("?")
+
+      value.try(predicate)
+    end
+
+    message = "does not satisfy the predicate#{"s" if with_option.size > 1}: #{with_option.join(" & ")}"
+
+    Solid::Validators.add_error(model, attribute, message, options)
+  end
+end

data/lib/solid/validators/kind_of_validator.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
+require "solid/validators"
+
 class KindOfValidator < ActiveModel::EachValidator
-  def validate_each(obj, attribute, value)
+  def validate_each(model, attribute, value)
     with_option = Array.wrap(options[:with] || options[:in])
 
     return if with_option.any? { |type| value.is_a?(type) }
 
-    expectation = with_option.map(&:name).join(" | ")
+    message = "is not a #{with_option.map(&:name).join(" | ")}"
 
-    obj.errors.add(attribute, (options[:message] || "is not a #{expectation}"))
+    Solid::Validators.add_error(model, attribute, message, options)
   end
 end

data/lib/solid/validators/respond_to_validator.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
+require "solid/validators"
+
 class RespondToValidator < ActiveModel::EachValidator
-  def validate_each(obj, attribute, value)
+  def validate_each(model, attribute, value)
     with_option = Array.wrap(options[:with] || options[:in])
 
     return if with_option.all? { value.respond_to?(_1) }
 
-    expectation = with_option.map(&:inspect).join(" & ")
+    message = "does not respond to #{with_option.map(&:inspect).join(" & ")}"
 
-    obj.errors.add(attribute, (options[:message] || "does not respond to #{expectation}"))
+    Solid::Validators.add_error(model, attribute, message, options)
   end
 end

data/lib/solid/validators/singleton_validator.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
+require "solid/validators"
+
 class SingletonValidator < ActiveModel::EachValidator
-  def validate_each(obj, attribute, value)
+  def validate_each(model, attribute, value)
     with_option = Array.wrap(options[:with] || options[:in])
 
-    unless value.is_a?(Module)
-      return obj.errors.add(attribute, options[:message] || "is not a class or module")
-    end
+    return model.errors.add(attribute, options[:message] || "is not a class or module") unless value.is_a?(Module)
 
-    is_valid = with_option.any? do |type|
-      type.is_a?(Module) or raise ArgumentError, "#{type.inspect} is not a class or module"
+    return if with_option.any? do |type|
+      raise ArgumentError, "#{type.inspect} is not a class or module" unless type.is_a?(Module)
 
       value == type || (value < type || value.is_a?(type))
     end
 
-    expectation = with_option.map(&:name).join(" | ")
+    message = "is not #{with_option.map(&:name).join(" | ")}"
 
-    is_valid or obj.errors.add(attribute, (options[:message] || "is not #{expectation}"))
+    Solid::Validators.add_error(model, attribute, message, options)
   end
 end

data/lib/solid/validators/uuid_validator.rb

@@ -5,16 +5,16 @@ class UuidValidator < ActiveModel::EachValidator
   CASE_SENSITIVE = /\A#{PATTERN}\z/.freeze
   CASE_INSENSITIVE = /\A#{PATTERN}\z/i.freeze
 
-  def validate_each(obj, attribute, value)
+  def validate_each(model, attribute, value)
     case_sensitive = options.fetch(:case_sensitive, true)
 
+    return model.errors.add(attribute, :blank, **options) if value.blank?
+
     regexp = case_sensitive ? CASE_SENSITIVE : CASE_INSENSITIVE
 
     return if value.is_a?(String) && value.match?(regexp)
 
-    message = options[:message] || "is not a valid UUID (case #{case_sensitive ? "sensitive" : "insensitive"})"
-
-    obj.errors.add(attribute, message)
+    model.errors.add(attribute, :invalid, **options)
   end
 
   private_constant :PATTERN

data/lib/solid/validators.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solid
+  module Validators
+    def self.add_error(model, attribute, message, options)
+      if ActiveModel.const_defined?(:Error)
+        model.errors.add(attribute, **options.merge(message: message))
+      else
+        model.errors.add(attribute, options.fetch(:message, message))
+      end
+    end
+  end
+end

data/lib/solid/value.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Solid::Value
+  module ClassMethods
+    UNDEFINED = ::Object.new
+
+    def new(value = UNDEFINED)
+      return value if value.is_a?(self)
+
+      UNDEFINED.equal?(value) ? super() : super(value: value)
+    end
+
+    def attribute(...)
+      super(:value, ...)
+    end
+
+    def validates(...)
+      super(:value, ...)
+    end
+  end
+
+  def self.included(subclass)
+    subclass.include Solid::Model
+    subclass.extend ClassMethods
+    subclass.attribute
+  end
+
+  def ==(other)
+    other.is_a?(self.class) && other.value == value
+  end
+
+  def hash
+    value.hash
+  end
+
+  def to_s
+    value.to_s
+  end
+
+  alias_method :eql?, :==
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid-process
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-14 00:00:00.000000000 Z
+date: 2024-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: solid-result
@@ -31,9 +31,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -41,9 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -58,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.5'
-description: Write self-documenting and self-observable business processes in Ruby/Rails.
+description: Write business logic for Ruby/Rails that scales.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
@@ -87,24 +81,28 @@ files:
 - lib/solid/input.rb
 - lib/solid/model.rb
 - lib/solid/model/access.rb
+- lib/solid/output.rb
 - lib/solid/process.rb
 - lib/solid/process/active_record.rb
+- lib/solid/process/backtrace_cleaner.rb
 - lib/solid/process/callbacks.rb
 - lib/solid/process/caller.rb
 - lib/solid/process/class_methods.rb
 - lib/solid/process/config.rb
 - lib/solid/process/error.rb
+- lib/solid/process/event_logs.rb
+- lib/solid/process/event_logs/basic_logger_listener.rb
 - lib/solid/process/version.rb
-- lib/solid/validators/all.rb
-- lib/solid/validators/bool_validator.rb
+- lib/solid/validators.rb
 - lib/solid/validators/email_validator.rb
+- lib/solid/validators/id_validator.rb
 - lib/solid/validators/instance_of_validator.rb
-- lib/solid/validators/is_a_validator.rb
+- lib/solid/validators/is_validator.rb
 - lib/solid/validators/kind_of_validator.rb
-- lib/solid/validators/persisted_validator.rb
 - lib/solid/validators/respond_to_validator.rb
 - lib/solid/validators/singleton_validator.rb
 - lib/solid/validators/uuid_validator.rb
+- lib/solid/value.rb
 homepage: https://github.com/serradura/solid-process
 licenses:
 - MIT
@@ -128,8 +126,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
-summary: Write self-documenting and self-observable business processes in Ruby/Rails.
+summary: Write business logic for Ruby/Rails that scales.
 test_files: []

data/lib/solid/validators/all.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "instance_of_validator"
-require_relative "is_a_validator"
-require_relative "kind_of_validator"
-require_relative "respond_to_validator"
-require_relative "singleton_validator"
-
-require_relative "bool_validator"
-require_relative "email_validator"
-require_relative "persisted_validator"
-require_relative "uuid_validator"

data/lib/solid/validators/bool_validator.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class BoolValidator < ActiveModel::EachValidator
-  def validate_each(obj, attribute, value)
-    return if value == true || value == false
-
-    obj.errors.add attribute, (options[:message] || "is not a boolean")
-  end
-end

data/lib/solid/validators/is_a_validator.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "kind_of_validator"
-
-class IsAValidator < KindOfValidator
-end

data/lib/solid/validators/persisted_validator.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class PersistedValidator < ActiveModel::EachValidator
-  def validate_each(record, attribute, value)
-    return if (options[:allow_nil] && value.nil?) || value.try(:persisted?)
-
-    record.errors.add(attribute, (options[:message] || "must be persisted"))
-  end
-end