sord 0.8.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/rbi/sord.rbi CHANGED
@@ -1,11 +1,15 @@
1
1
  # typed: strong
2
2
  module Sord
3
+ VERSION = T.let('0.8.0', T.untyped)
4
+
3
5
  module Logging
6
+ AVAILABLE_TYPES = T.let([:warn, :info, :duck, :error, :infer, :omit, :done].freeze, T.untyped)
7
+
4
8
  sig { returns(T::Array[Proc]) }
5
- def self.hooks(); end
9
+ def self.hooks; end
6
10
 
7
11
  sig { returns(T::Boolean) }
8
- def self.silent?(); end
12
+ def self.silent?; end
9
13
 
10
14
  sig { params(value: T::Boolean).void }
11
15
  def self.silent=(value); end
@@ -14,7 +18,7 @@ module Sord
14
18
  def self.enabled_types=(value); end
15
19
 
16
20
  sig { returns(T::Array[Symbol]) }
17
- def self.enabled_types(); end
21
+ def self.enabled_types; end
18
22
 
19
23
  sig { params(value: T::Array[Symbol]).void }
20
24
  def self.valid_types?(value); end
@@ -25,62 +29,54 @@ module Sord
25
29
  kind: Symbol,
26
30
  header: String,
27
31
  msg: String,
28
- item: YARD::CodeObjects::Base,
29
- indent_level: Integer
32
+ item: YARD::CodeObjects::Base
30
33
  ).void
31
34
  end
32
- def self.generic(kind, header, msg, item, indent_level = 0); end
35
+ def self.generic(kind, header, msg, item); end
33
36
 
34
37
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
35
- sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
36
- def self.warn(msg, item = nil, indent_level = 0); end
38
+ sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
39
+ def self.warn(msg, item = nil); end
37
40
 
38
41
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
39
- sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
40
- def self.info(msg, item = nil, indent_level = 0); end
42
+ sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
43
+ def self.info(msg, item = nil); end
41
44
 
42
45
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
43
- sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
44
- def self.duck(msg, item = nil, indent_level = 0); end
46
+ sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
47
+ def self.duck(msg, item = nil); end
45
48
 
46
49
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
47
- sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
48
- def self.error(msg, item = nil, indent_level = 0); end
50
+ sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
51
+ def self.error(msg, item = nil); end
49
52
 
50
53
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
51
- sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
52
- def self.infer(msg, item = nil, indent_level = 0); end
54
+ sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
55
+ def self.infer(msg, item = nil); end
53
56
 
54
57
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
55
- sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
56
- def self.omit(msg, item = nil, indent_level = 0); end
58
+ sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
59
+ def self.omit(msg, item = nil); end
57
60
 
58
61
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
59
- sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
60
- def self.done(msg, item = nil, indent_level = 0); end
62
+ sig { params(msg: String, item: T.nilable(YARD::CodeObjects::Base)).void }
63
+ def self.done(msg, item = nil); end
61
64
 
62
65
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
63
- sig do
64
- params(
65
- kind: Symbol,
66
- msg: String,
67
- item: YARD::CodeObjects::Base,
68
- indent_level: Integer
69
- ).void
70
- end
71
- def self.invoke_hooks(kind, msg, item, indent_level = 0); end
66
+ sig { params(kind: Symbol, msg: String, item: YARD::CodeObjects::Base).void }
67
+ def self.invoke_hooks(kind, msg, item); end
72
68
 
73
69
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
74
- sig { params(blk: T.proc.params(kind: Symbol, msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void).void }
70
+ sig { params(blk: T.proc.params(kind: Symbol, msg: String, item: YARD::CodeObjects::Base).void).void }
75
71
  def self.add_hook(&blk); end
76
72
  end
77
73
 
78
74
  module Resolver
79
75
  sig { void }
80
- def self.prepare(); end
76
+ def self.prepare; end
81
77
 
82
78
  sig { void }
83
- def self.clear(); end
79
+ def self.clear; end
84
80
 
85
81
  sig { params(name: String).returns(T::Array[String]) }
86
82
  def self.paths_for(name); end
@@ -89,77 +85,111 @@ module Sord
89
85
  def self.path_for(name); end
90
86
 
91
87
  sig { returns(T::Array[String]) }
92
- def self.builtin_classes(); end
88
+ def self.builtin_classes; end
93
89
 
94
90
  sig { params(name: String, item: Object).returns(T::Boolean) }
95
91
  def self.resolvable?(name, item); end
96
92
  end
97
93
 
98
94
  class RbiGenerator
99
- sig { returns(T::Array[String]) }
100
- def rbi_contents(); end
101
-
102
95
  sig { returns(Integer) }
103
- def object_count(); end
96
+ def object_count; end
104
97
 
105
98
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
106
99
  sig { returns(T::Array[[String, YARD::CodeObjects::Base, Integer]]) }
107
- def warnings(); end
108
-
109
- sig { returns(T::Boolean) }
110
- def next_item_is_first_in_namespace(); end
100
+ def warnings; end
111
101
 
112
- # sord infer - inferred type of parameter "value" as T::Boolean using getter's return type
113
- sig { params(value: T::Boolean).returns(T::Boolean) }
114
- def next_item_is_first_in_namespace=(value); end
115
-
116
- sig { params(options: Hash).void }
102
+ sig { params(options: T::Hash[T.untyped, T.untyped]).void }
117
103
  def initialize(options); end
118
104
 
119
105
  sig { void }
120
- def count_namespace(); end
121
-
122
- sig { void }
123
- def count_method(); end
106
+ def count_namespace; end
124
107
 
125
108
  sig { void }
126
- def add_blank(); end
109
+ def count_method; end
127
110
 
128
111
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
129
- sig { params(item: YARD::CodeObjects::Base, indent_level: Integer).returns(Integer) }
130
- def add_mixins(item, indent_level); end
112
+ sig { params(item: YARD::CodeObjects::Base).returns(Integer) }
113
+ def add_mixins(item); end
131
114
 
132
- sig { params(params: T::Array[String], returns: String, indent_level: Integer).void }
133
- def add_signature(params, returns, indent_level); end
115
+ # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
116
+ sig { params(item: YARD::CodeObjects::NamespaceObject).void }
117
+ def add_constants(item); end
134
118
 
135
119
  # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
136
- sig { params(item: YARD::CodeObjects::NamespaceObject, indent_level: Integer).void }
137
- def add_methods(item, indent_level); end
120
+ sig { params(item: YARD::CodeObjects::NamespaceObject).void }
121
+ def add_methods(item); end
138
122
 
139
123
  # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
140
- sig { params(item: YARD::CodeObjects::NamespaceObject, indent_level: Integer).void }
141
- def add_namespace(item, indent_level = 0); end
124
+ sig { params(item: YARD::CodeObjects::NamespaceObject).void }
125
+ def add_namespace(item); end
142
126
 
143
- sig { returns(String) }
144
- def generate(); end
127
+ sig { void }
128
+ def populate; end
129
+
130
+ sig { void }
131
+ def generate; end
132
+
133
+ sig { void }
134
+ def run; end
135
+ end
136
+
137
+ class ParlourPlugin < Parlour::Plugin
138
+ # sord omit - no YARD return type given, using T.untyped
139
+ sig { returns(T.untyped) }
140
+ def options; end
141
+
142
+ # sord omit - no YARD return type given, using T.untyped
143
+ sig { returns(T.untyped) }
144
+ def parlour; end
145
+
146
+ # sord omit - no YARD return type given, using T.untyped
147
+ sig { params(value: T.untyped).returns(T.untyped) }
148
+ def parlour=(value); end
145
149
 
146
- sig { params(filename: T.nilable(String)).void }
147
- def run(filename); end
150
+ # sord omit - no YARD type given for "options", using T.untyped
151
+ sig { params(options: T.untyped).returns(ParlourPlugin) }
152
+ def initialize(options); end
153
+
154
+ # sord omit - no YARD type given for "root", using T.untyped
155
+ # sord omit - no YARD return type given, using T.untyped
156
+ sig { params(root: T.untyped).returns(T.untyped) }
157
+ def generate(root); end
148
158
  end
149
159
 
150
160
  module TypeConverter
161
+ SIMPLE_TYPE_REGEX = T.let(/(?:\:\:)?[a-zA-Z_][\w]*(?:\:\:[a-zA-Z_][\w]*)*/, T.untyped)
162
+ GENERIC_TYPE_REGEX = T.let(/(#{SIMPLE_TYPE_REGEX})\s*[<{]\s*(.*)\s*[>}]/, T.untyped)
163
+ DUCK_TYPE_REGEX = T.let(/^\#[a-zA-Z_][\w]*(?:[a-zA-Z_][\w=]*)*(?:( ?\& ?\#)*[a-zA-Z_][\w=]*)*$/, T.untyped)
164
+ ORDERED_LIST_REGEX = T.let(/^(?:Array|)\((.*)\s*\)$/, T.untyped)
165
+ SHORTHAND_HASH_SYNTAX = T.let(/^{\s*(.*)\s*}$/, T.untyped)
166
+ SHORTHAND_ARRAY_SYNTAX = T.let(/^<\s*(.*)\s*>$/, T.untyped)
167
+ SORBET_SUPPORTED_GENERIC_TYPES = T.let(%w{Array Set Enumerable Enumerator Range Hash Class}, T.untyped)
168
+ SORBET_SINGLE_ARG_GENERIC_TYPES = T.let(%w{Array Set Enumerable Enumerator Range}, T.untyped)
169
+
151
170
  sig { params(params: String).returns(T::Array[String]) }
152
171
  def self.split_type_parameters(params); end
153
172
 
154
173
  # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
155
174
  sig do
156
175
  params(
157
- yard: T.any(T::Boolean, Array, String),
176
+ yard: T.any(T::Boolean, T::Array[T.untyped], String),
177
+ item: T.nilable(YARD::CodeObjects::Base),
178
+ replace_errors_with_untyped: T::Boolean,
179
+ replace_unresolved_with_untyped: T::Boolean
180
+ ).returns(String)
181
+ end
182
+ def self.yard_to_sorbet(yard, item = nil, replace_errors_with_untyped = false, replace_unresolved_with_untyped = false); end
183
+
184
+ # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
185
+ sig do
186
+ params(
187
+ name: String,
188
+ log_warning: String,
158
189
  item: YARD::CodeObjects::Base,
159
- indent_level: Integer,
160
190
  replace_errors_with_untyped: T::Boolean
161
191
  ).returns(String)
162
192
  end
163
- def self.yard_to_sorbet(yard, item = nil, indent_level = 0, replace_errors_with_untyped = false); end
193
+ def self.handle_sord_error(name, log_warning, item, replace_errors_with_untyped); end
164
194
  end
165
195
  end
@@ -0,0 +1,214 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: true
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parlour/all/parlour.rbi
9
+ #
10
+ # parlour-0.6.1
11
+ module Parlour
12
+ end
13
+ module Kernel
14
+ end
15
+ class Parlour::Plugin
16
+ def generate(*args, &blk); end
17
+ def initialize(*args, &blk); end
18
+ def self.inherited(*args, &blk); end
19
+ def self.method_added(name); end
20
+ def self.registered_plugins(*args, &blk); end
21
+ def self.run_plugins(*args, &blk); end
22
+ def self.singleton_method_added(name); end
23
+ extend T::Helpers
24
+ extend T::InterfaceWrapper::Helpers
25
+ extend T::Private::Abstract::Hooks
26
+ extend T::Sig
27
+ end
28
+ class Parlour::RbiGenerator
29
+ def current_plugin(*args, &blk); end
30
+ def current_plugin=(arg0); end
31
+ def initialize(*args, &blk); end
32
+ def options(*args, &blk); end
33
+ def rbi(*args, &blk); end
34
+ def root(*args, &blk); end
35
+ def self.method_added(name); end
36
+ def self.singleton_method_added(name); end
37
+ extend T::Sig
38
+ end
39
+ class Parlour::RbiGenerator::Parameter
40
+ def ==(*args, &blk); end
41
+ def default(*args, &blk); end
42
+ def initialize(*args, &blk); end
43
+ def kind(*args, &blk); end
44
+ def name(*args, &blk); end
45
+ def name_without_kind(*args, &blk); end
46
+ def self.method_added(name); end
47
+ def self.singleton_method_added(name); end
48
+ def to_def_param(*args, &blk); end
49
+ def to_sig_param(*args, &blk); end
50
+ def type(*args, &blk); end
51
+ extend T::Sig
52
+ end
53
+ class Parlour::RbiGenerator::RbiObject
54
+ def add_comment(*args, &blk); end
55
+ def add_comments(*args, &blk); end
56
+ def comments(*args, &blk); end
57
+ def describe(*args, &blk); end
58
+ def generate_comments(*args, &blk); end
59
+ def generate_rbi(*args, &blk); end
60
+ def generated_by(*args, &blk); end
61
+ def generator(*args, &blk); end
62
+ def initialize(*args, &blk); end
63
+ def merge_into_self(*args, &blk); end
64
+ def mergeable?(*args, &blk); end
65
+ def name(*args, &blk); end
66
+ def self.method_added(name); end
67
+ def self.singleton_method_added(name); end
68
+ extend T::Helpers
69
+ extend T::InterfaceWrapper::Helpers
70
+ extend T::Private::Abstract::Hooks
71
+ extend T::Sig
72
+ end
73
+ class Parlour::RbiGenerator::Method < Parlour::RbiGenerator::RbiObject
74
+ def ==(*args, &blk); end
75
+ def abstract(*args, &blk); end
76
+ def class_method(*args, &blk); end
77
+ def describe(*args, &blk); end
78
+ def generate_definition(*args, &blk); end
79
+ def generate_rbi(*args, &blk); end
80
+ def implementation(*args, &blk); end
81
+ def initialize(*args, &blk); end
82
+ def merge_into_self(*args, &blk); end
83
+ def mergeable?(*args, &blk); end
84
+ def overridable(*args, &blk); end
85
+ def override(*args, &blk); end
86
+ def parameters(*args, &blk); end
87
+ def qualifiers(*args, &blk); end
88
+ def return_type(*args, &blk); end
89
+ def self.method_added(name); end
90
+ def self.singleton_method_added(name); end
91
+ extend T::Sig
92
+ end
93
+ class Parlour::RbiGenerator::Attribute < Parlour::RbiGenerator::Method
94
+ def generate_definition(*args, &blk); end
95
+ def initialize(*args, &blk); end
96
+ def kind(*args, &blk); end
97
+ def self.method_added(name); end
98
+ def self.singleton_method_added(name); end
99
+ end
100
+ class Parlour::RbiGenerator::Arbitrary < Parlour::RbiGenerator::RbiObject
101
+ def ==(*args, &blk); end
102
+ def code(*args, &blk); end
103
+ def code=(arg0); end
104
+ def describe(*args, &blk); end
105
+ def generate_rbi(*args, &blk); end
106
+ def initialize(*args, &blk); end
107
+ def merge_into_self(*args, &blk); end
108
+ def mergeable?(*args, &blk); end
109
+ def self.method_added(name); end
110
+ def self.singleton_method_added(name); end
111
+ end
112
+ class Parlour::RbiGenerator::Options
113
+ def break_params(*args, &blk); end
114
+ def indented(*args, &blk); end
115
+ def initialize(*args, &blk); end
116
+ def self.method_added(name); end
117
+ def self.singleton_method_added(name); end
118
+ def tab_size(*args, &blk); end
119
+ extend T::Sig
120
+ end
121
+ class Parlour::RbiGenerator::Include < Parlour::RbiGenerator::RbiObject
122
+ def ==(*args, &blk); end
123
+ def describe(*args, &blk); end
124
+ def generate_rbi(*args, &blk); end
125
+ def initialize(*args, &blk); end
126
+ def merge_into_self(*args, &blk); end
127
+ def mergeable?(*args, &blk); end
128
+ def self.method_added(name); end
129
+ def self.singleton_method_added(name); end
130
+ end
131
+ class Parlour::RbiGenerator::Extend < Parlour::RbiGenerator::RbiObject
132
+ def ==(*args, &blk); end
133
+ def describe(*args, &blk); end
134
+ def generate_rbi(*args, &blk); end
135
+ def initialize(*args, &blk); end
136
+ def merge_into_self(*args, &blk); end
137
+ def mergeable?(*args, &blk); end
138
+ def self.method_added(name); end
139
+ def self.singleton_method_added(name); end
140
+ end
141
+ class Parlour::RbiGenerator::Constant < Parlour::RbiGenerator::RbiObject
142
+ def ==(*args, &blk); end
143
+ def describe(*args, &blk); end
144
+ def generate_rbi(*args, &blk); end
145
+ def initialize(*args, &blk); end
146
+ def merge_into_self(*args, &blk); end
147
+ def mergeable?(*args, &blk); end
148
+ def self.method_added(name); end
149
+ def self.singleton_method_added(name); end
150
+ def value(*args, &blk); end
151
+ end
152
+ class Parlour::RbiGenerator::Namespace < Parlour::RbiGenerator::RbiObject
153
+ def add_comment_to_next_child(*args, &blk); end
154
+ def children(*args, &blk); end
155
+ def constants(*args, &blk); end
156
+ def create_arbitrary(code:, &block); end
157
+ def create_attr(name, kind:, type:, &block); end
158
+ def create_attr_accessor(name, type:, &block); end
159
+ def create_attr_reader(name, type:, &block); end
160
+ def create_attr_writer(name, type:, &block); end
161
+ def create_attribute(name, kind:, type:, &block); end
162
+ def create_class(*args, &blk); end
163
+ def create_constant(*args, &blk); end
164
+ def create_extend(*args, &blk); end
165
+ def create_extends(*args, &blk); end
166
+ def create_include(*args, &blk); end
167
+ def create_includes(*args, &blk); end
168
+ def create_method(*args, &blk); end
169
+ def create_module(*args, &blk); end
170
+ def describe(*args, &blk); end
171
+ def extends(*args, &blk); end
172
+ def generate_body(*args, &blk); end
173
+ def generate_rbi(*args, &blk); end
174
+ def includes(*args, &blk); end
175
+ def initialize(*args, &blk); end
176
+ def merge_into_self(*args, &blk); end
177
+ def mergeable?(*args, &blk); end
178
+ def move_next_comments(*args, &blk); end
179
+ def path(*args, &blk); end
180
+ def self.method_added(name); end
181
+ def self.singleton_method_added(name); end
182
+ extend T::Sig
183
+ end
184
+ class Parlour::RbiGenerator::ModuleNamespace < Parlour::RbiGenerator::Namespace
185
+ def describe(*args, &blk); end
186
+ def generate_rbi(*args, &blk); end
187
+ def initialize(*args, &blk); end
188
+ def interface(*args, &blk); end
189
+ def merge_into_self(*args, &blk); end
190
+ def mergeable?(*args, &blk); end
191
+ def self.method_added(name); end
192
+ def self.singleton_method_added(name); end
193
+ extend T::Sig
194
+ end
195
+ class Parlour::RbiGenerator::ClassNamespace < Parlour::RbiGenerator::Namespace
196
+ def abstract(*args, &blk); end
197
+ def describe(*args, &blk); end
198
+ def generate_rbi(*args, &blk); end
199
+ def initialize(*args, &blk); end
200
+ def merge_into_self(*args, &blk); end
201
+ def mergeable?(*args, &blk); end
202
+ def self.method_added(name); end
203
+ def self.singleton_method_added(name); end
204
+ def superclass(*args, &blk); end
205
+ extend T::Sig
206
+ end
207
+ class Parlour::ConflictResolver
208
+ def all_eql?(*args, &blk); end
209
+ def resolve_conflicts(*args, &blk); end
210
+ def self.method_added(name); end
211
+ def self.singleton_method_added(name); end
212
+ def single_type_of_array(*args, &blk); end
213
+ extend T::Sig
214
+ end
@@ -0,0 +1,117 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: true
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rainbow/all/rainbow.rbi
9
+ #
10
+ # rainbow-3.0.0
11
+ module Rainbow
12
+ def self.enabled; end
13
+ def self.enabled=(value); end
14
+ def self.global; end
15
+ def self.new; end
16
+ def self.uncolor(string); end
17
+ end
18
+ class Rainbow::StringUtils
19
+ def self.uncolor(string); end
20
+ def self.wrap_with_sgr(string, codes); end
21
+ end
22
+ module Rainbow::X11ColorNames
23
+ end
24
+ class Rainbow::Color
25
+ def ground; end
26
+ def self.build(ground, values); end
27
+ def self.parse_hex_color(hex); end
28
+ end
29
+ class Rainbow::Color::Indexed < Rainbow::Color
30
+ def codes; end
31
+ def initialize(ground, num); end
32
+ def num; end
33
+ end
34
+ class Rainbow::Color::Named < Rainbow::Color::Indexed
35
+ def initialize(ground, name); end
36
+ def self.color_names; end
37
+ def self.valid_names; end
38
+ end
39
+ class Rainbow::Color::RGB < Rainbow::Color::Indexed
40
+ def b; end
41
+ def code_from_rgb; end
42
+ def codes; end
43
+ def g; end
44
+ def initialize(ground, *values); end
45
+ def r; end
46
+ def self.to_ansi_domain(value); end
47
+ end
48
+ class Rainbow::Color::X11Named < Rainbow::Color::RGB
49
+ def initialize(ground, name); end
50
+ def self.color_names; end
51
+ def self.valid_names; end
52
+ include Rainbow::X11ColorNames
53
+ end
54
+ class Rainbow::Presenter < String
55
+ def background(*values); end
56
+ def bg(*values); end
57
+ def black; end
58
+ def blink; end
59
+ def blue; end
60
+ def bold; end
61
+ def bright; end
62
+ def color(*values); end
63
+ def cyan; end
64
+ def dark; end
65
+ def faint; end
66
+ def fg(*values); end
67
+ def foreground(*values); end
68
+ def green; end
69
+ def hide; end
70
+ def inverse; end
71
+ def italic; end
72
+ def magenta; end
73
+ def method_missing(method_name, *args); end
74
+ def red; end
75
+ def reset; end
76
+ def respond_to_missing?(method_name, *args); end
77
+ def underline; end
78
+ def white; end
79
+ def wrap_with_sgr(codes); end
80
+ def yellow; end
81
+ end
82
+ class Rainbow::NullPresenter < String
83
+ def background(*_values); end
84
+ def bg(*_values); end
85
+ def black; end
86
+ def blink; end
87
+ def blue; end
88
+ def bold; end
89
+ def bright; end
90
+ def color(*_values); end
91
+ def cyan; end
92
+ def dark; end
93
+ def faint; end
94
+ def fg(*_values); end
95
+ def foreground(*_values); end
96
+ def green; end
97
+ def hide; end
98
+ def inverse; end
99
+ def italic; end
100
+ def magenta; end
101
+ def method_missing(method_name, *args); end
102
+ def red; end
103
+ def reset; end
104
+ def respond_to_missing?(method_name, *args); end
105
+ def underline; end
106
+ def white; end
107
+ def yellow; end
108
+ end
109
+ class Rainbow::Wrapper
110
+ def enabled; end
111
+ def enabled=(arg0); end
112
+ def initialize(enabled = nil); end
113
+ def wrap(string); end
114
+ end
115
+ class Object < BasicObject
116
+ def Rainbow(string); end
117
+ end
@@ -7,7 +7,7 @@
7
7
  #
8
8
  # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-core/all/rspec-core.rbi
9
9
  #
10
- # rspec-core-3.8.1
10
+ # rspec-core-3.8.2
11
11
  module RSpec
12
12
  def self.clear_examples; end
13
13
  def self.configuration; end
@@ -7,13 +7,14 @@
7
7
  #
8
8
  # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov/all/simplecov.rbi
9
9
  #
10
- # simplecov-0.16.1
10
+ # simplecov-0.17.0
11
11
  module SimpleCov
12
12
  def self.add_not_loaded_files(result); end
13
13
  def self.clear_result; end
14
14
  def self.exit_exception; end
15
15
  def self.exit_status_from_exception; end
16
16
  def self.filtered(files); end
17
+ def self.final_result_process?; end
17
18
  def self.grouped(files); end
18
19
  def self.load_adapter(name); end
19
20
  def self.load_profile(name); end
@@ -29,6 +30,7 @@ module SimpleCov
29
30
  def self.set_exit_exception; end
30
31
  def self.start(profile = nil, &block); end
31
32
  def self.usable?; end
33
+ def self.wait_for_other_processes; end
32
34
  def self.write_last_run(covered_percent); end
33
35
  extend SimpleCov::Configuration
34
36
  end