clean-architecture 3.0.0 → 3.0.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/.github/workflows/ci.yml +52 -0
- data/.ruby-version +1 -1
- data/CHANGELOG.md +4 -0
- data/Gemfile +0 -2
- data/clean-architecture.gemspec +3 -3
- data/lib/clean_architecture/queries/http_failure_code.rb +2 -1
- data/lib/clean_architecture/version.rb +1 -1
- data/sorbet/rbi/gems/activemodel.rbi +2 -1
- data/sorbet/rbi/gems/activesupport.rbi +3 -3
- data/sorbet/rbi/gems/ast.rbi +1 -0
- data/sorbet/rbi/gems/byebug.rbi +3 -2
- data/sorbet/rbi/gems/coderay.rbi +1 -0
- data/sorbet/rbi/gems/concurrent-ruby.rbi +22 -23
- data/sorbet/rbi/gems/docile.rbi +1 -0
- data/sorbet/rbi/gems/dry-configurable.rbi +107 -57
- data/sorbet/rbi/gems/dry-container.rbi +1 -0
- data/sorbet/rbi/gems/dry-core.rbi +1 -0
- data/sorbet/rbi/gems/dry-equalizer.rbi +5 -4
- data/sorbet/rbi/gems/dry-inflector.rbi +1 -0
- data/sorbet/rbi/gems/dry-initializer.rbi +4 -4
- data/sorbet/rbi/gems/dry-logic.rbi +12 -11
- data/sorbet/rbi/gems/dry-matcher.rbi +2 -1
- data/sorbet/rbi/gems/dry-monads.rbi +8 -6
- data/sorbet/rbi/gems/dry-schema.rbi +92 -96
- data/sorbet/rbi/gems/dry-struct.rbi +32 -60
- data/sorbet/rbi/gems/dry-types.rbi +76 -55
- data/sorbet/rbi/gems/dry-validation.rbi +34 -30
- data/sorbet/rbi/gems/duckface-interfaces.rbi +1 -0
- data/sorbet/rbi/gems/i18n.rbi +2 -1
- data/sorbet/rbi/gems/jaro_winkler.rbi +2 -1
- data/sorbet/rbi/gems/method_source.rbi +1 -0
- data/sorbet/rbi/gems/parallel.rbi +2 -1
- data/sorbet/rbi/gems/parser.rbi +80 -452
- data/sorbet/rbi/gems/pry-byebug.rbi +10 -4
- data/sorbet/rbi/gems/pry.rbi +1 -0
- data/sorbet/rbi/gems/rainbow.rbi +1 -0
- data/sorbet/rbi/gems/rake.rbi +77 -67
- data/sorbet/rbi/gems/rb-readline.rbi +1 -0
- data/sorbet/rbi/gems/rexml.rbi +589 -0
- data/sorbet/rbi/gems/rspec-core.rbi +14 -1
- data/sorbet/rbi/gems/rspec-expectations.rbi +2 -34
- data/sorbet/rbi/gems/rspec-mocks.rbi +133 -1
- data/sorbet/rbi/gems/rspec-support.rbi +4 -1
- data/sorbet/rbi/gems/rspec.rbi +1 -0
- data/sorbet/rbi/gems/rubocop-rspec.rbi +51 -4
- data/sorbet/rbi/gems/rubocop.rbi +746 -442
- data/sorbet/rbi/gems/ruby-progressbar.rbi +1 -0
- data/sorbet/rbi/gems/simplecov-html.rbi +6 -1
- data/sorbet/rbi/gems/simplecov.rbi +144 -17
- data/sorbet/rbi/gems/stackprof.rbi +2 -1
- data/sorbet/rbi/gems/unicode-display_width.rbi +2 -1
- data/sorbet/rbi/hidden-definitions/errors.txt +2040 -890
- data/sorbet/rbi/hidden-definitions/hidden.rbi +1431 -2092
- data/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi +325 -295
- data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +357 -3
- data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +9 -0
- data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +37 -15
- data/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi +8 -8
- data/sorbet/rbi/todo.rbi +1 -4
- metadata +11 -23
- data/.github/workflows/rspec.yml +0 -21
- data/sorbet/rbi/gems/axiom-types.rbi +0 -159
- data/sorbet/rbi/gems/codeclimate-engine-rb.rbi +0 -123
- data/sorbet/rbi/gems/coercible.rbi +0 -156
- data/sorbet/rbi/gems/descendants_tracker.rbi +0 -17
- data/sorbet/rbi/gems/equalizer.rbi +0 -22
- data/sorbet/rbi/gems/ice_nine.rbi +0 -66
- data/sorbet/rbi/gems/kwalify.rbi +0 -339
- data/sorbet/rbi/gems/psych.rbi +0 -462
- data/sorbet/rbi/gems/reek.rbi +0 -1066
- data/sorbet/rbi/gems/thread_safe.rbi +0 -81
- data/sorbet/rbi/gems/timecop.rbi +0 -97
- data/sorbet/rbi/gems/virtus.rbi +0 -421
@@ -7,7 +7,8 @@
|
|
7
7
|
#
|
8
8
|
# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/pry-byebug/all/pry-byebug.rbi
|
9
9
|
#
|
10
|
-
# pry-byebug-3.
|
10
|
+
# pry-byebug-3.8.0
|
11
|
+
|
11
12
|
module PryByebug
|
12
13
|
def check_file_context(target, msg = nil); end
|
13
14
|
def current_remote_server; end
|
@@ -16,6 +17,12 @@ module PryByebug
|
|
16
17
|
def self.check_file_context(target, msg = nil); end
|
17
18
|
def self.file_context?(target); end
|
18
19
|
end
|
20
|
+
module PryByebug::Helpers
|
21
|
+
end
|
22
|
+
module PryByebug::Helpers::Location
|
23
|
+
def current_file(source = nil); end
|
24
|
+
def self.current_file(source = nil); end
|
25
|
+
end
|
19
26
|
module Byebug
|
20
27
|
end
|
21
28
|
class Byebug::PryProcessor < Byebug::CommandProcessor
|
@@ -45,8 +52,6 @@ class Pry
|
|
45
52
|
def self.start_with_pry_byebug(target = nil, options = nil); end
|
46
53
|
def self.start_without_pry_byebug(target = nil, options = nil); end
|
47
54
|
end
|
48
|
-
module PryByebug::Helpers
|
49
|
-
end
|
50
55
|
module PryByebug::Helpers::Navigation
|
51
56
|
def breakout_navigation(action, options = nil); end
|
52
57
|
end
|
@@ -69,7 +74,6 @@ end
|
|
69
74
|
module PryByebug::Helpers::Breakpoints
|
70
75
|
def bold_puts(msg); end
|
71
76
|
def breakpoints; end
|
72
|
-
def current_file; end
|
73
77
|
def max_width; end
|
74
78
|
def print_breakpoints_header; end
|
75
79
|
def print_full_breakpoint(breakpoint); end
|
@@ -78,6 +82,7 @@ end
|
|
78
82
|
class PryByebug::ContinueCommand < Pry::ClassCommand
|
79
83
|
def process; end
|
80
84
|
include PryByebug::Helpers::Breakpoints
|
85
|
+
include PryByebug::Helpers::Location
|
81
86
|
include PryByebug::Helpers::Navigation
|
82
87
|
end
|
83
88
|
class PryByebug::FinishCommand < Pry::ClassCommand
|
@@ -142,6 +147,7 @@ class PryByebug::BreakCommand < Pry::ClassCommand
|
|
142
147
|
def process_enable; end
|
143
148
|
def process_show; end
|
144
149
|
include PryByebug::Helpers::Breakpoints
|
150
|
+
include PryByebug::Helpers::Location
|
145
151
|
include PryByebug::Helpers::Multiline
|
146
152
|
end
|
147
153
|
class PryByebug::ExitAllCommand < Pry::Command::ExitAll
|
data/sorbet/rbi/gems/pry.rbi
CHANGED
data/sorbet/rbi/gems/rainbow.rbi
CHANGED
data/sorbet/rbi/gems/rake.rbi
CHANGED
@@ -7,7 +7,8 @@
|
|
7
7
|
#
|
8
8
|
# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rake/all/rake.rbi
|
9
9
|
#
|
10
|
-
# rake-
|
10
|
+
# rake-13.0.1
|
11
|
+
|
11
12
|
module Rake
|
12
13
|
def self.add_rakelib(*files); end
|
13
14
|
def self.application; end
|
@@ -117,52 +118,52 @@ module Rake::Cloneable
|
|
117
118
|
end
|
118
119
|
module FileUtils
|
119
120
|
def create_shell_runner(cmd); end
|
120
|
-
def ruby(*args, &block); end
|
121
|
-
def safe_ln(*args); end
|
121
|
+
def ruby(*args, **options, &block); end
|
122
|
+
def safe_ln(*args, **options); end
|
122
123
|
def set_verbose_option(options); end
|
123
124
|
def sh(*cmd, &block); end
|
124
125
|
def sh_show_command(cmd); end
|
125
126
|
def split_all(path); end
|
126
127
|
end
|
127
128
|
module Rake::FileUtilsExt
|
128
|
-
def cd(*args, &block); end
|
129
|
-
def chdir(*args, &block); end
|
130
|
-
def chmod(*args, &block); end
|
131
|
-
def chmod_R(*args, &block); end
|
132
|
-
def chown(*args, &block); end
|
133
|
-
def chown_R(*args, &block); end
|
134
|
-
def copy(*args, &block); end
|
135
|
-
def cp(*args, &block); end
|
136
|
-
def
|
137
|
-
def
|
138
|
-
def
|
139
|
-
def
|
140
|
-
def
|
141
|
-
def
|
142
|
-
def
|
143
|
-
def
|
144
|
-
def
|
145
|
-
def
|
146
|
-
def
|
147
|
-
def
|
129
|
+
def cd(*args, **options, &block); end
|
130
|
+
def chdir(*args, **options, &block); end
|
131
|
+
def chmod(*args, **options, &block); end
|
132
|
+
def chmod_R(*args, **options, &block); end
|
133
|
+
def chown(*args, **options, &block); end
|
134
|
+
def chown_R(*args, **options, &block); end
|
135
|
+
def copy(*args, **options, &block); end
|
136
|
+
def cp(*args, **options, &block); end
|
137
|
+
def cp_lr(*args, **options, &block); end
|
138
|
+
def cp_r(*args, **options, &block); end
|
139
|
+
def install(*args, **options, &block); end
|
140
|
+
def link(*args, **options, &block); end
|
141
|
+
def ln(*args, **options, &block); end
|
142
|
+
def ln_s(*args, **options, &block); end
|
143
|
+
def ln_sf(*args, **options, &block); end
|
144
|
+
def makedirs(*args, **options, &block); end
|
145
|
+
def mkdir(*args, **options, &block); end
|
146
|
+
def mkdir_p(*args, **options, &block); end
|
147
|
+
def mkpath(*args, **options, &block); end
|
148
|
+
def move(*args, **options, &block); end
|
149
|
+
def mv(*args, **options, &block); end
|
148
150
|
def nowrite(value = nil); end
|
149
151
|
def rake_check_options(options, *optdecl); end
|
150
|
-
def rake_merge_option(args, defaults); end
|
151
152
|
def rake_output_message(message); end
|
152
|
-
def remove(*args, &block); end
|
153
|
-
def rm(*args, &block); end
|
154
|
-
def rm_f(*args, &block); end
|
155
|
-
def rm_r(*args, &block); end
|
156
|
-
def rm_rf(*args, &block); end
|
157
|
-
def rmdir(*args, &block); end
|
158
|
-
def rmtree(*args, &block); end
|
159
|
-
def safe_unlink(*args, &block); end
|
153
|
+
def remove(*args, **options, &block); end
|
154
|
+
def rm(*args, **options, &block); end
|
155
|
+
def rm_f(*args, **options, &block); end
|
156
|
+
def rm_r(*args, **options, &block); end
|
157
|
+
def rm_rf(*args, **options, &block); end
|
158
|
+
def rmdir(*args, **options, &block); end
|
159
|
+
def rmtree(*args, **options, &block); end
|
160
|
+
def safe_unlink(*args, **options, &block); end
|
160
161
|
def self.nowrite_flag; end
|
161
162
|
def self.nowrite_flag=(arg0); end
|
162
163
|
def self.verbose_flag; end
|
163
164
|
def self.verbose_flag=(arg0); end
|
164
|
-
def symlink(*args, &block); end
|
165
|
-
def touch(*args, &block); end
|
165
|
+
def symlink(*args, **options, &block); end
|
166
|
+
def touch(*args, **options, &block); end
|
166
167
|
def verbose(value = nil); end
|
167
168
|
def when_writing(msg = nil); end
|
168
169
|
extend Rake::FileUtilsExt
|
@@ -187,6 +188,7 @@ class Rake::FileList
|
|
187
188
|
def at(*args, &block); end
|
188
189
|
def bsearch(*args, &block); end
|
189
190
|
def bsearch_index(*args, &block); end
|
191
|
+
def chain(*args, &block); end
|
190
192
|
def chunk(*args, &block); end
|
191
193
|
def chunk_while(*args, &block); end
|
192
194
|
def clear(*args, &block); end
|
@@ -204,6 +206,7 @@ class Rake::FileList
|
|
204
206
|
def delete_at(*args, &block); end
|
205
207
|
def delete_if(*args, &block); end
|
206
208
|
def detect(*args, &block); end
|
209
|
+
def difference(*args, &block); end
|
207
210
|
def dig(*args, &block); end
|
208
211
|
def drop(*args, &block); end
|
209
212
|
def drop_while(*args, &block); end
|
@@ -222,8 +225,11 @@ class Rake::FileList
|
|
222
225
|
def existing!; end
|
223
226
|
def existing; end
|
224
227
|
def ext(newext = nil); end
|
228
|
+
def extract_options!(*args, &block); end
|
225
229
|
def fetch(*args, &block); end
|
226
230
|
def fill(*args, &block); end
|
231
|
+
def filter!(*args, &block); end
|
232
|
+
def filter(*args, &block); end
|
227
233
|
def find(*args, &block); end
|
228
234
|
def find_all(*args, &block); end
|
229
235
|
def find_index(*args, &block); end
|
@@ -316,6 +322,7 @@ class Rake::FileList
|
|
316
322
|
def to_s; end
|
317
323
|
def to_set(*args, &block); end
|
318
324
|
def transpose(*args, &block); end
|
325
|
+
def union(*args, &block); end
|
319
326
|
def uniq!(*args, &block); end
|
320
327
|
def uniq(*args, &block); end
|
321
328
|
def unshift(*args, &block); end
|
@@ -515,6 +522,7 @@ class Rake::Task
|
|
515
522
|
def name; end
|
516
523
|
def name_with_args; end
|
517
524
|
def needed?; end
|
525
|
+
def order_only_prerequisites; end
|
518
526
|
def prereqs; end
|
519
527
|
def prerequisite_tasks; end
|
520
528
|
def prerequisites; end
|
@@ -524,6 +532,7 @@ class Rake::Task
|
|
524
532
|
def self.clear; end
|
525
533
|
def self.create_rule(*args, &block); end
|
526
534
|
def self.define_task(*args, &block); end
|
535
|
+
def self.format_deps(deps); end
|
527
536
|
def self.scope_name(scope, task_name); end
|
528
537
|
def self.task_defined?(task_name); end
|
529
538
|
def self.tasks; end
|
@@ -534,6 +543,7 @@ class Rake::Task
|
|
534
543
|
def timestamp; end
|
535
544
|
def to_s; end
|
536
545
|
def transform_comments(separator, &block); end
|
546
|
+
def |(deps); end
|
537
547
|
end
|
538
548
|
class Rake::EarlyTime
|
539
549
|
def <=>(other); end
|
@@ -559,53 +569,53 @@ class Rake::MultiTask < Rake::Task
|
|
559
569
|
def invoke_prerequisites(task_args, invocation_chain); end
|
560
570
|
end
|
561
571
|
module Rake::DSL
|
562
|
-
def cd(*args, &block); end
|
563
|
-
def chdir(*args, &block); end
|
564
|
-
def chmod(*args, &block); end
|
565
|
-
def chmod_R(*args, &block); end
|
566
|
-
def chown(*args, &block); end
|
567
|
-
def chown_R(*args, &block); end
|
568
|
-
def copy(*args, &block); end
|
569
|
-
def cp(*args, &block); end
|
570
|
-
def
|
572
|
+
def cd(*args, **options, &block); end
|
573
|
+
def chdir(*args, **options, &block); end
|
574
|
+
def chmod(*args, **options, &block); end
|
575
|
+
def chmod_R(*args, **options, &block); end
|
576
|
+
def chown(*args, **options, &block); end
|
577
|
+
def chown_R(*args, **options, &block); end
|
578
|
+
def copy(*args, **options, &block); end
|
579
|
+
def cp(*args, **options, &block); end
|
580
|
+
def cp_lr(*args, **options, &block); end
|
581
|
+
def cp_r(*args, **options, &block); end
|
571
582
|
def desc(description); end
|
572
583
|
def directory(*args, &block); end
|
573
584
|
def file(*args, &block); end
|
574
585
|
def file_create(*args, &block); end
|
575
586
|
def import(*fns); end
|
576
|
-
def install(*args, &block); end
|
577
|
-
def link(*args, &block); end
|
578
|
-
def ln(*args, &block); end
|
579
|
-
def ln_s(*args, &block); end
|
580
|
-
def ln_sf(*args, &block); end
|
581
|
-
def makedirs(*args, &block); end
|
582
|
-
def mkdir(*args, &block); end
|
583
|
-
def mkdir_p(*args, &block); end
|
584
|
-
def mkpath(*args, &block); end
|
585
|
-
def move(*args, &block); end
|
587
|
+
def install(*args, **options, &block); end
|
588
|
+
def link(*args, **options, &block); end
|
589
|
+
def ln(*args, **options, &block); end
|
590
|
+
def ln_s(*args, **options, &block); end
|
591
|
+
def ln_sf(*args, **options, &block); end
|
592
|
+
def makedirs(*args, **options, &block); end
|
593
|
+
def mkdir(*args, **options, &block); end
|
594
|
+
def mkdir_p(*args, **options, &block); end
|
595
|
+
def mkpath(*args, **options, &block); end
|
596
|
+
def move(*args, **options, &block); end
|
586
597
|
def multitask(*args, &block); end
|
587
|
-
def mv(*args, &block); end
|
598
|
+
def mv(*args, **options, &block); end
|
588
599
|
def namespace(name = nil, &block); end
|
589
600
|
def nowrite(value = nil); end
|
590
601
|
def rake_check_options(options, *optdecl); end
|
591
|
-
def rake_merge_option(args, defaults); end
|
592
602
|
def rake_output_message(message); end
|
593
|
-
def remove(*args, &block); end
|
594
|
-
def rm(*args, &block); end
|
595
|
-
def rm_f(*args, &block); end
|
596
|
-
def rm_r(*args, &block); end
|
597
|
-
def rm_rf(*args, &block); end
|
598
|
-
def rmdir(*args, &block); end
|
599
|
-
def rmtree(*args, &block); end
|
600
|
-
def ruby(*args, &block); end
|
603
|
+
def remove(*args, **options, &block); end
|
604
|
+
def rm(*args, **options, &block); end
|
605
|
+
def rm_f(*args, **options, &block); end
|
606
|
+
def rm_r(*args, **options, &block); end
|
607
|
+
def rm_rf(*args, **options, &block); end
|
608
|
+
def rmdir(*args, **options, &block); end
|
609
|
+
def rmtree(*args, **options, &block); end
|
610
|
+
def ruby(*args, **options, &block); end
|
601
611
|
def rule(*args, &block); end
|
602
|
-
def safe_ln(*args); end
|
603
|
-
def safe_unlink(*args, &block); end
|
612
|
+
def safe_ln(*args, **options); end
|
613
|
+
def safe_unlink(*args, **options, &block); end
|
604
614
|
def sh(*cmd, &block); end
|
605
615
|
def split_all(path); end
|
606
|
-
def symlink(*args, &block); end
|
616
|
+
def symlink(*args, **options, &block); end
|
607
617
|
def task(*args, &block); end
|
608
|
-
def touch(*args, &block); end
|
618
|
+
def touch(*args, **options, &block); end
|
609
619
|
def verbose(value = nil); end
|
610
620
|
def when_writing(msg = nil); end
|
611
621
|
include Rake::FileUtilsExt
|
@@ -0,0 +1,589 @@
|
|
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/rexml/all/rexml.rbi
|
9
|
+
#
|
10
|
+
# rexml-3.2.4
|
11
|
+
|
12
|
+
module REXML
|
13
|
+
end
|
14
|
+
module REXML::Security
|
15
|
+
def self.entity_expansion_limit; end
|
16
|
+
def self.entity_expansion_limit=(val); end
|
17
|
+
def self.entity_expansion_text_limit; end
|
18
|
+
def self.entity_expansion_text_limit=(val); end
|
19
|
+
end
|
20
|
+
class REXML::ParseException < RuntimeError
|
21
|
+
def context; end
|
22
|
+
def continued_exception; end
|
23
|
+
def continued_exception=(arg0); end
|
24
|
+
def initialize(message, source = nil, parser = nil, exception = nil); end
|
25
|
+
def line; end
|
26
|
+
def parser; end
|
27
|
+
def parser=(arg0); end
|
28
|
+
def position; end
|
29
|
+
def source; end
|
30
|
+
def source=(arg0); end
|
31
|
+
def to_s; end
|
32
|
+
end
|
33
|
+
module REXML::Formatters
|
34
|
+
end
|
35
|
+
class REXML::Formatters::Default
|
36
|
+
def initialize(ie_hack = nil); end
|
37
|
+
def write(node, output); end
|
38
|
+
def write_cdata(node, output); end
|
39
|
+
def write_comment(node, output); end
|
40
|
+
def write_document(node, output); end
|
41
|
+
def write_element(node, output); end
|
42
|
+
def write_instruction(node, output); end
|
43
|
+
def write_text(node, output); end
|
44
|
+
end
|
45
|
+
class REXML::Formatters::Pretty < REXML::Formatters::Default
|
46
|
+
def compact; end
|
47
|
+
def compact=(arg0); end
|
48
|
+
def indent_text(string, level = nil, style = nil, indentfirstline = nil); end
|
49
|
+
def initialize(indentation = nil, ie_hack = nil); end
|
50
|
+
def width; end
|
51
|
+
def width=(arg0); end
|
52
|
+
def wrap(string, width); end
|
53
|
+
def write_cdata(node, output); end
|
54
|
+
def write_comment(node, output); end
|
55
|
+
def write_document(node, output); end
|
56
|
+
def write_element(node, output); end
|
57
|
+
def write_text(node, output); end
|
58
|
+
end
|
59
|
+
module REXML::Node
|
60
|
+
def each_recursive(&block); end
|
61
|
+
def find_first_recursive(&block); end
|
62
|
+
def indent(to, ind); end
|
63
|
+
def index_in_parent; end
|
64
|
+
def next_sibling_node; end
|
65
|
+
def parent?; end
|
66
|
+
def previous_sibling_node; end
|
67
|
+
def to_s(indent = nil); end
|
68
|
+
end
|
69
|
+
class REXML::Child
|
70
|
+
def bytes; end
|
71
|
+
def document; end
|
72
|
+
def initialize(parent = nil); end
|
73
|
+
def next_sibling; end
|
74
|
+
def next_sibling=(other); end
|
75
|
+
def parent; end
|
76
|
+
def parent=(other); end
|
77
|
+
def previous_sibling; end
|
78
|
+
def previous_sibling=(other); end
|
79
|
+
def remove; end
|
80
|
+
def replace_with(child); end
|
81
|
+
include REXML::Node
|
82
|
+
end
|
83
|
+
class REXML::Parent < REXML::Child
|
84
|
+
def <<(object); end
|
85
|
+
def [](index); end
|
86
|
+
def []=(*args); end
|
87
|
+
def add(object); end
|
88
|
+
def children; end
|
89
|
+
def deep_clone; end
|
90
|
+
def delete(object); end
|
91
|
+
def delete_at(index); end
|
92
|
+
def delete_if(&block); end
|
93
|
+
def each(&block); end
|
94
|
+
def each_child(&block); end
|
95
|
+
def each_index(&block); end
|
96
|
+
def index(child); end
|
97
|
+
def initialize(parent = nil); end
|
98
|
+
def insert_after(child1, child2); end
|
99
|
+
def insert_before(child1, child2); end
|
100
|
+
def length; end
|
101
|
+
def parent?; end
|
102
|
+
def push(object); end
|
103
|
+
def replace_child(to_replace, replacement); end
|
104
|
+
def size; end
|
105
|
+
def to_a; end
|
106
|
+
def unshift(object); end
|
107
|
+
include Enumerable
|
108
|
+
end
|
109
|
+
module REXML::XMLTokens
|
110
|
+
end
|
111
|
+
module REXML::Namespace
|
112
|
+
def expanded_name; end
|
113
|
+
def fully_expanded_name; end
|
114
|
+
def has_name?(other, ns = nil); end
|
115
|
+
def local_name; end
|
116
|
+
def name; end
|
117
|
+
def name=(name); end
|
118
|
+
def prefix; end
|
119
|
+
def prefix=(arg0); end
|
120
|
+
include REXML::XMLTokens
|
121
|
+
end
|
122
|
+
module REXML::Encoding
|
123
|
+
def decode(string); end
|
124
|
+
def encode(string); end
|
125
|
+
def encoding; end
|
126
|
+
def encoding=(encoding); end
|
127
|
+
def find_encoding(name); end
|
128
|
+
end
|
129
|
+
class REXML::SourceFactory
|
130
|
+
def self.create_from(arg); end
|
131
|
+
end
|
132
|
+
class REXML::Source
|
133
|
+
def buffer; end
|
134
|
+
def consume(pattern); end
|
135
|
+
def current_line; end
|
136
|
+
def detect_encoding; end
|
137
|
+
def empty?; end
|
138
|
+
def encoding; end
|
139
|
+
def encoding=(enc); end
|
140
|
+
def encoding_updated; end
|
141
|
+
def initialize(arg, encoding = nil); end
|
142
|
+
def line; end
|
143
|
+
def match(pattern, cons = nil); end
|
144
|
+
def match_to(char, pattern); end
|
145
|
+
def match_to_consume(char, pattern); end
|
146
|
+
def position; end
|
147
|
+
def read; end
|
148
|
+
def scan(pattern, cons = nil); end
|
149
|
+
include REXML::Encoding
|
150
|
+
end
|
151
|
+
class REXML::IOSource < REXML::Source
|
152
|
+
def consume(pattern); end
|
153
|
+
def current_line; end
|
154
|
+
def empty?; end
|
155
|
+
def encoding_updated; end
|
156
|
+
def initialize(arg, block_size = nil, encoding = nil); end
|
157
|
+
def match(pattern, cons = nil); end
|
158
|
+
def position; end
|
159
|
+
def read; end
|
160
|
+
def readline; end
|
161
|
+
def scan(pattern, cons = nil); end
|
162
|
+
end
|
163
|
+
class REXML::Entity < REXML::Child
|
164
|
+
def external; end
|
165
|
+
def initialize(stream, value = nil, parent = nil, reference = nil); end
|
166
|
+
def name; end
|
167
|
+
def ndata; end
|
168
|
+
def normalized; end
|
169
|
+
def pubid; end
|
170
|
+
def ref; end
|
171
|
+
def self.matches?(string); end
|
172
|
+
def to_s; end
|
173
|
+
def unnormalized; end
|
174
|
+
def value; end
|
175
|
+
def write(out, indent = nil); end
|
176
|
+
include REXML::XMLTokens
|
177
|
+
end
|
178
|
+
module REXML::EntityConst
|
179
|
+
end
|
180
|
+
class REXML::AttlistDecl < REXML::Child
|
181
|
+
def [](key); end
|
182
|
+
def each(&block); end
|
183
|
+
def element_name; end
|
184
|
+
def include?(key); end
|
185
|
+
def initialize(source); end
|
186
|
+
def node_type; end
|
187
|
+
def write(out, indent = nil); end
|
188
|
+
include Enumerable
|
189
|
+
end
|
190
|
+
class REXML::DocType < REXML::Parent
|
191
|
+
def add(child); end
|
192
|
+
def attribute_of(element, attribute); end
|
193
|
+
def attributes_of(element); end
|
194
|
+
def clone; end
|
195
|
+
def context; end
|
196
|
+
def entities; end
|
197
|
+
def entity(name); end
|
198
|
+
def external_id; end
|
199
|
+
def initialize(first, parent = nil); end
|
200
|
+
def name; end
|
201
|
+
def namespaces; end
|
202
|
+
def node_type; end
|
203
|
+
def notation(name); end
|
204
|
+
def notations; end
|
205
|
+
def public; end
|
206
|
+
def strip_quotes(quoted_string); end
|
207
|
+
def system; end
|
208
|
+
def write(output, indent = nil, transitive = nil, ie_hack = nil); end
|
209
|
+
include REXML::XMLTokens
|
210
|
+
end
|
211
|
+
class REXML::Declaration < REXML::Child
|
212
|
+
def initialize(src); end
|
213
|
+
def to_s; end
|
214
|
+
def write(output, indent); end
|
215
|
+
end
|
216
|
+
class REXML::ElementDecl < REXML::Declaration
|
217
|
+
def initialize(src); end
|
218
|
+
end
|
219
|
+
class REXML::ExternalEntity < REXML::Child
|
220
|
+
def initialize(src); end
|
221
|
+
def to_s; end
|
222
|
+
def write(output, indent); end
|
223
|
+
end
|
224
|
+
class REXML::NotationDecl < REXML::Child
|
225
|
+
def initialize(name, middle, pub, sys); end
|
226
|
+
def name; end
|
227
|
+
def public; end
|
228
|
+
def public=(arg0); end
|
229
|
+
def system; end
|
230
|
+
def system=(arg0); end
|
231
|
+
def to_s; end
|
232
|
+
def write(output, indent = nil); end
|
233
|
+
end
|
234
|
+
class REXML::Text < REXML::Child
|
235
|
+
def <<(to_append); end
|
236
|
+
def <=>(other); end
|
237
|
+
def clear_cache; end
|
238
|
+
def clone; end
|
239
|
+
def doctype; end
|
240
|
+
def empty?; end
|
241
|
+
def indent_text(string, level = nil, style = nil, indentfirstline = nil); end
|
242
|
+
def initialize(arg, respect_whitespace = nil, parent = nil, raw = nil, entity_filter = nil, illegal = nil); end
|
243
|
+
def inspect; end
|
244
|
+
def node_type; end
|
245
|
+
def parent=(parent); end
|
246
|
+
def raw; end
|
247
|
+
def raw=(arg0); end
|
248
|
+
def self.check(string, pattern, doctype); end
|
249
|
+
def self.expand(ref, doctype, filter); end
|
250
|
+
def self.normalize(input, doctype = nil, entity_filter = nil); end
|
251
|
+
def self.read_with_substitution(input, illegal = nil); end
|
252
|
+
def self.unnormalize(string, doctype = nil, filter = nil, illegal = nil); end
|
253
|
+
def to_s; end
|
254
|
+
def value; end
|
255
|
+
def value=(val); end
|
256
|
+
def wrap(string, width, addnewline = nil); end
|
257
|
+
def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
|
258
|
+
def write_with_substitution(out, input); end
|
259
|
+
def xpath; end
|
260
|
+
include Comparable
|
261
|
+
end
|
262
|
+
class REXML::Attribute
|
263
|
+
def ==(other); end
|
264
|
+
def clone; end
|
265
|
+
def doctype; end
|
266
|
+
def element; end
|
267
|
+
def element=(element); end
|
268
|
+
def hash; end
|
269
|
+
def initialize(first, second = nil, parent = nil); end
|
270
|
+
def inspect; end
|
271
|
+
def namespace(arg = nil); end
|
272
|
+
def node_type; end
|
273
|
+
def normalized=(arg0); end
|
274
|
+
def prefix; end
|
275
|
+
def remove; end
|
276
|
+
def to_s; end
|
277
|
+
def to_string; end
|
278
|
+
def value; end
|
279
|
+
def write(output, indent = nil); end
|
280
|
+
def xpath; end
|
281
|
+
include REXML::Namespace
|
282
|
+
include REXML::Node
|
283
|
+
end
|
284
|
+
class REXML::CData < REXML::Text
|
285
|
+
def clone; end
|
286
|
+
def initialize(first, whitespace = nil, parent = nil); end
|
287
|
+
def to_s; end
|
288
|
+
def value; end
|
289
|
+
def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end
|
290
|
+
end
|
291
|
+
module REXML::Functions
|
292
|
+
end
|
293
|
+
module REXML::Parsers
|
294
|
+
end
|
295
|
+
class REXML::Parsers::XPathParser
|
296
|
+
def AdditiveExpr(path, parsed); end
|
297
|
+
def AndExpr(path, parsed); end
|
298
|
+
def EqualityExpr(path, parsed); end
|
299
|
+
def FilterExpr(path, parsed); end
|
300
|
+
def FunctionCall(rest, parsed); end
|
301
|
+
def LocationPath(path, parsed); end
|
302
|
+
def MultiplicativeExpr(path, parsed); end
|
303
|
+
def NodeTest(path, parsed); end
|
304
|
+
def OrExpr(path, parsed); end
|
305
|
+
def PathExpr(path, parsed); end
|
306
|
+
def Predicate(path, parsed); end
|
307
|
+
def PrimaryExpr(path, parsed); end
|
308
|
+
def RelationalExpr(path, parsed); end
|
309
|
+
def RelativeLocationPath(path, parsed); end
|
310
|
+
def UnaryExpr(path, parsed); end
|
311
|
+
def UnionExpr(path, parsed); end
|
312
|
+
def abbreviate(path); end
|
313
|
+
def expand(path); end
|
314
|
+
def get_group(string); end
|
315
|
+
def namespaces=(namespaces); end
|
316
|
+
def parse(path); end
|
317
|
+
def parse_args(string); end
|
318
|
+
def predicate(path); end
|
319
|
+
def predicate_to_string(path, &block); end
|
320
|
+
include REXML::XMLTokens
|
321
|
+
end
|
322
|
+
class Object < BasicObject
|
323
|
+
def dclone; end
|
324
|
+
end
|
325
|
+
class Symbol
|
326
|
+
def dclone; end
|
327
|
+
end
|
328
|
+
class Integer < Numeric
|
329
|
+
def dclone; end
|
330
|
+
end
|
331
|
+
class Float < Numeric
|
332
|
+
def dclone; end
|
333
|
+
end
|
334
|
+
class Array
|
335
|
+
def dclone; end
|
336
|
+
end
|
337
|
+
class REXML::XPathParser
|
338
|
+
def []=(variable_name, value); end
|
339
|
+
def child(nodeset); end
|
340
|
+
def compare(a, operator, b); end
|
341
|
+
def descendant(nodeset, include_self); end
|
342
|
+
def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end
|
343
|
+
def each_unnode(nodeset); end
|
344
|
+
def enter(tag, *args); end
|
345
|
+
def equality_relational_compare(set1, op, set2); end
|
346
|
+
def evaluate_predicate(expression, nodesets); end
|
347
|
+
def expr(path_stack, nodeset, context = nil); end
|
348
|
+
def filter_nodeset(nodeset); end
|
349
|
+
def first(path_stack, node); end
|
350
|
+
def following(node); end
|
351
|
+
def following_node_of(node); end
|
352
|
+
def get_first(path, nodeset); end
|
353
|
+
def get_namespace(node, prefix); end
|
354
|
+
def initialize(strict: nil); end
|
355
|
+
def leave(tag, *args); end
|
356
|
+
def match(path_stack, nodeset); end
|
357
|
+
def namespaces=(namespaces = nil); end
|
358
|
+
def next_sibling_node(node); end
|
359
|
+
def node_test(path_stack, nodesets, any_type: nil); end
|
360
|
+
def norm(b); end
|
361
|
+
def normalize_compare_values(a, operator, b); end
|
362
|
+
def parse(path, nodeset); end
|
363
|
+
def preceding(node); end
|
364
|
+
def preceding_node_of(node); end
|
365
|
+
def predicate(path, nodeset); end
|
366
|
+
def sort(array_of_nodes, order); end
|
367
|
+
def step(path_stack, any_type: nil, order: nil); end
|
368
|
+
def strict?; end
|
369
|
+
def trace(*args); end
|
370
|
+
def unnode(nodeset); end
|
371
|
+
def value_type(value); end
|
372
|
+
def variables=(vars = nil); end
|
373
|
+
include REXML::XMLTokens
|
374
|
+
end
|
375
|
+
class REXML::XPathNode
|
376
|
+
def context; end
|
377
|
+
def initialize(node, context = nil); end
|
378
|
+
def position; end
|
379
|
+
def raw_node; end
|
380
|
+
end
|
381
|
+
class REXML::XPath
|
382
|
+
def self.each(element, path = nil, namespaces = nil, variables = nil, options = nil, &block); end
|
383
|
+
def self.first(element, path = nil, namespaces = nil, variables = nil, options = nil); end
|
384
|
+
def self.match(element, path = nil, namespaces = nil, variables = nil, options = nil); end
|
385
|
+
include REXML::Functions
|
386
|
+
end
|
387
|
+
class REXML::Element < REXML::Parent
|
388
|
+
def [](name_or_index); end
|
389
|
+
def __to_xpath_helper(node); end
|
390
|
+
def add_attribute(key, value = nil); end
|
391
|
+
def add_attributes(hash); end
|
392
|
+
def add_element(element, attrs = nil); end
|
393
|
+
def add_namespace(prefix, uri = nil); end
|
394
|
+
def add_text(text); end
|
395
|
+
def attribute(name, namespace = nil); end
|
396
|
+
def attributes; end
|
397
|
+
def cdatas; end
|
398
|
+
def clone; end
|
399
|
+
def comments; end
|
400
|
+
def context; end
|
401
|
+
def context=(arg0); end
|
402
|
+
def delete_attribute(key); end
|
403
|
+
def delete_element(element); end
|
404
|
+
def delete_namespace(namespace = nil); end
|
405
|
+
def document; end
|
406
|
+
def each_element(xpath = nil, &block); end
|
407
|
+
def each_element_with_attribute(key, value = nil, max = nil, name = nil, &block); end
|
408
|
+
def each_element_with_text(text = nil, max = nil, name = nil, &block); end
|
409
|
+
def each_with_something(test, max = nil, name = nil); end
|
410
|
+
def elements; end
|
411
|
+
def get_elements(xpath); end
|
412
|
+
def get_text(path = nil); end
|
413
|
+
def has_attributes?; end
|
414
|
+
def has_elements?; end
|
415
|
+
def has_text?; end
|
416
|
+
def ignore_whitespace_nodes; end
|
417
|
+
def initialize(arg = nil, parent = nil, context = nil); end
|
418
|
+
def inspect; end
|
419
|
+
def instructions; end
|
420
|
+
def namespace(prefix = nil); end
|
421
|
+
def namespaces; end
|
422
|
+
def next_element; end
|
423
|
+
def node_type; end
|
424
|
+
def prefixes; end
|
425
|
+
def previous_element; end
|
426
|
+
def raw; end
|
427
|
+
def root; end
|
428
|
+
def root_node; end
|
429
|
+
def text(path = nil); end
|
430
|
+
def text=(text); end
|
431
|
+
def texts; end
|
432
|
+
def whitespace; end
|
433
|
+
def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end
|
434
|
+
def xpath; end
|
435
|
+
include REXML::Namespace
|
436
|
+
end
|
437
|
+
class REXML::Elements
|
438
|
+
def <<(element = nil); end
|
439
|
+
def [](index, name = nil); end
|
440
|
+
def []=(index, element); end
|
441
|
+
def add(element = nil); end
|
442
|
+
def collect(xpath = nil); end
|
443
|
+
def delete(element); end
|
444
|
+
def delete_all(xpath); end
|
445
|
+
def each(xpath = nil); end
|
446
|
+
def empty?; end
|
447
|
+
def index(element); end
|
448
|
+
def initialize(parent); end
|
449
|
+
def inject(xpath = nil, initial = nil); end
|
450
|
+
def literalize(name); end
|
451
|
+
def size; end
|
452
|
+
def to_a(xpath = nil); end
|
453
|
+
include Enumerable
|
454
|
+
end
|
455
|
+
class REXML::Attributes < Hash
|
456
|
+
def <<(attribute); end
|
457
|
+
def [](name); end
|
458
|
+
def []=(name, value); end
|
459
|
+
def add(attribute); end
|
460
|
+
def delete(attribute); end
|
461
|
+
def delete_all(name); end
|
462
|
+
def each; end
|
463
|
+
def each_attribute; end
|
464
|
+
def get_attribute(name); end
|
465
|
+
def get_attribute_ns(namespace, name); end
|
466
|
+
def initialize(element); end
|
467
|
+
def length; end
|
468
|
+
def namespaces; end
|
469
|
+
def prefixes; end
|
470
|
+
def size; end
|
471
|
+
def to_a; end
|
472
|
+
end
|
473
|
+
class REXML::XMLDecl < REXML::Child
|
474
|
+
def ==(other); end
|
475
|
+
def clone; end
|
476
|
+
def content(enc); end
|
477
|
+
def dowrite; end
|
478
|
+
def encoding=(enc); end
|
479
|
+
def initialize(version = nil, encoding = nil, standalone = nil); end
|
480
|
+
def inspect; end
|
481
|
+
def node_type; end
|
482
|
+
def nowrite; end
|
483
|
+
def old_enc=(encoding); end
|
484
|
+
def self.default; end
|
485
|
+
def stand_alone?; end
|
486
|
+
def standalone; end
|
487
|
+
def standalone=(arg0); end
|
488
|
+
def version; end
|
489
|
+
def version=(arg0); end
|
490
|
+
def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
|
491
|
+
def writeencoding; end
|
492
|
+
def writethis; end
|
493
|
+
def xmldecl(version, encoding, standalone); end
|
494
|
+
include REXML::Encoding
|
495
|
+
end
|
496
|
+
class REXML::Comment < REXML::Child
|
497
|
+
def <=>(other); end
|
498
|
+
def ==(other); end
|
499
|
+
def clone; end
|
500
|
+
def initialize(first, second = nil); end
|
501
|
+
def node_type; end
|
502
|
+
def string; end
|
503
|
+
def string=(arg0); end
|
504
|
+
def to_s; end
|
505
|
+
def write(output, indent = nil, transitive = nil, ie_hack = nil); end
|
506
|
+
include Comparable
|
507
|
+
end
|
508
|
+
class REXML::Instruction < REXML::Child
|
509
|
+
def ==(other); end
|
510
|
+
def clone; end
|
511
|
+
def content; end
|
512
|
+
def content=(arg0); end
|
513
|
+
def initialize(target, content = nil); end
|
514
|
+
def inspect; end
|
515
|
+
def node_type; end
|
516
|
+
def target; end
|
517
|
+
def target=(arg0); end
|
518
|
+
def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
|
519
|
+
end
|
520
|
+
class REXML::Output
|
521
|
+
def <<(content); end
|
522
|
+
def encoding; end
|
523
|
+
def initialize(real_IO, encd = nil); end
|
524
|
+
def to_s; end
|
525
|
+
include REXML::Encoding
|
526
|
+
end
|
527
|
+
class REXML::UndefinedNamespaceException < REXML::ParseException
|
528
|
+
def initialize(prefix, source, parser); end
|
529
|
+
end
|
530
|
+
class REXML::Parsers::BaseParser
|
531
|
+
def add_listener(listener); end
|
532
|
+
def empty?; end
|
533
|
+
def entity(reference, entities); end
|
534
|
+
def has_next?; end
|
535
|
+
def initialize(source); end
|
536
|
+
def need_source_encoding_update?(xml_declaration_encoding); end
|
537
|
+
def normalize(input, entities = nil, entity_filter = nil); end
|
538
|
+
def parse_attributes(prefixes, curr_ns); end
|
539
|
+
def peek(depth = nil); end
|
540
|
+
def position; end
|
541
|
+
def process_instruction; end
|
542
|
+
def pull; end
|
543
|
+
def pull_event; end
|
544
|
+
def source; end
|
545
|
+
def stream=(source); end
|
546
|
+
def unnormalize(string, entities = nil, filter = nil); end
|
547
|
+
def unshift(token); end
|
548
|
+
end
|
549
|
+
class REXML::Parsers::StreamParser
|
550
|
+
def add_listener(listener); end
|
551
|
+
def initialize(source, listener); end
|
552
|
+
def parse; end
|
553
|
+
end
|
554
|
+
module REXML::Validation
|
555
|
+
end
|
556
|
+
class REXML::Validation::ValidationException < RuntimeError
|
557
|
+
def initialize(msg); end
|
558
|
+
end
|
559
|
+
class REXML::Parsers::TreeParser
|
560
|
+
def add_listener(listener); end
|
561
|
+
def initialize(source, build_context = nil); end
|
562
|
+
def parse; end
|
563
|
+
end
|
564
|
+
class REXML::Document < REXML::Element
|
565
|
+
def <<(child); end
|
566
|
+
def add(child); end
|
567
|
+
def add_element(arg = nil, arg2 = nil); end
|
568
|
+
def build(source); end
|
569
|
+
def clone; end
|
570
|
+
def doctype; end
|
571
|
+
def document; end
|
572
|
+
def encoding; end
|
573
|
+
def entity_expansion_count; end
|
574
|
+
def expanded_name; end
|
575
|
+
def initialize(source = nil, context = nil); end
|
576
|
+
def name; end
|
577
|
+
def node_type; end
|
578
|
+
def record_entity_expansion; end
|
579
|
+
def root; end
|
580
|
+
def self.entity_expansion_limit; end
|
581
|
+
def self.entity_expansion_limit=(val); end
|
582
|
+
def self.entity_expansion_text_limit; end
|
583
|
+
def self.entity_expansion_text_limit=(val); end
|
584
|
+
def self.parse_stream(source, listener); end
|
585
|
+
def stand_alone?; end
|
586
|
+
def version; end
|
587
|
+
def write(*arguments); end
|
588
|
+
def xml_decl; end
|
589
|
+
end
|