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.
- checksums.yaml +4 -4
- data/.parlour +7 -0
- data/.travis.yml +6 -0
- data/CHANGELOG.md +46 -0
- data/README.md +1 -0
- data/Rakefile +67 -11
- data/exe/sord +10 -35
- data/lib/sord/logging.rb +21 -30
- data/lib/sord/parlour_plugin.rb +63 -0
- data/lib/sord/rbi_generator.rb +116 -150
- data/lib/sord/resolver.rb +9 -2
- data/lib/sord/type_converter.rb +57 -19
- data/lib/sord/version.rb +1 -1
- data/lib/sord.rb +1 -0
- data/rbi/sord.rbi +96 -66
- data/sorbet/rbi/gems/parlour.rbi +214 -0
- data/sorbet/rbi/gems/rainbow.rbi +117 -0
- data/sorbet/rbi/gems/rspec-core.rbi +1 -1
- data/sorbet/rbi/gems/simplecov.rbi +3 -1
- data/sorbet/rbi/gems/sorbet-runtime.rbi +45 -22
- data/sorbet/rbi/gems/yard.rbi +3 -3
- data/sorbet/rbi/hidden-definitions/errors.txt +26 -94
- data/sorbet/rbi/hidden-definitions/hidden.rbi +16179 -6215
- data/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi +32 -4
- data/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi +14 -14
- data/sord.gemspec +1 -1
- metadata +16 -12
- data/sorbet/rbi/gems/colorize.rbi +0 -81
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
|
9
|
+
def self.hooks; end
|
6
10
|
|
7
11
|
sig { returns(T::Boolean) }
|
8
|
-
def self.silent
|
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
|
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
|
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
|
36
|
-
def self.warn(msg, item = nil
|
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
|
40
|
-
def self.info(msg, item = nil
|
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
|
44
|
-
def self.duck(msg, item = nil
|
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
|
48
|
-
def self.error(msg, item = nil
|
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
|
52
|
-
def self.infer(msg, item = nil
|
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
|
56
|
-
def self.omit(msg, item = nil
|
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
|
60
|
-
def self.done(msg, item = nil
|
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
|
64
|
-
|
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
|
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
|
76
|
+
def self.prepare; end
|
81
77
|
|
82
78
|
sig { void }
|
83
|
-
def self.clear
|
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
|
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
|
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
|
108
|
-
|
109
|
-
sig { returns(T::Boolean) }
|
110
|
-
def next_item_is_first_in_namespace(); end
|
100
|
+
def warnings; end
|
111
101
|
|
112
|
-
|
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
|
121
|
-
|
122
|
-
sig { void }
|
123
|
-
def count_method(); end
|
106
|
+
def count_namespace; end
|
124
107
|
|
125
108
|
sig { void }
|
126
|
-
def
|
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
|
130
|
-
def add_mixins(item
|
112
|
+
sig { params(item: YARD::CodeObjects::Base).returns(Integer) }
|
113
|
+
def add_mixins(item); end
|
131
114
|
|
132
|
-
|
133
|
-
|
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
|
137
|
-
def add_methods(item
|
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
|
141
|
-
def add_namespace(item
|
124
|
+
sig { params(item: YARD::CodeObjects::NamespaceObject).void }
|
125
|
+
def add_namespace(item); end
|
142
126
|
|
143
|
-
sig {
|
144
|
-
def
|
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
|
-
|
147
|
-
|
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.
|
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,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.
|
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
|