clean-architecture 3.0.0 → 3.0.1

data/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi

@@ -29,7 +29,7 @@ module ActiveModel::Validations
       params(
         names: T.any(Symbol, String),
         if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-        on: T.any(Symbol, String),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
         prepend: T::Boolean,
         unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
       ).void
@@ -74,6 +74,7 @@ module ActiveModel::Validations
         strict: T::Boolean,
         uniqueness: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
         unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        kwargs: T.untyped
       ).void
     end
     def validates(
@@ -94,91 +95,41 @@ module ActiveModel::Validations
       size: false,
       strict: false,
       uniqueness: false,
-      unless: :_
+      unless: :_,
+      **kwargs
     )
     end
   end
+
+  mixes_in_class_methods(ClassMethods)
 end
 
-class ActiveModel::Type::Boolean
+class ActiveModel::Type::Value
+  extend T::Sig
+
+  sig { params(precision: T.untyped, limit: T.untyped, scale: T.untyped).void }
+  def initialize(precision: nil, limit: nil, scale: nil); end
+
+  sig { params(value: T.untyped).returns(T.untyped) }
+  def cast(value); end
+end
+
+class ActiveModel::Type::Boolean < ActiveModel::Type::Value
   sig { params(arg0: T.untyped).returns(T.nilable(T::Boolean))}
   def cast(arg0); end
 end
 
-module ActiveModel::Validations::HelperMethods
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: String,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_absence_of(
-    *attr_names,
-    message: 'must be blank',
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
-
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: String,
-      accept: T.untyped,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_acceptance_of(
-    *attr_names,
-    message: 'must be accepted',
-    accept: ['1', true],
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
+class ActiveModel::Type::ImmutableString < ActiveModel::Type::Value
+  sig { params(arg0: T.untyped).returns(T.nilable(String))}
+  def cast(arg0); end
+end
 
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: String,
-      case_sensitive: T::Boolean,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_confirmation_of(
-    *attr_names,
-    message: "doesn't match %{translated_attribute_name}",
-    case_sensitive: true,
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
+class ActiveModel::Type::String < ActiveModel::Type::ImmutableString
+  sig { params(arg0: T.untyped).returns(T.nilable(String))}
+  def cast(arg0); end
+end
 
+module ActiveModel::Validations::HelperMethods
   # A type alias for the in/within parameters on the
   # validates_(inclusion/exclusion)_of methods.
   InWithinType = T.type_alias do
@@ -188,235 +139,314 @@ module ActiveModel::Validations::HelperMethods
         String,
         T::Array[T.any(String, Symbol)],
         T::Range[Integer],
+        T::Array[T::Boolean],
         T.proc.params(arg0: T.untyped).returns(T::Boolean)
       )
     )
   end
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: String,
-      in: InWithinType,
-      within: InWithinType,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_exclusion_of(
-    *attr_names,
-    message: 'is reserved',
-    in: nil,
-    within: nil,
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
 
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: String,
-      with: T.untyped,
-      without: T.untyped,
-      multiline: T.untyped,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_format_of(
-    *attr_names,
-    message: 'is invalid',
-    with: nil,
-    without: nil,
-    multiline: nil,
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
+  module ClassMethods
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_absence_of(
+      *attr_names,
+      message: 'must be blank',
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
 
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: String,
-      in: InWithinType,
-      within: InWithinType,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_inclusion_of(
-    *attr_names,
-    message: 'is not included in the list',
-    in: nil,
-    within: nil,
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        accept: T.untyped,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_acceptance_of(
+      *attr_names,
+      message: 'must be accepted',
+      accept: ['1', true],
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
 
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: T.nilable(String),
-      minimum: T.nilable(Integer),
-      maximum: T.nilable(Integer),
-      is: T.nilable(Integer),
-      within: T.nilable(T::Range[Integer]),
-      in: T.nilable(T::Range[Integer]),
-      too_long: String,
-      too_short: String,
-      wrong_length: String,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_length_of(
-    *attr_names,
-    message: nil,
-    minimum: nil,
-    maximum: nil,
-    is: nil,
-    within: nil,
-    in: nil,
-    too_long: 'is too long (maximum is %{count} characters)',
-    too_short: 'is too short (minimum is %{count} characters)',
-    wrong_length: 'is the wrong length (should be %{count} characters)',
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        case_sensitive: T::Boolean,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_confirmation_of(
+      *attr_names,
+      message: "doesn't match %{translated_attribute_name}",
+      case_sensitive: true,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
 
-  # validates_size_of is an alias of validates_length_of
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: T.nilable(String),
-      minimum: T.nilable(Integer),
-      maximum: T.nilable(Integer),
-      is: T.nilable(Integer),
-      within: T.nilable(T::Range[Integer]),
-      in: T.nilable(T::Range[Integer]),
-      too_long: String,
-      too_short: String,
-      wrong_length: String,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_size_of(
-    *attr_names,
-    message: nil,
-    minimum: nil,
-    maximum: nil,
-    is: nil,
-    within: nil,
-    in: nil,
-    too_long: 'is too long (maximum is %{count} characters)',
-    too_short: 'is too short (minimum is %{count} characters)',
-    wrong_length: 'is the wrong length (should be %{count} characters)',
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        in: InWithinType,
+        within: InWithinType,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_exclusion_of(
+      *attr_names,
+      message: 'is reserved',
+      in: nil,
+      within: nil,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
 
-  # Create a type alias so we don't have to repeat this long type signature 6 times.
-  NumberComparatorType = T.type_alias {T.nilable(T.any(Integer, Float, T.proc.params(arg0: T.untyped).returns(T::Boolean), Symbol))}
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: String,
-      only_integer: T::Boolean,
-      greater_than: NumberComparatorType,
-      greater_than_or_equal_to: NumberComparatorType,
-      equal_to: NumberComparatorType,
-      less_than: NumberComparatorType,
-      less_than_or_equal_to: NumberComparatorType,
-      other_than: NumberComparatorType,
-      odd: T::Boolean,
-      even: T::Boolean,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
-  end
-  def validates_numericality_of(
-    *attr_names,
-    message: 'is not a number',
-    only_integer: false,
-    greater_than: nil,
-    greater_than_or_equal_to: nil,
-    equal_to: nil,
-    less_than: nil,
-    less_than_or_equal_to: nil,
-    other_than: nil,
-    odd: false,
-    even: false,
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        with: T.untyped,
+        without: T.untyped,
+        multiline: T.untyped,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_format_of(
+      *attr_names,
+      message: 'is invalid',
+      with: nil,
+      without: nil,
+      multiline: nil,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        in: InWithinType,
+        within: InWithinType,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_inclusion_of(
+      *attr_names,
+      message: 'is not included in the list',
+      in: nil,
+      within: nil,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: T.nilable(String),
+        minimum: T.nilable(Integer),
+        maximum: T.nilable(Integer),
+        is: T.nilable(Integer),
+        within: T.nilable(T::Range[Integer]),
+        in: T.nilable(T::Range[Integer]),
+        too_long: String,
+        too_short: String,
+        wrong_length: String,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_length_of(
+      *attr_names,
+      message: nil,
+      minimum: nil,
+      maximum: nil,
+      is: nil,
+      within: nil,
+      in: nil,
+      too_long: 'is too long (maximum is %{count} characters)',
+      too_short: 'is too short (minimum is %{count} characters)',
+      wrong_length: 'is the wrong length (should be %{count} characters)',
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    # validates_size_of is an alias of validates_length_of
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: T.nilable(String),
+        minimum: T.nilable(Integer),
+        maximum: T.nilable(Integer),
+        is: T.nilable(Integer),
+        within: T.nilable(T::Range[Integer]),
+        in: T.nilable(T::Range[Integer]),
+        too_long: String,
+        too_short: String,
+        wrong_length: String,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_size_of(
+      *attr_names,
+      message: nil,
+      minimum: nil,
+      maximum: nil,
+      is: nil,
+      within: nil,
+      in: nil,
+      too_long: 'is too long (maximum is %{count} characters)',
+      too_short: 'is too short (minimum is %{count} characters)',
+      wrong_length: 'is the wrong length (should be %{count} characters)',
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    # Create a type alias so we don't have to repeat this long type signature 6 times.
+    NumberComparatorType = T.type_alias {T.nilable(T.any(Integer, Float, T.proc.params(arg0: T.untyped).returns(T::Boolean), Symbol))}
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        only_integer: T::Boolean,
+        greater_than: NumberComparatorType,
+        greater_than_or_equal_to: NumberComparatorType,
+        equal_to: NumberComparatorType,
+        less_than: NumberComparatorType,
+        less_than_or_equal_to: NumberComparatorType,
+        other_than: NumberComparatorType,
+        odd: T::Boolean,
+        even: T::Boolean,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_numericality_of(
+      *attr_names,
+      message: 'is not a number',
+      only_integer: false,
+      greater_than: nil,
+      greater_than_or_equal_to: nil,
+      equal_to: nil,
+      less_than: nil,
+      less_than_or_equal_to: nil,
+      other_than: nil,
+      odd: false,
+      even: false,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
 
-  sig do
-    params(
-      attr_names: T.any(String, Symbol),
-      message: String,
-      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
-      on: T.any(Symbol, String),
-      allow_nil: T::Boolean,
-      allow_blank: T::Boolean,
-      strict: T::Boolean
-    ).void
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_presence_of(
+      *attr_names,
+      message: "can't be blank",
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
   end
-  def validates_presence_of(
-    *attr_names,
-    message: "can't be blank",
-    if: nil,
-    unless: :_,
-    on: :_,
-    allow_nil: false,
-    allow_blank: false,
-    strict: false
-  ); end
+
+  mixes_in_class_methods(ClassMethods)
 end