clean-architecture 5.0.2 → 6.0.0

data/lib/clean_architecture/use_cases/errors.rb

@@ -1,58 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require 'active_model'
-require 'active_support/core_ext/string/inflections'
-require 'forwardable'
-
-module CleanArchitecture
-  module UseCases
-    # Acts as a facade in front of ActiveModel::Errors implementing the bare minimum of the API
-    # It also implements the same interface as a FailureDetails so as to be interchangeable if
-    # passed back to code expecting a FailureDetails
-    class Errors
-      extend Forwardable
-      include ActiveModel::Translation
-
-      DEFAULT_FAILURE_DETAILS_TYPE = 'error'
-
-      def initialize(base, type = DEFAULT_FAILURE_DETAILS_TYPE)
-        @active_model_errors = ActiveModel::Errors.new(base)
-        @type = type
-      end
-
-      attr_reader :type
-
-      def message
-        full_messages.join(', ')
-      end
-
-      def other_properties
-        {}
-      end
-
-      def_delegators :@active_model_errors,
-                     :count,
-                     :each,
-                     :size,
-                     :clear,
-                     :blank?,
-                     :empty?,
-                     :add
-
-      ATTRIBUTE_NAME_HUMANIZE_OPTIONS = { capitalize: true, keep_id_suffix: false }
-      BASE_NAME = :base
-
-      def full_messages
-        @active_model_errors.messages.map do |attribute, messages|
-          attribute_name = if attribute == BASE_NAME
-            nil
-          else
-            ActiveSupport::Inflector.humanize(attribute, ATTRIBUTE_NAME_HUMANIZE_OPTIONS)
-          end
-          messages.map { |message| [attribute_name, message].compact.join(' ') }
-        end.flatten
-      end
-    end
-  end
-end

data/lib/clean_architecture/use_cases/form.rb

@@ -1,116 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require 'active_model'
-require 'clean_architecture/use_cases/errors'
-require 'clean_architecture/entities/failure_details'
-require 'dry/struct'
-require 'dry/monads/try'
-require 'dry/matcher/result_matcher'
-
-module CleanArchitecture
-  module UseCases
-    class Form
-      include ActiveModel::Conversion
-      include Dry::Monads::Try::Mixin
-      extend ActiveModel::Naming
-
-      attr_reader :errors, :context
-
-      def initialize(params: {}, context: {}, errors: UseCases::Errors.new(nil))
-        @params = params.to_h.symbolize_keys
-        @context = context
-        @errors = errors
-      end
-
-      def persisted?
-        false
-      end
-
-      # Attempts to create the parameter object returning a Dry::Monads::Result with either
-      # the parameter object or an exception
-      def to_parameter_object
-        @to_parameter_object ||= begin
-          use_case_class.parameters(parameter_object_hash.merge(context: context))
-        end
-      end
-
-      def with_errors(new_errors, override_params: nil)
-        self.class.new(
-          params: override_params || @params,
-          context: @context,
-          errors: ErrorsFactory.new(new_errors).manufacture
-        )
-      end
-
-      def with_error_message(message, override_params: nil)
-        new_errors = UseCases::Errors.new(nil)
-        new_errors.add(:base, message)
-        with_errors(new_errors, override_params: override_params)
-      end
-
-      def self.acts_as_form_for(use_case_class)
-        attribute_names = use_case_class.contract.__schema__.rules.keys
-
-        attribute_names.each do |attribute_name|
-          define_method attribute_name do
-            to_parameter_object[attribute_name]
-          end
-        end
-
-        define_method :use_case_class do
-          use_case_class
-        end
-      end
-
-      def self.prepopulate_with(_object, _context)
-        raise NotImplementedError, 'This form does not support prepopulation'
-      end
-
-      private
-
-      def attempt_parameter_object_hash_creation
-        errors.clear
-        parameter_object_hash
-      end
-
-      # This can be overridden for forms where the params don't map perfectly
-      # to the parameter object
-      def parameter_object_hash
-        @params
-      end
-
-      class ErrorsFactory
-        def initialize(errors)
-          @errors = errors
-        end
-
-        def manufacture
-          if @errors.is_a?(UseCases::Errors)
-            return @errors
-          elsif @errors.is_a?(Entities::FailureDetails)
-            return errors_from_failure_details
-          elsif @errors.is_a?(String)
-            return errors_from_string
-          end
-
-          raise ArgumentError, "Unable to handle errors of type: #{@errors.class}"
-        end
-
-        private
-
-        def errors_from_failure_details
-          errors = UseCases::Errors.new(nil)
-          errors.add(:base, @errors.message)
-          errors
-        end
-
-        def errors_from_string
-          errors = UseCases::Errors.new(nil)
-          errors.add(:base, @errors)
-          errors
-        end
-      end
-    end
-  end
-end

data/lib/clean_architecture/use_cases/parameters.rb

@@ -1,43 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require 'dry/monads/result'
-require 'clean_architecture/use_cases/errors'
-require 'forwardable'
-
-module CleanArchitecture
-  module UseCases
-    class Parameters
-      include Dry::Monads::Result::Mixin
-      extend Forwardable
-
-      def initialize(context, dry_validation_result)
-        @context = context
-        @dry_validation_result = dry_validation_result
-      end
-
-      def context(key)
-        @context.fetch(key)
-      end
-
-      def_delegators :@dry_validation_result,
-                     :[]
-
-      def to_monad
-        @dry_validation_result.success? ? Success(@dry_validation_result.to_h) : Failure(errors)
-      end
-
-      INVALID_PARAMS_FAILURE_TYPE = 'expectation_failed'
-
-      def errors
-        new_errors = Errors.new(nil, INVALID_PARAMS_FAILURE_TYPE)
-        @dry_validation_result.errors.to_h.each_pair do |invalid_attribute_key, error_messages|
-          error_messages.each do |error_message|
-            new_errors.add(invalid_attribute_key, error_message)
-          end
-        end
-        new_errors
-      end
-    end
-  end
-end

data/sorbet/rbi/gems/activemodel.rbi

@@ -1,75 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activemodel/all/activemodel.rbi
-#
-# activemodel-6.0.2.1
-
-module ActiveModel
-  def self.eager_load!; end
-  def self.gem_version; end
-  def self.version; end
-  extend ActiveSupport::Autoload
-end
-module ActiveModel::VERSION
-end
-module ActiveModel::Serializers
-  extend ActiveSupport::Autoload
-end
-class ActiveModel::Name
-  def !~(*args, &block); end
-  def <=>(*args, &block); end
-  def ==(arg); end
-  def ===(arg); end
-  def =~(*args, &block); end
-  def _singularize(string); end
-  def as_json(*args, &block); end
-  def cache_key; end
-  def collection; end
-  def element; end
-  def eql?(*args, &block); end
-  def human(options = nil); end
-  def i18n_key; end
-  def initialize(klass, namespace = nil, name = nil); end
-  def match?(*args, &block); end
-  def name; end
-  def param_key; end
-  def plural; end
-  def route_key; end
-  def singular; end
-  def singular_route_key; end
-  def to_s(*args, &block); end
-  def to_str(*args, &block); end
-  include Comparable
-end
-module ActiveModel::Naming
-  def model_name; end
-  def self.extended(base); end
-  def self.model_name_from_record_or_class(record_or_class); end
-  def self.param_key(record_or_class); end
-  def self.plural(record_or_class); end
-  def self.route_key(record_or_class); end
-  def self.singular(record_or_class); end
-  def self.singular_route_key(record_or_class); end
-  def self.uncountable?(record_or_class); end
-end
-module ActiveModel::Translation
-  def human_attribute_name(attribute, options = nil); end
-  def i18n_scope; end
-  def lookup_ancestors; end
-  include ActiveModel::Naming
-end
-module ActiveModel::Conversion
-  def to_key; end
-  def to_model; end
-  def to_param; end
-  def to_partial_path; end
-  extend ActiveSupport::Concern
-end
-module ActiveModel::Conversion::ClassMethods
-  def _to_partial_path; end
-end