clean-architecture 5.0.2 → 6.0.0

data/bin/tapioca

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("tapioca", "tapioca")

data/clean-architecture.gemspec

@@ -28,13 +28,13 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'activemodel', '>= 5'
   spec.add_dependency 'activesupport', '>= 5'
+  spec.add_dependency 'activerecord', '>= 5'
   spec.add_dependency 'dry-matcher'
   spec.add_dependency 'dry-monads'
-  spec.add_dependency 'dry-struct'
-  spec.add_dependency 'dry-types'
-  spec.add_dependency 'dry-validation', '>= 1.0.0'
-  spec.add_dependency 'duckface-interfaces'
+  spec.add_dependency 'dry-monads-sorbet'
+  spec.add_dependency 'sorbet'
   spec.add_dependency 'sorbet-runtime'
+  spec.add_dependency 'sorbet-struct-comparable'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '>= 12.0'

data/lib/clean-architecture.rb

@@ -1,4 +1,7 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
+require 'sorbet-runtime'
+require 'dry-monads-sorbet'
+require 'sorbet-struct-comparable'
 require 'clean_architecture/all'

data/lib/clean_architecture/adapters/all.rb

@@ -1,4 +1,4 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
 # THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MANUALLY MODIFIED

data/lib/clean_architecture/adapters/attribute_hash_base.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require 'time'
@@ -12,114 +12,141 @@ module CleanArchitecture
       # Error raised if an expected value isn't present or isn't the type we expect
       class EmptyOrIncorrectAttributeTypeError < StandardError; end
 
+      extend T::Sig
+
+      sig { params(attribute_hash: T::Hash[Object, Object]).void }
       def initialize(attribute_hash)
         @attribute_hash = attribute_hash
       end
 
       protected
 
+      sig { returns(T::Hash[Object, Object]) }
       attr_reader :attribute_hash
 
       private
 
-      def ensured_value(default:)
-        yield
+      sig { params(default: Object, block: T.proc.returns(T.nilable(Object))).returns(Object) }
+      def ensured_value(default:, &block)
+        block.call || default
       rescue EmptyOrIncorrectAttributeTypeError, TypeError, ArgumentError
         default
       end
 
-      def maybe_value
-        ensured_value(default: nil) { yield }
+      sig { params(block: T.proc.returns(T.nilable(Object))).returns(T.nilable(Object)) }
+      def maybe_value(&block)
+        ensured_value(default: nil) { block.call }
       end
 
+      sig { params(key: Object).returns(T::Boolean) }
       def boolean_value(key)
         raw_value(key).to_s == 'true'
       end
 
+      sig { params(key: Object, adapter_class: Class).returns(Object) }
       def complex_object_value(key, adapter_class)
-        adapter_class.new(raw_value(key))
+        T.unsafe(adapter_class).new(raw_value(key))
       end
 
+      sig { params(key: Object, adapter_class: Class, additional_arguments: Object).returns(T::Array[Object]) }
       def complex_object_list_value(key, adapter_class, additional_arguments = [])
         array = maybe_raw_value(key) || []
         unless array.is_a?(Array)
           raise EmptyOrIncorrectAttributeTypeError, "value at key #{key} is not an array!"
         end
-        array.map { |array_entry| adapter_class.new(array_entry, *additional_arguments) }
+        array.map { |array_entry| T.unsafe(adapter_class).new(array_entry, *additional_arguments) }
       end
 
+      sig { params(key: Object).returns(Float) }
       def currency_value(key)
-        float_value(key).round(2)
+        float_value(key).round(2).to_f
       end
 
+      sig { params(key: Object).returns(Date) }
       def date_value(key)
-        Date.parse(raw_value(key))
+        Date.parse(raw_value(key).to_s)
       end
 
+      sig { params(key: Object).returns(Time) }
       def time_value(key)
-        Time.parse(raw_value(key))
+        Time.parse(raw_value(key).to_s)
       end
 
+      sig { params(key: Object).returns(Time) }
       def date_time_value(key)
-        Time.strptime(raw_value(key), '%Y-%m-%dT%H:%M:%S.%L%z')
+        Time.strptime(raw_value(key).to_s, '%Y-%m-%dT%H:%M:%S.%L%z')
       end
 
+      sig { params(key: Object).returns(Float) }
       def float_value(key)
-        raw_value(key).to_f
+        raw_value(key).to_s.to_f
       end
 
+      sig { params(key: Object).returns(Integer) }
       def int_value(key)
-        raw_value(key).to_i
+        raw_value(key).to_s.to_i
       end
 
+      sig { params(key: Object).returns(Regexp) }
       def regex_value(key)
         raw_pattern = raw_value(key)
         return raw_pattern if raw_pattern.is_a?(Regexp)
         /#{raw_pattern}/
       end
 
+      sig { params(key: Object, adapter_class: Class).returns(T.nilable(Object)) }
       def maybe_complex_object_value(key, adapter_class)
         maybe_value { complex_object_value(key, adapter_class) }
       end
 
+      sig { params(key: Object).returns(T.nilable(Date)) }
       def maybe_date_value(key)
-        maybe_value { date_value(key) }
+        T.cast(maybe_value { date_value(key) }, T.nilable(Date))
       end
 
+      sig { params(key: Object).returns(T.nilable(Time)) }
       def maybe_time_value(key)
-        maybe_value { time_value(key) }
+        T.cast(maybe_value { time_value(key) }, T.nilable(Time))
       end
 
+      sig { params(key: Object).returns(T.nilable(Time)) }
       def maybe_date_time_value(key)
-        maybe_value { date_time_value(key) }
+        T.cast(maybe_value { date_time_value(key) }, T.nilable(Time))
       end
 
+      sig { params(key: Object).returns(T.nilable(Integer)) }
       def maybe_int_value(key)
-        maybe_value { int_value(key) }
+        T.cast(maybe_value { int_value(key) }, T.nilable(Integer))
       end
 
+      sig { params(key: Object).returns(T.nilable(Float)) }
       def maybe_float_value(key)
-        maybe_value { float_value(key) }
+        T.cast(maybe_value { float_value(key) }, T.nilable(Float))
       end
 
+      sig { params(key: Object).returns(T.nilable(String)) }
       def maybe_string_value(key)
-        maybe_value { string_value(key) }
+        T.cast(maybe_value { string_value(key) }, T.nilable(String))
       end
 
+      sig { params(key: Object).returns(String) }
       def string_value(key)
         raw_value(key).to_s
       end
 
+      sig { params(key: Object).returns(Symbol) }
       def symbol_value(key)
         string_value(key).to_sym
       end
 
+      sig { params(key: Object).returns(T.nilable(Object)) }
       def maybe_raw_value(key)
         maybe_value { raw_value(key) }
       end
 
-      EMPTY_VALUES = [nil, ''].freeze
+      EMPTY_VALUES = T.let([nil, ''].freeze, T::Array[Object])
 
+      sig { params(key: Object).returns(Object) }
       def raw_value(key)
         value = @attribute_hash[key]
         if EMPTY_VALUES.include?(value)

data/lib/clean_architecture/all.rb

@@ -1,4 +1,4 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
 # THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MANUALLY MODIFIED
@@ -7,11 +7,8 @@ require 'clean_architecture/adapters/all'
 require 'clean_architecture/builders/all'
 require 'clean_architecture/checks/all'
 require 'clean_architecture/entities/all'
-require 'clean_architecture/interfaces/all'
 require 'clean_architecture/matchers/all'
 require 'clean_architecture/queries/all'
 require 'clean_architecture/serializers/all'
-require 'clean_architecture/use_cases/all'
 
-require 'clean_architecture/types'
 require 'clean_architecture/version'

data/lib/clean_architecture/builders/abstract_active_record_entity_builder.rb

@@ -1,13 +1,17 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require 'active_record'
+
 module CleanArchitecture
   module Builders
     # Helps to take an instance of an AR model and wrap it up in the given Entity
     # Any columns from the AR model that do not directly map to an attribute on the Entity
     # can be specified by overriding #attributes_for_entity.
     class AbstractActiveRecordEntityBuilder
-      # @param [Class] A Dry::Struct based entity that this builder will construct instances of
+      extend T::Sig
+
+      sig { params(entity_class: T.class_of(T::Struct)).void }
       def self.acts_as_builder_for_entity(entity_class)
         @has_many_builders = []
         @belongs_to_builders = []
@@ -27,33 +31,44 @@ module CleanArchitecture
         private :entity_class
       end
 
+      sig { params(relation_name: Symbol, use: Class).void }
       def self.has_many(relation_name, use:)
-        @has_many_builders << [relation_name, use]
+        @has_many_builders = T.let(@has_many_builders, T.nilable(T::Array[Object]))
+        T.must(@has_many_builders) << [relation_name, use]
       end
 
+      sig { params(relation_name: Symbol, use: Class).void }
       def self.belongs_to(relation_name, use:)
-        @belongs_to_builders << [relation_name, use]
+        @belongs_to_builders = T.let(@belongs_to_builders, T.nilable(T::Array[Object]))
+        T.must(@belongs_to_builders) << [relation_name, use]
       end
 
-      # @param [ActiveRecord::Base] An ActiveRecord model to map to the entity
+      sig { params(ar_model_instance: ActiveRecord::Base).void }
       def initialize(ar_model_instance)
         @ar_model_instance = ar_model_instance
       end
 
+      sig { returns(T::Struct) }
       def build
-        entity_class.new(all_attributes_for_entity)
+        specified_entity_class.new(all_attributes_for_entity)
+      end
+
+      sig { returns(T.class_of(T::Struct)) }
+      def specified_entity_class
+        send(:entity_class)
       end
 
       private
 
+      sig { returns(ActiveRecord::Base) }
       attr_reader :ar_model_instance
 
+      sig { returns(T::Array[Symbol]) }
       def entity_attribute_names
+        @entity_attributes = T.let(@entity_attributes, T.nilable(T::Array[Symbol]))
         @entity_attributes ||= begin
-          if entity_class.respond_to?(:schema) # Dry::Struct
-            schema_keys = entity_class.schema.keys
-          elsif entity_class.respond_to?(:decorator) # T::Struct
-            schema_keys = entity_class.decorator.props.keys
+          if specified_entity_class.respond_to?(:decorator) # T::Struct
+            schema_keys = specified_entity_class.decorator.props.keys
           else
             raise 'Cannot determine schema format'
           end
@@ -68,22 +83,34 @@ module CleanArchitecture
         end
       end
 
+      sig { returns(T::Hash[Symbol, Object]) }
       def ar_model_instance_attributes
+        @ar_model_instance_attributes = T.let(
+          @ar_model_instance_attributes,
+          T.nilable(T::Hash[Symbol, Object])
+        )
         @ar_model_instance_attributes ||= @ar_model_instance.attributes
       end
 
+      sig { returns(T::Hash[Symbol, Object]) }
       def symbolized_ar_model_instance_attributes
+        @symbolized_ar_model_instance_attributes = T.let(
+          @symbolized_ar_model_instance_attributes,
+          T.nilable(T::Hash[Symbol, Object])
+        )
         @symbolized_ar_model_instance_attributes ||= Hash[
           ar_model_instance_attributes.map{|(key, value)| [key.to_sym, value]}
         ]
       end
 
+      sig { returns(T::Hash[Symbol, Object]) }
       def ar_attributes_for_entity
-        symbolized_ar_model_instance_attributes.slice(*entity_attribute_names)
+        T.unsafe(symbolized_ar_model_instance_attributes).slice(*entity_attribute_names)
       end
 
+      sig { returns(T::Hash[Symbol, Object]) }
       def attributes_for_belongs_to_relations
-        self.class.belongs_to_builders.map do |belongs_to_builder_config|
+        T.unsafe(self.class).belongs_to_builders.map do |belongs_to_builder_config|
           relation_name, builder_class = belongs_to_builder_config
           relation = @ar_model_instance.public_send(relation_name)
 
@@ -94,8 +121,9 @@ module CleanArchitecture
         end.to_h
       end
 
+      sig { returns(T::Hash[Symbol, Object]) }
       def attributes_for_has_many_relations
-        self.class.has_many_builders.map do |has_many_builder_config|
+        T.unsafe(self.class).has_many_builders.map do |has_many_builder_config|
           relation_name, builder_class = has_many_builder_config
           relations = @ar_model_instance.public_send(relation_name)
           built_relations = relations.map do |relation|
@@ -109,10 +137,12 @@ module CleanArchitecture
         end.to_h
       end
 
+      sig { returns(T::Hash[Symbol, Object]) }
       def attributes_for_entity
         {}
       end
 
+      sig { returns(T::Hash[Symbol, Object]) }
       def all_attributes_for_entity
         ar_attributes_for_entity
           .merge(attributes_for_belongs_to_relations)

data/lib/clean_architecture/builders/all.rb

@@ -1,4 +1,4 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
 # THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MANUALLY MODIFIED

data/lib/clean_architecture/checks/all.rb

@@ -1,4 +1,4 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
 # THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MANUALLY MODIFIED

data/lib/clean_architecture/checks/authorization.rb

@@ -1,23 +1,25 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require 'dry/monads/all'
 require 'clean_architecture/entities/failure_details'
-require 'forwardable'
 
 module CleanArchitecture
   module Checks
     class Authorization
-      extend Forwardable
+      extend T::Sig
+      extend T::Helpers
 
+      abstract!
+
+      sig { returns(Dry::Monads::Result[Entities::FailureDetails, NilClass]) }
       def result
         if authorized?
-          Dry::Monads::Success(true)
+          Dry::Monads::Success(nil)
         else
           failure_details = Entities::FailureDetails.new(
             message: failure_message,
-            other_properties: {},
-            type: 'unauthorized'
+            type: Entities::FailureType::Unauthorized
           )
           Dry::Monads::Failure(failure_details)
         end
@@ -25,13 +27,13 @@ module CleanArchitecture
 
       protected
 
+      sig { returns(String) }
       def failure_message
         'Unauthorized'
       end
 
-      def authorized?
-        raise NotImplementedError
-      end
+      sig { abstract.returns(T::Boolean) }
+      def authorized?; end
     end
   end
 end

data/lib/clean_architecture/entities/all.rb

@@ -1,8 +1,6 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
 # THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MANUALLY MODIFIED
 
 require 'clean_architecture/entities/failure_details'
-require 'clean_architecture/entities/targeted_parameters'
-require 'clean_architecture/entities/untargeted_parameters'

data/lib/clean_architecture/entities/failure_details.rb

@@ -1,30 +1,40 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require 'clean_architecture/types'
-require 'dry/struct'
-
 module CleanArchitecture
   module Entities
-    class FailureDetails < Dry::Struct
-      FailureTypes = Types::Strict::String.enum(
-        'error',
-        'expectation_failed',
-        'not_found',
-        'unauthorized',
-        'unprocessable_entity'
-      )
+    class FailureType < T::Enum
+      enums do
+        Error = new('internal_server_error')
+        ExpectationFailed = new('expectation_failed')
+        NotFound = new('not_found')
+        Unauthorized = new('unauthorized')
+        UnprocessableEntity = new('unprocessable_entity')
+      end
+    end
+
+    class FailureDetails < T::Struct
+      extend T::Sig
+
+      include T::Struct::ActsAsComparable
 
-      attribute :type, FailureTypes
-      attribute :message, Types::Strict::String
-      attribute :other_properties, Types::Strict::Hash.default({}.freeze)
+      const :type, FailureType
+      const :message, String
 
+      sig { params(array: T::Array[Object]).returns(FailureDetails) }
       def self.from_array(array)
-        new(message: array.map(&:to_s).join(', '), other_properties: {}, type: 'error')
+        new(
+          message: array.map(&:to_s).join(', '),
+          type: FailureType::Error
+        )
       end
 
+      sig { params(string: String).returns(FailureDetails) }
       def self.from_string(string)
-        new(message: string, other_properties: {}, type: 'error')
+        new(
+          message: string,
+          type: FailureType::Error
+        )
       end
     end
   end

data/lib/clean_architecture/matchers/all.rb

@@ -1,4 +1,4 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
 # THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MANUALLY MODIFIED

data/lib/clean_architecture/matchers/use_case_result.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require 'clean_architecture/entities/failure_details'
@@ -8,16 +8,21 @@ require 'dry/monads/all'
 module CleanArchitecture
   module Matchers
     class UseCaseResult
+      extend T::Sig
+
+      sig { params(result: Dry::Monads::Result[T.any(T::Array[Object], String, Entities::FailureDetails), T.untyped], block: T.untyped).returns(T.untyped) }
       def self.call(result, &block)
         new.matcher.call(result, &block)
       end
 
+      sig {returns(Dry::Matcher)}
       def matcher
         Dry::Matcher.new(success: success_case, failure: failure_case)
       end
 
       private
 
+      sig { returns(Dry::Matcher::Case) }
       def success_case
         Dry::Matcher::Case.new(
           match: ->(value) { value.is_a?(Dry::Monads::Success) },
@@ -25,6 +30,7 @@ module CleanArchitecture
         )
       end
 
+      sig { returns(Dry::Matcher::Case) }
       def failure_case
         Dry::Matcher::Case.new(
           match: ->(value) { value.is_a?(Dry::Monads::Failure) },
@@ -32,6 +38,7 @@ module CleanArchitecture
         )
       end
 
+      sig { params(value: Dry::Monads::Result[T.any(T::Array[Object], String, Entities::FailureDetails), T.untyped]).returns(Entities::FailureDetails) }
       def resolve_failure_value(value)
         failure = value.failure
         case failure
@@ -42,8 +49,7 @@ module CleanArchitecture
         when Entities::FailureDetails
           failure
         else
-          type_list = [Array, String, Entities::FailureDetails].map(&:to_s).join(' or ')
-          raise ArgumentError, "Unexpected failure value - must be #{type_list}"
+          T.absurd(failure)
         end
       end
     end

data/lib/clean_architecture/queries/all.rb

@@ -1,4 +1,4 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
 # THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MANUALLY MODIFIED

data/lib/clean_architecture/queries/http_failure_code.rb

@@ -1,32 +1,20 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module CleanArchitecture
   module Queries
     class HttpFailureCode
-      def initialize(failure_details_type)
-        @failure_details_type = failure_details_type
+      extend T::Sig
+
+      sig { params(failure_type: Entities::FailureType).void }
+      def initialize(failure_type)
+        @failure_type = failure_type
       end
 
+      sig { returns(Symbol) }
       def to_sym
-        code = FAILURE_DETAILS_TYPE_TO_STATUS_CODE[@failure_details_type.to_s.downcase]
-        if code.nil?
-          raise NotImplementedError,
-                "cannot determine failure code for failure details type #{@failure_details_type}"
-        end
-
-        code
+        @failure_type.serialize.to_sym
       end
-
-      private
-
-      FAILURE_DETAILS_TYPE_TO_STATUS_CODE = {
-        'error' => :internal_server_error,
-        'expectation_failed' => :expectation_failed,
-        'not_found' => :not_found,
-        'unauthorized' => :unauthorized,
-        'unprocessable_entity' => :unprocessable_entity
-      }.freeze
     end
   end
 end

data/lib/clean_architecture/queries/http_success_code.rb

@@ -1,13 +1,17 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module CleanArchitecture
   module Queries
     class HttpSuccessCode
+      extend T::Sig
+
+      sig { params(http_method: String).void }
       def initialize(http_method)
         @http_method = http_method
       end
 
+      sig { returns(Symbol) }
       def to_sym
         code = HTTP_METHOD_TO_SUCCESS_CODE[@http_method.to_s.upcase]
         if code.nil?
@@ -19,12 +23,15 @@ module CleanArchitecture
 
       private
 
-      HTTP_METHOD_TO_SUCCESS_CODE = {
-        'GET' => :ok,
-        'POST' => :created,
-        'PUT' => :accepted,
-        'DELETE' => :ok
-      }.freeze
+      HTTP_METHOD_TO_SUCCESS_CODE = T.let(
+        {
+          'GET' => :ok,
+          'POST' => :created,
+          'PUT' => :accepted,
+          'DELETE' => :ok
+        }.freeze,
+        T::Hash[String, Symbol]
+      )
     end
   end
 end

data/lib/clean_architecture/serializers/all.rb

@@ -1,4 +1,4 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
 # THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MANUALLY MODIFIED