sord 0.8.0 → 0.9.0

data/rbi/sord.rbi

@@ -1,11 +1,15 @@
 # typed: strong
 module Sord
+  VERSION = T.let('0.8.0', T.untyped)
+
   module Logging
+    AVAILABLE_TYPES = T.let([:warn, :info, :duck, :error, :infer, :omit, :done].freeze, T.untyped)
+
     sig { returns(T::Array[Proc]) }
-    def self.hooks(); end
+    def self.hooks; end
 
     sig { returns(T::Boolean) }
-    def self.silent?(); end
+    def self.silent?; end
 
     sig { params(value: T::Boolean).void }
     def self.silent=(value); end
@@ -14,7 +18,7 @@ module Sord
     def self.enabled_types=(value); end
 
     sig { returns(T::Array[Symbol]) }
-    def self.enabled_types(); end
+    def self.enabled_types; end
 
     sig { params(value: T::Array[Symbol]).void }
     def self.valid_types?(value); end
@@ -25,62 +29,54 @@ module Sord
         kind: Symbol,
         header: String,
         msg: String,
-        item: YARD::CodeObjects::Base,
-        indent_level: Integer
+        item: YARD::CodeObjects::Base
       ).void
     end
-    def self.generic(kind, header, msg, item, indent_level = 0); end
+    def self.generic(kind, header, msg, item); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
-    def self.warn(msg, item = nil, indent_level = 0); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
+    def self.warn(msg, item = nil); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
-    def self.info(msg, item = nil, indent_level = 0); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
+    def self.info(msg, item = nil); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
-    def self.duck(msg, item = nil, indent_level = 0); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
+    def self.duck(msg, item = nil); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
-    def self.error(msg, item = nil, indent_level = 0); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
+    def self.error(msg, item = nil); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
-    def self.infer(msg, item = nil, indent_level = 0); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
+    def self.infer(msg, item = nil); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
-    def self.omit(msg, item = nil, indent_level = 0); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
+    def self.omit(msg, item = nil); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
-    def self.done(msg, item = nil, indent_level = 0); end
+    sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
+    def self.done(msg, item = nil); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig do
-      params(
-        kind: Symbol,
-        msg: String,
-        item: YARD::CodeObjects::Base,
-        indent_level: Integer
-      ).void
-    end
-    def self.invoke_hooks(kind, msg, item, indent_level = 0); end
+    sig { params(kind: Symbol, msg: String, item: YARD::CodeObjects::Base).void }
+    def self.invoke_hooks(kind, msg, item); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(blk: T.proc.params(kind: Symbol, msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void).void }
+    sig { params(blk: T.proc.params(kind: Symbol, msg: String, item: YARD::CodeObjects::Base).void).void }
     def self.add_hook(&blk); end
   end
 
   module Resolver
     sig { void }
-    def self.prepare(); end
+    def self.prepare; end
 
     sig { void }
-    def self.clear(); end
+    def self.clear; end
 
     sig { params(name: String).returns(T::Array[String]) }
     def self.paths_for(name); end
@@ -89,77 +85,111 @@ module Sord
     def self.path_for(name); end
 
     sig { returns(T::Array[String]) }
-    def self.builtin_classes(); end
+    def self.builtin_classes; end
 
     sig { params(name: String, item: Object).returns(T::Boolean) }
     def self.resolvable?(name, item); end
   end
 
   class RbiGenerator
-    sig { returns(T::Array[String]) }
-    def rbi_contents(); end
-
     sig { returns(Integer) }
-    def object_count(); end
+    def object_count; end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
     sig { returns(T::Array[[String, YARD::CodeObjects::Base, Integer]]) }
-    def warnings(); end
-
-    sig { returns(T::Boolean) }
-    def next_item_is_first_in_namespace(); end
+    def warnings; end
 
-    # sord infer - inferred type of parameter "value" as T::Boolean using getter's return type
-    sig { params(value: T::Boolean).returns(T::Boolean) }
-    def next_item_is_first_in_namespace=(value); end
-
-    sig { params(options: Hash).void }
+    sig { params(options: T::Hash[T.untyped, T.untyped]).void }
     def initialize(options); end
 
     sig { void }
-    def count_namespace(); end
-
-    sig { void }
-    def count_method(); end
+    def count_namespace; end
 
     sig { void }
-    def add_blank(); end
+    def count_method; end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
-    sig { params(item: YARD::CodeObjects::Base, indent_level: Integer).returns(Integer) }
-    def add_mixins(item, indent_level); end
+    sig { params(item: YARD::CodeObjects::Base).returns(Integer) }
+    def add_mixins(item); end
 
-    sig { params(params: T::Array[String], returns: String, indent_level: Integer).void }
-    def add_signature(params, returns, indent_level); end
+    # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
+    sig { params(item: YARD::CodeObjects::NamespaceObject).void }
+    def add_constants(item); end
 
     # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
-    sig { params(item: YARD::CodeObjects::NamespaceObject, indent_level: Integer).void }
-    def add_methods(item, indent_level); end
+    sig { params(item: YARD::CodeObjects::NamespaceObject).void }
+    def add_methods(item); end
 
     # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
-    sig { params(item: YARD::CodeObjects::NamespaceObject, indent_level: Integer).void }
-    def add_namespace(item, indent_level = 0); end
+    sig { params(item: YARD::CodeObjects::NamespaceObject).void }
+    def add_namespace(item); end
 
-    sig { returns(String) }
-    def generate(); end
+    sig { void }
+    def populate; end
+
+    sig { void }
+    def generate; end
+
+    sig { void }
+    def run; end
+  end
+
+  class ParlourPlugin < Parlour::Plugin
+    # sord omit - no YARD return type given, using T.untyped
+    sig { returns(T.untyped) }
+    def options; end
+
+    # sord omit - no YARD return type given, using T.untyped
+    sig { returns(T.untyped) }
+    def parlour; end
+
+    # sord omit - no YARD return type given, using T.untyped
+    sig { params(value: T.untyped).returns(T.untyped) }
+    def parlour=(value); end
 
-    sig { params(filename: T.nilable(String)).void }
-    def run(filename); end
+    # sord omit - no YARD type given for "options", using T.untyped
+    sig { params(options: T.untyped).returns(ParlourPlugin) }
+    def initialize(options); end
+
+    # sord omit - no YARD type given for "root", using T.untyped
+    # sord omit - no YARD return type given, using T.untyped
+    sig { params(root: T.untyped).returns(T.untyped) }
+    def generate(root); end
   end
 
   module TypeConverter
+    SIMPLE_TYPE_REGEX = T.let(/(?:\:\:)?[a-zA-Z_][\w]*(?:\:\:[a-zA-Z_][\w]*)*/, T.untyped)
+    GENERIC_TYPE_REGEX = T.let(/(#{SIMPLE_TYPE_REGEX})\s*[<{]\s*(.*)\s*[>}]/, T.untyped)
+    DUCK_TYPE_REGEX = T.let(/^\#[a-zA-Z_][\w]*(?:[a-zA-Z_][\w=]*)*(?:( ?\& ?\#)*[a-zA-Z_][\w=]*)*$/, T.untyped)
+    ORDERED_LIST_REGEX = T.let(/^(?:Array|)\((.*)\s*\)$/, T.untyped)
+    SHORTHAND_HASH_SYNTAX = T.let(/^{\s*(.*)\s*}$/, T.untyped)
+    SHORTHAND_ARRAY_SYNTAX = T.let(/^<\s*(.*)\s*>$/, T.untyped)
+    SORBET_SUPPORTED_GENERIC_TYPES = T.let(%w{Array Set Enumerable Enumerator Range Hash Class}, T.untyped)
+    SORBET_SINGLE_ARG_GENERIC_TYPES = T.let(%w{Array Set Enumerable Enumerator Range}, T.untyped)
+
     sig { params(params: String).returns(T::Array[String]) }
     def self.split_type_parameters(params); end
 
     # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
     sig do
       params(
-        yard: T.any(T::Boolean, Array, String),
+        yard: T.any(T::Boolean, T::Array[T.untyped], String),
+        item: T.nilable(YARD::CodeObjects::Base),
+        replace_errors_with_untyped: T::Boolean,
+        replace_unresolved_with_untyped: T::Boolean
+      ).returns(String)
+    end
+    def self.yard_to_sorbet(yard, item = nil, replace_errors_with_untyped = false, replace_unresolved_with_untyped = false); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig do
+      params(
+        name: String,
+        log_warning: String,
         item: YARD::CodeObjects::Base,
-        indent_level: Integer,
         replace_errors_with_untyped: T::Boolean
       ).returns(String)
     end
-    def self.yard_to_sorbet(yard, item = nil, indent_level = 0, replace_errors_with_untyped = false); end
+    def self.handle_sord_error(name, log_warning, item, replace_errors_with_untyped); end
   end
 end

data/sorbet/rbi/gems/parlour.rbi

@@ -0,0 +1,214 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# 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/parlour/all/parlour.rbi
+#
+# parlour-0.6.1
+module Parlour
+end
+module Kernel
+end
+class Parlour::Plugin
+  def generate(*args, &blk); end
+  def initialize(*args, &blk); end
+  def self.inherited(*args, &blk); end
+  def self.method_added(name); end
+  def self.registered_plugins(*args, &blk); end
+  def self.run_plugins(*args, &blk); end
+  def self.singleton_method_added(name); end
+  extend T::Helpers
+  extend T::InterfaceWrapper::Helpers
+  extend T::Private::Abstract::Hooks
+  extend T::Sig
+end
+class Parlour::RbiGenerator
+  def current_plugin(*args, &blk); end
+  def current_plugin=(arg0); end
+  def initialize(*args, &blk); end
+  def options(*args, &blk); end
+  def rbi(*args, &blk); end
+  def root(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  extend T::Sig
+end
+class Parlour::RbiGenerator::Parameter
+  def ==(*args, &blk); end
+  def default(*args, &blk); end
+  def initialize(*args, &blk); end
+  def kind(*args, &blk); end
+  def name(*args, &blk); end
+  def name_without_kind(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  def to_def_param(*args, &blk); end
+  def to_sig_param(*args, &blk); end
+  def type(*args, &blk); end
+  extend T::Sig
+end
+class Parlour::RbiGenerator::RbiObject
+  def add_comment(*args, &blk); end
+  def add_comments(*args, &blk); end
+  def comments(*args, &blk); end
+  def describe(*args, &blk); end
+  def generate_comments(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def generated_by(*args, &blk); end
+  def generator(*args, &blk); end
+  def initialize(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def name(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  extend T::Helpers
+  extend T::InterfaceWrapper::Helpers
+  extend T::Private::Abstract::Hooks
+  extend T::Sig
+end
+class Parlour::RbiGenerator::Method < Parlour::RbiGenerator::RbiObject
+  def ==(*args, &blk); end
+  def abstract(*args, &blk); end
+  def class_method(*args, &blk); end
+  def describe(*args, &blk); end
+  def generate_definition(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def implementation(*args, &blk); end
+  def initialize(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def overridable(*args, &blk); end
+  def override(*args, &blk); end
+  def parameters(*args, &blk); end
+  def qualifiers(*args, &blk); end
+  def return_type(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  extend T::Sig
+end
+class Parlour::RbiGenerator::Attribute < Parlour::RbiGenerator::Method
+  def generate_definition(*args, &blk); end
+  def initialize(*args, &blk); end
+  def kind(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+end
+class Parlour::RbiGenerator::Arbitrary < Parlour::RbiGenerator::RbiObject
+  def ==(*args, &blk); end
+  def code(*args, &blk); end
+  def code=(arg0); end
+  def describe(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def initialize(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+end
+class Parlour::RbiGenerator::Options
+  def break_params(*args, &blk); end
+  def indented(*args, &blk); end
+  def initialize(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  def tab_size(*args, &blk); end
+  extend T::Sig
+end
+class Parlour::RbiGenerator::Include < Parlour::RbiGenerator::RbiObject
+  def ==(*args, &blk); end
+  def describe(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def initialize(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+end
+class Parlour::RbiGenerator::Extend < Parlour::RbiGenerator::RbiObject
+  def ==(*args, &blk); end
+  def describe(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def initialize(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+end
+class Parlour::RbiGenerator::Constant < Parlour::RbiGenerator::RbiObject
+  def ==(*args, &blk); end
+  def describe(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def initialize(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  def value(*args, &blk); end
+end
+class Parlour::RbiGenerator::Namespace < Parlour::RbiGenerator::RbiObject
+  def add_comment_to_next_child(*args, &blk); end
+  def children(*args, &blk); end
+  def constants(*args, &blk); end
+  def create_arbitrary(code:, &block); end
+  def create_attr(name, kind:, type:, &block); end
+  def create_attr_accessor(name, type:, &block); end
+  def create_attr_reader(name, type:, &block); end
+  def create_attr_writer(name, type:, &block); end
+  def create_attribute(name, kind:, type:, &block); end
+  def create_class(*args, &blk); end
+  def create_constant(*args, &blk); end
+  def create_extend(*args, &blk); end
+  def create_extends(*args, &blk); end
+  def create_include(*args, &blk); end
+  def create_includes(*args, &blk); end
+  def create_method(*args, &blk); end
+  def create_module(*args, &blk); end
+  def describe(*args, &blk); end
+  def extends(*args, &blk); end
+  def generate_body(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def includes(*args, &blk); end
+  def initialize(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def move_next_comments(*args, &blk); end
+  def path(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  extend T::Sig
+end
+class Parlour::RbiGenerator::ModuleNamespace < Parlour::RbiGenerator::Namespace
+  def describe(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def initialize(*args, &blk); end
+  def interface(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  extend T::Sig
+end
+class Parlour::RbiGenerator::ClassNamespace < Parlour::RbiGenerator::Namespace
+  def abstract(*args, &blk); end
+  def describe(*args, &blk); end
+  def generate_rbi(*args, &blk); end
+  def initialize(*args, &blk); end
+  def merge_into_self(*args, &blk); end
+  def mergeable?(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  def superclass(*args, &blk); end
+  extend T::Sig
+end
+class Parlour::ConflictResolver
+  def all_eql?(*args, &blk); end
+  def resolve_conflicts(*args, &blk); end
+  def self.method_added(name); end
+  def self.singleton_method_added(name); end
+  def single_type_of_array(*args, &blk); end
+  extend T::Sig
+end

data/sorbet/rbi/gems/rainbow.rbi

@@ -0,0 +1,117 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# 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/rainbow/all/rainbow.rbi
+#
+# rainbow-3.0.0
+module Rainbow
+  def self.enabled; end
+  def self.enabled=(value); end
+  def self.global; end
+  def self.new; end
+  def self.uncolor(string); end
+end
+class Rainbow::StringUtils
+  def self.uncolor(string); end
+  def self.wrap_with_sgr(string, codes); end
+end
+module Rainbow::X11ColorNames
+end
+class Rainbow::Color
+  def ground; end
+  def self.build(ground, values); end
+  def self.parse_hex_color(hex); end
+end
+class Rainbow::Color::Indexed < Rainbow::Color
+  def codes; end
+  def initialize(ground, num); end
+  def num; end
+end
+class Rainbow::Color::Named < Rainbow::Color::Indexed
+  def initialize(ground, name); end
+  def self.color_names; end
+  def self.valid_names; end
+end
+class Rainbow::Color::RGB < Rainbow::Color::Indexed
+  def b; end
+  def code_from_rgb; end
+  def codes; end
+  def g; end
+  def initialize(ground, *values); end
+  def r; end
+  def self.to_ansi_domain(value); end
+end
+class Rainbow::Color::X11Named < Rainbow::Color::RGB
+  def initialize(ground, name); end
+  def self.color_names; end
+  def self.valid_names; end
+  include Rainbow::X11ColorNames
+end
+class Rainbow::Presenter < String
+  def background(*values); end
+  def bg(*values); end
+  def black; end
+  def blink; end
+  def blue; end
+  def bold; end
+  def bright; end
+  def color(*values); end
+  def cyan; end
+  def dark; end
+  def faint; end
+  def fg(*values); end
+  def foreground(*values); end
+  def green; end
+  def hide; end
+  def inverse; end
+  def italic; end
+  def magenta; end
+  def method_missing(method_name, *args); end
+  def red; end
+  def reset; end
+  def respond_to_missing?(method_name, *args); end
+  def underline; end
+  def white; end
+  def wrap_with_sgr(codes); end
+  def yellow; end
+end
+class Rainbow::NullPresenter < String
+  def background(*_values); end
+  def bg(*_values); end
+  def black; end
+  def blink; end
+  def blue; end
+  def bold; end
+  def bright; end
+  def color(*_values); end
+  def cyan; end
+  def dark; end
+  def faint; end
+  def fg(*_values); end
+  def foreground(*_values); end
+  def green; end
+  def hide; end
+  def inverse; end
+  def italic; end
+  def magenta; end
+  def method_missing(method_name, *args); end
+  def red; end
+  def reset; end
+  def respond_to_missing?(method_name, *args); end
+  def underline; end
+  def white; end
+  def yellow; end
+end
+class Rainbow::Wrapper
+  def enabled; end
+  def enabled=(arg0); end
+  def initialize(enabled = nil); end
+  def wrap(string); end
+end
+class Object < BasicObject
+  def Rainbow(string); end
+end

data/sorbet/rbi/gems/rspec-core.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-core/all/rspec-core.rbi
 #
-# rspec-core-3.8.1
+# rspec-core-3.8.2
 module RSpec
   def self.clear_examples; end
   def self.configuration; end

data/sorbet/rbi/gems/simplecov.rbi

@@ -7,13 +7,14 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov/all/simplecov.rbi
 #
-# simplecov-0.16.1
+# simplecov-0.17.0
 module SimpleCov
   def self.add_not_loaded_files(result); end
   def self.clear_result; end
   def self.exit_exception; end
   def self.exit_status_from_exception; end
   def self.filtered(files); end
+  def self.final_result_process?; end
   def self.grouped(files); end
   def self.load_adapter(name); end
   def self.load_profile(name); end
@@ -29,6 +30,7 @@ module SimpleCov
   def self.set_exit_exception; end
   def self.start(profile = nil, &block); end
   def self.usable?; end
+  def self.wait_for_other_processes; end
   def self.write_last_run(covered_percent); end
   extend SimpleCov::Configuration
 end