sorbet-rails 0.6.2 → 0.6.3

data/lib/bundled_rbi/active_record_base.rbi

@@ -1,83 +0,0 @@
-# typed: strong
-class ActiveRecord::Base
-  sig { params(args: T.untyped).returns(T.attached_class) }
-  def self.find(*args); end
-
-  sig { params(args: T.untyped).returns(T.nilable(T.attached_class)) }
-  def self.find_by(*args); end
-
-  sig { params(args: T.untyped).returns(T.attached_class) }
-  def self.find_by!(*args); end
-
-  sig {
-    params(
-      attributes: T.untyped,
-      block: T.nilable(T.proc.params(object: T.attached_class).void),
-    ).
-    returns(T.attached_class)
-  }
-  def self.find_or_initialize_by(attributes, &block); end
-
-  sig {
-    params(
-      attributes: T.untyped,
-      block: T.nilable(T.proc.params(object: T.attached_class).void),
-    ).
-    returns(T.attached_class)
-  }
-  def self.find_or_create_by(attributes, &block); end
-
-  sig {
-    params(
-      attributes: T.untyped,
-      block: T.nilable(T.proc.params(object: T.attached_class).void),
-    ).
-    returns(T.attached_class)
-  }
-  def self.find_or_create_by!(attributes, &block); end
-
-  sig { returns(T.nilable(T.attached_class)) }
-  def self.first; end
-
-  sig { returns(T.attached_class) }
-  def self.first!; end
-
-  sig { returns(T.nilable(T.attached_class)) }
-  def self.second; end
-
-  sig { returns(T.attached_class) }
-  def self.second!; end
-
-  sig { returns(T.nilable(T.attached_class)) }
-  def self.third; end
-
-  sig { returns(T.attached_class) }
-  def self.third!; end
-
-  sig { returns(T.nilable(T.attached_class)) }
-  def self.third_to_last; end
-
-  sig { returns(T.attached_class) }
-  def self.third_to_last!; end
-
-  sig { returns(T.nilable(T.attached_class)) }
-  def self.second_to_last; end
-
-  sig { returns(T.attached_class) }
-  def self.second_to_last!; end
-
-  sig { returns(T.nilable(T.attached_class)) }
-  def self.last; end
-
-  sig { returns(T.attached_class) }
-  def self.last!; end
-
-  sig { params(attributes: T.untyped, block: T.untyped).returns(T.attached_class) }
-  def self.create(attributes = nil, &block); end
-
-  sig { params(attributes: T.untyped, block: T.untyped).returns(T.attached_class) }
-  def self.create!(attributes = nil, &block); end
-
-  sig { params(attributes: T.untyped, block: T.untyped).returns(T.attached_class) }
-  def self.new(attributes = nil, &block); end
-end

data/lib/bundled_rbi/active_record_relation.rbi

@@ -1,122 +0,0 @@
-# typed: strong
-class ActiveRecord::Relation
-  Elem = type_member(fixed: T.untyped)
-
-  sig { params(args: T.untyped).returns(Elem) }
-  def find(*args); end
-
-  sig { params(args: T.untyped).returns(T.nilable(Elem)) }
-  def find_by(*args); end
-
-  sig { params(args: T.untyped).returns(Elem) }
-  def find_by!(*args); end
-
-  sig {
-    params(
-      attributes: T.untyped,
-      block: T.nilable(T.proc.params(object: Elem).void)
-    ).
-    returns(Elem)
-  }
-  def find_or_initialize_by(attributes, &block); end
-
-  sig {
-    params(
-      attributes: T.untyped,
-      block: T.nilable(T.proc.params(object: Elem).void)
-    ).
-    returns(Elem)
-  }
-  def find_or_create_by(attributes, &block); end
-
-  sig {
-    params(
-      attributes: T.untyped,
-      block: T.nilable(T.proc.params(object: Elem).void)
-    ).
-    returns(Elem)
-  }
-  def find_or_create_by!(attributes, &block); end
-
-  sig { returns(T.nilable(Elem)) }
-  def first; end
-
-  sig { returns(Elem) }
-  def first!; end
-
-  sig { returns(T.nilable(Elem)) }
-  def second; end
-
-  sig { returns(Elem) }
-  def second!; end
-
-  sig { returns(T.nilable(Elem)) }
-  def third; end
-
-  sig { returns(Elem) }
-  def third!; end
-
-  sig { returns(T.nilable(Elem)) }
-  def third_to_last; end
-
-  sig { returns(Elem) }
-  def third_to_last!; end
-
-  sig { returns(T.nilable(Elem)) }
-  def second_to_last; end
-
-  sig { returns(Elem) }
-  def second_to_last!; end
-
-  sig { returns(T.nilable(Elem)) }
-  def last; end
-
-  sig { returns(Elem) }
-  def last!; end
-
-  sig do
-    override.params(
-      start: T.nilable(Integer),
-      finish: T.nilable(Integer),
-      batch_size: T.nilable(Integer),
-      error_on_ignore: T.nilable(T::Boolean),
-      block: T.nilable(T.proc.params(e: Elem).void) # block is optional, eg. you can do Klass.find_each.map
-    ).returns(T::Array[Elem])
-  end
-  def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, &block); end
-
-  sig { override.params(block: T.proc.params(e: Elem).void).returns(T::Array[Elem]) }
-  def each(&block); end
-
-  sig { params(level: T.nilable(Integer)).returns(T::Array[Elem]) }
-  def flatten(level); end
-
-  sig { returns(T::Array[Elem]) }
-  def to_a; end
-
-  sig do
-    type_parameters(:U).params(
-        blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
-    )
-    .returns(T::Array[T.type_parameter(:U)])
-  end
-  def map(&blk); end
-
-  sig { params(conditions: T.untyped).returns(T::Boolean) }
-  def exists?(conditions = nil); end
-
-  sig { returns(T::Boolean) }
-  def any?; end
-
-  sig { returns(T::Boolean) }
-  def empty?; end
-
-  sig { returns(T::Boolean) }
-  def many?; end
-
-  sig { returns(T::Boolean) }
-  def none?; end
-
-  sig { returns(T::Boolean) }
-  def one?; end
-end

data/lib/sorbet-rails/model_plugins/active_record_finder_methods.rb

@@ -1,131 +0,0 @@
-# typed: strict
-require ('sorbet-rails/model_plugins/base')
-class SorbetRails::ModelPlugins::ActiveRecordFinderMethods < SorbetRails::ModelPlugins::Base
-
-  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
-  def generate(root)
-    model_class_rbi = root.create_class(self.model_class_name)
-    create_finder_methods_for(model_class_rbi, class_method: true, include_methods_that_return_self: false)
-
-    model_relation_class_rbi = root.create_class(self.model_relation_class_name)
-    create_finder_methods_for(model_relation_class_rbi, class_method: false, include_methods_that_return_self: false)
-
-    model_assoc_proxy_class_rbi = root.create_class(self.model_assoc_proxy_class_name)
-    create_finder_methods_for(model_assoc_proxy_class_rbi, class_method: false)
-
-    model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
-    create_finder_methods_for(model_assoc_relation_rbi, class_method: false)
-  end
-
-  sig do
-    params(
-      class_rbi: Parlour::RbiGenerator::ClassNamespace,
-      class_method: T::Boolean,
-      include_methods_that_return_self: T::Boolean
-    ).void
-  end
-  def create_finder_methods_for(class_rbi, class_method:, include_methods_that_return_self: true)
-    # The intent of this is to prevent these methods from being generated
-    # unnecessarily when T.attached_class or Elem can be used to reduce
-    # the number of method signatures that have to be generated.
-    if include_methods_that_return_self
-      class_rbi.create_method(
-        "find",
-        parameters: [ Parameter.new("*args", type: "T.untyped") ],
-        return_type: self.model_class_name,
-        class_method: class_method,
-      )
-      class_rbi.create_method(
-        "find_by",
-        parameters: [ Parameter.new("*args", type: "T.untyped") ],
-        return_type: "T.nilable(#{self.model_class_name})",
-        class_method: class_method,
-      )
-      class_rbi.create_method(
-        "find_by!",
-        parameters: [ Parameter.new("*args", type: "T.untyped") ],
-        return_type: self.model_class_name,
-        class_method: class_method
-      )
-      class_rbi.create_method(
-        "find_or_initialize_by",
-        parameters: [
-          Parameter.new("attributes", type: "T.untyped") ,
-          Parameter.new(
-            "&block",
-            type: "T.nilable(T.proc.params(object: #{self.model_class_name}).void)",
-          ),
-        ],
-        return_type: self.model_class_name,
-        class_method: class_method
-      )
-      class_rbi.create_method(
-        "find_or_create_by",
-        parameters: [
-          Parameter.new("attributes", type: "T.untyped") ,
-          Parameter.new(
-            "&block",
-            type: "T.nilable(T.proc.params(object: #{self.model_class_name}).void)"
-          ),
-        ],
-        return_type: self.model_class_name,
-        class_method: class_method
-      )
-      class_rbi.create_method(
-        "find_or_create_by!",
-        parameters: [
-          Parameter.new("attributes", type: "T.untyped") ,
-          Parameter.new(
-            "&block",
-            type: "T.nilable(T.proc.params(object: #{self.model_class_name}).void)",
-          ),
-        ],
-        return_type: self.model_class_name,
-        class_method: class_method
-      )
-
-      ["first", "second", "third", "third_to_last", "second_to_last", "last"].
-        each do |method_name|
-          create_finder_method_pair(class_rbi, method_name, class_method)
-        end
-    end
-
-    # Checker methods
-    class_rbi.create_method(
-      "exists?",
-      parameters: [ Parameter.new("conditions", type: "T.untyped", default: "nil") ],
-      return_type: "T::Boolean",
-      class_method: class_method,
-    )
-
-    ["any?", "many?", "none?", "one?", "empty?"].each do |method_name|
-      class_rbi.create_method(
-        method_name,
-        parameters: [ Parameter.new("*args", type: "T.untyped") ],
-        return_type: "T::Boolean",
-        class_method: class_method,
-      )
-    end
-  end
-
-  sig {
-    params(
-      class_rbi: Parlour::RbiGenerator::ClassNamespace,
-      method_name: String,
-      class_method: T::Boolean,
-    ).
-    void
-  }
-  def create_finder_method_pair(class_rbi, method_name, class_method)
-    class_rbi.create_method(
-      method_name,
-      return_type: "T.nilable(#{self.model_class_name})",
-      class_method: class_method,
-    )
-    class_rbi.create_method(
-      "#{method_name}!",
-      return_type: self.model_class_name,
-      class_method: class_method,
-    )
-  end
-end

data/spec/support/v5.0/typed-override.yaml

@@ -1,2 +0,0 @@
-true:
-- ./sorbet_test_cases.rb

data/spec/support/v5.1/typed-override.yaml

@@ -1,2 +0,0 @@
-true:
-- ./sorbet_test_cases.rb

data/spec/support/v5.2/typed-override.yaml

@@ -1,2 +0,0 @@
-true:
-- ./sorbet_test_cases.rb

data/spec/support/v6.0/typed-override.yaml

@@ -1,2 +0,0 @@
-true:
-- ./sorbet_test_cases.rb