titleist 0.1.1 → 1.0.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/.github/workflows/tests.yml +19 -0
- data/.gitignore +1 -2
- data/.rubocop.yml +26 -1
- data/.ruby-version +1 -1
- data/Gemfile +13 -2
- data/README.md +95 -25
- data/Rakefile +17 -6
- data/docs/index.md +7 -0
- data/lib/generators/titleist/titleist_generator.rb +3 -0
- data/lib/titleist.rb +14 -9
- data/lib/titleist/controller.rb +36 -0
- data/lib/titleist/engine.rb +10 -4
- data/lib/titleist/helper.rb +23 -0
- data/lib/titleist/title.rb +52 -89
- data/lib/titleist/version.rb +5 -1
- data/rbi/sord.rbi +117 -0
- data/sorbet/config +2 -0
- data/sorbet/rbi/gems/actioncable.rbi +318 -0
- data/sorbet/rbi/gems/actionmailbox.rbi +56 -0
- data/sorbet/rbi/gems/actionmailer.rbi +446 -0
- data/sorbet/rbi/gems/actionpack.rbi +3411 -0
- data/sorbet/rbi/gems/actiontext.rbi +79 -0
- data/sorbet/rbi/gems/actionview.rbi +1185 -0
- data/sorbet/rbi/gems/activejob.rbi +362 -0
- data/sorbet/rbi/gems/activemodel.rbi +749 -0
- data/sorbet/rbi/gems/activerecord.rbi +5713 -0
- data/sorbet/rbi/gems/activestorage.rbi +221 -0
- data/sorbet/rbi/gems/activesupport.rbi +2437 -0
- data/sorbet/rbi/gems/addressable.rbi +146 -0
- data/sorbet/rbi/gems/ast.rbi +47 -0
- data/sorbet/rbi/gems/capybara.rbi +1787 -0
- data/sorbet/rbi/gems/childprocess.rbi +106 -0
- data/sorbet/rbi/gems/codeclimate-test-reporter.rbi +125 -0
- data/sorbet/rbi/gems/concurrent-ruby.rbi +1587 -0
- data/sorbet/rbi/gems/crass.rbi +92 -0
- data/sorbet/rbi/gems/docile.rbi +29 -0
- data/sorbet/rbi/gems/erubi.rbi +26 -0
- data/sorbet/rbi/gems/globalid.rbi +98 -0
- data/sorbet/rbi/gems/i18n.rbi +191 -0
- data/sorbet/rbi/gems/jaro_winkler.rbi +14 -0
- data/sorbet/rbi/gems/loofah.rbi +129 -0
- data/sorbet/rbi/gems/mail.rbi +1582 -0
- data/sorbet/rbi/gems/marcel.rbi +12 -0
- data/sorbet/rbi/gems/method_source.rbi +63 -0
- data/sorbet/rbi/gems/mini_mime.rbi +51 -0
- data/sorbet/rbi/gems/minitest.rbi +419 -0
- data/sorbet/rbi/gems/mocha.rbi +794 -0
- data/sorbet/rbi/gems/nio4r.rbi +67 -0
- data/sorbet/rbi/gems/nokogiri.rbi +1010 -0
- data/sorbet/rbi/gems/parallel.rbi +81 -0
- data/sorbet/rbi/gems/parser.rbi +920 -0
- data/sorbet/rbi/gems/public_suffix.rbi +103 -0
- data/sorbet/rbi/gems/puma.rbi +586 -0
- data/sorbet/rbi/gems/rack-test.rbi +161 -0
- data/sorbet/rbi/gems/rack.rbi +634 -0
- data/sorbet/rbi/gems/rails-dom-testing.rbi +67 -0
- data/sorbet/rbi/gems/rails-html-sanitizer.rbi +91 -0
- data/sorbet/rbi/gems/railties.rbi +834 -0
- data/sorbet/rbi/gems/rainbow.rbi +117 -0
- data/sorbet/rbi/gems/rake.rbi +269 -0
- data/sorbet/rbi/gems/regexp_parser.rbi +912 -0
- data/sorbet/rbi/gems/rubocop.rbi +7232 -0
- data/sorbet/rbi/gems/ruby-progressbar.rbi +304 -0
- data/sorbet/rbi/gems/rubyzip.rbi +546 -0
- data/sorbet/rbi/gems/selenium-webdriver.rbi +1450 -0
- data/sorbet/rbi/gems/simplecov-html.rbi +30 -0
- data/sorbet/rbi/gems/simplecov.rbi +189 -0
- data/sorbet/rbi/gems/site_ruby.rbi +265 -0
- data/sorbet/rbi/gems/sprockets-rails.rbi +105 -0
- data/sorbet/rbi/gems/sprockets.rbi +753 -0
- data/sorbet/rbi/gems/sqlite3.rbi +353 -0
- data/sorbet/rbi/gems/thor.rbi +579 -0
- data/sorbet/rbi/gems/thread_safe.rbi +81 -0
- data/sorbet/rbi/gems/tzinfo.rbi +405 -0
- data/sorbet/rbi/gems/unicode-display_width.rbi +16 -0
- data/sorbet/rbi/gems/webdrivers.rbi +155 -0
- data/sorbet/rbi/gems/xpath.rbi +158 -0
- data/sorbet/rbi/gems/yard.rbi +1159 -0
- data/sorbet/rbi/hidden-definitions/errors.txt +14957 -0
- data/sorbet/rbi/hidden-definitions/hidden.rbi +24898 -0
- data/sorbet/rbi/sorbet-typed/lib/actionmailer/all/actionmailer.rbi +13 -0
- data/sorbet/rbi/sorbet-typed/lib/actionpack/all/actionpack.rbi +938 -0
- data/sorbet/rbi/sorbet-typed/lib/actionview/all/actionview.rbi +314 -0
- data/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi +425 -0
- data/sorbet/rbi/sorbet-typed/lib/activerecord/>=5.2/activerecord.rbi +17 -0
- data/sorbet/rbi/sorbet-typed/lib/activerecord/all/activerecord.rbi +1425 -0
- data/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0/activerecord.rbi +475 -0
- data/sorbet/rbi/sorbet-typed/lib/activestorage/>=6.0.0/activestorage.rbi +19 -0
- data/sorbet/rbi/sorbet-typed/lib/activestorage/all/activestorage.rbi +173 -0
- data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi +23 -0
- data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +858 -0
- data/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi +8684 -0
- data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +108 -0
- data/sorbet/rbi/sorbet-typed/lib/railties/all/railties.rbi +25 -0
- data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +254 -0
- data/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi +4222 -0
- data/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi +111 -0
- data/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi +543 -0
- data/sorbet/rbi/todo.rbi +20 -0
- data/titleist.gemspec +3 -14
- metadata +96 -155
- data/.travis.yml +0 -45
- data/app/controllers/.keep +0 -0
- data/app/helpers/.keep +0 -0
- data/app/helpers/titleist_helper.rb +0 -47
- data/app/mailers/.keep +0 -0
- data/app/models/.keep +0 -0
- data/app/views/.keep +0 -0
@@ -0,0 +1,304 @@
|
|
1
|
+
# This file is autogenerated. Do not edit it by hand. Regenerate it with:
|
2
|
+
# srb rbi gems
|
3
|
+
|
4
|
+
# typed: strong
|
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/ruby-progressbar/all/ruby-progressbar.rbi
|
9
|
+
#
|
10
|
+
# ruby-progressbar-1.10.1
|
11
|
+
class ProgressBar
|
12
|
+
def self.create(*args); end
|
13
|
+
end
|
14
|
+
class ProgressBar::Output
|
15
|
+
def bar; end
|
16
|
+
def bar=(arg0); end
|
17
|
+
def clear_string; end
|
18
|
+
def initialize(options = nil); end
|
19
|
+
def length; end
|
20
|
+
def length_calculator; end
|
21
|
+
def length_calculator=(arg0); end
|
22
|
+
def log(string); end
|
23
|
+
def print_and_flush; end
|
24
|
+
def refresh(options = nil); end
|
25
|
+
def self.detect(options = nil); end
|
26
|
+
def stream; end
|
27
|
+
def stream=(arg0); end
|
28
|
+
def throttle; end
|
29
|
+
def throttle=(arg0); end
|
30
|
+
def with_refresh; end
|
31
|
+
end
|
32
|
+
module ProgressBar::Outputs
|
33
|
+
end
|
34
|
+
class ProgressBar::Outputs::Tty < ProgressBar::Output
|
35
|
+
def bar_update_string; end
|
36
|
+
def clear; end
|
37
|
+
def default_format; end
|
38
|
+
def eol; end
|
39
|
+
def refresh_with_format_change; end
|
40
|
+
def resolve_format(other_format); end
|
41
|
+
end
|
42
|
+
class ProgressBar::Outputs::NonTty < ProgressBar::Output
|
43
|
+
def bar_update_string; end
|
44
|
+
def clear; end
|
45
|
+
def default_format; end
|
46
|
+
def eol; end
|
47
|
+
def last_update_length; end
|
48
|
+
def last_update_length=(arg0); end
|
49
|
+
def refresh_with_format_change(*arg0); end
|
50
|
+
def resolve_format(*arg0); end
|
51
|
+
end
|
52
|
+
class ProgressBar::Time
|
53
|
+
def initialize(time = nil); end
|
54
|
+
def now; end
|
55
|
+
def time; end
|
56
|
+
def time=(arg0); end
|
57
|
+
def unmocked_time_method; end
|
58
|
+
end
|
59
|
+
class ProgressBar::Timer
|
60
|
+
def divide_seconds(seconds); end
|
61
|
+
def elapsed_seconds; end
|
62
|
+
def elapsed_whole_seconds; end
|
63
|
+
def initialize(options = nil); end
|
64
|
+
def pause; end
|
65
|
+
def reset; end
|
66
|
+
def reset?; end
|
67
|
+
def restart; end
|
68
|
+
def resume; end
|
69
|
+
def start; end
|
70
|
+
def started?; end
|
71
|
+
def started_at; end
|
72
|
+
def started_at=(arg0); end
|
73
|
+
def stop; end
|
74
|
+
def stopped?; end
|
75
|
+
def stopped_at; end
|
76
|
+
def stopped_at=(arg0); end
|
77
|
+
def time; end
|
78
|
+
def time=(arg0); end
|
79
|
+
end
|
80
|
+
class ProgressBar::InvalidProgressError < RuntimeError
|
81
|
+
end
|
82
|
+
class ProgressBar::Progress
|
83
|
+
def absolute; end
|
84
|
+
def decrement; end
|
85
|
+
def finish; end
|
86
|
+
def finished?; end
|
87
|
+
def increment; end
|
88
|
+
def initialize(options = nil); end
|
89
|
+
def none?; end
|
90
|
+
def percentage_completed; end
|
91
|
+
def percentage_completed_with_precision; end
|
92
|
+
def progress; end
|
93
|
+
def progress=(new_progress); end
|
94
|
+
def reset; end
|
95
|
+
def running_average; end
|
96
|
+
def running_average=(arg0); end
|
97
|
+
def smoothing; end
|
98
|
+
def smoothing=(arg0); end
|
99
|
+
def start(options = nil); end
|
100
|
+
def starting_position; end
|
101
|
+
def starting_position=(arg0); end
|
102
|
+
def total; end
|
103
|
+
def total=(new_total); end
|
104
|
+
def total_with_unknown_indicator; end
|
105
|
+
def unknown?; end
|
106
|
+
end
|
107
|
+
class ProgressBar::Throttle
|
108
|
+
def choke(options = nil); end
|
109
|
+
def initialize(options = nil); end
|
110
|
+
def rate; end
|
111
|
+
def rate=(arg0); end
|
112
|
+
def started_at; end
|
113
|
+
def started_at=(arg0); end
|
114
|
+
def stopped_at; end
|
115
|
+
def stopped_at=(arg0); end
|
116
|
+
def timer; end
|
117
|
+
def timer=(arg0); end
|
118
|
+
end
|
119
|
+
module ProgressBar::Calculators
|
120
|
+
end
|
121
|
+
class ProgressBar::Calculators::Length
|
122
|
+
def calculate_length; end
|
123
|
+
def current_length; end
|
124
|
+
def current_length=(arg0); end
|
125
|
+
def dynamic_width; end
|
126
|
+
def dynamic_width_stty; end
|
127
|
+
def dynamic_width_tput; end
|
128
|
+
def dynamic_width_via_io_object; end
|
129
|
+
def dynamic_width_via_output_stream_object; end
|
130
|
+
def dynamic_width_via_system_calls; end
|
131
|
+
def initialize(options = nil); end
|
132
|
+
def length; end
|
133
|
+
def length_changed?; end
|
134
|
+
def length_override; end
|
135
|
+
def length_override=(other); end
|
136
|
+
def output; end
|
137
|
+
def output=(arg0); end
|
138
|
+
def reset_length; end
|
139
|
+
def terminal_width; end
|
140
|
+
def unix?; end
|
141
|
+
end
|
142
|
+
class ProgressBar::Calculators::RunningAverage
|
143
|
+
def self.calculate(current_average, new_value_to_average, smoothing_factor); end
|
144
|
+
end
|
145
|
+
module ProgressBar::Components
|
146
|
+
end
|
147
|
+
class ProgressBar::Components::Bar
|
148
|
+
def bar(length); end
|
149
|
+
def bar_with_percentage(length); end
|
150
|
+
def complete_bar(length); end
|
151
|
+
def complete_bar_with_percentage(length); end
|
152
|
+
def completed_length; end
|
153
|
+
def incomplete_space(length); end
|
154
|
+
def incomplete_string; end
|
155
|
+
def initialize(options = nil); end
|
156
|
+
def integrated_percentage_complete_string; end
|
157
|
+
def length; end
|
158
|
+
def length=(arg0); end
|
159
|
+
def progress; end
|
160
|
+
def progress=(arg0); end
|
161
|
+
def progress_mark; end
|
162
|
+
def progress_mark=(arg0); end
|
163
|
+
def remainder_mark; end
|
164
|
+
def remainder_mark=(arg0); end
|
165
|
+
def standard_complete_string; end
|
166
|
+
def to_s(options = nil); end
|
167
|
+
def unknown_progress_frame; end
|
168
|
+
def unknown_string; end
|
169
|
+
def upa_steps; end
|
170
|
+
def upa_steps=(arg0); end
|
171
|
+
end
|
172
|
+
class ProgressBar::Components::Percentage
|
173
|
+
def initialize(options = nil); end
|
174
|
+
def justified_percentage; end
|
175
|
+
def justified_percentage_with_precision; end
|
176
|
+
def percentage; end
|
177
|
+
def percentage_with_precision; end
|
178
|
+
def progress; end
|
179
|
+
def progress=(arg0); end
|
180
|
+
end
|
181
|
+
class ProgressBar::Components::Rate
|
182
|
+
def base_rate; end
|
183
|
+
def elapsed_seconds; end
|
184
|
+
def initialize(options = nil); end
|
185
|
+
def progress; end
|
186
|
+
def progress=(arg0); end
|
187
|
+
def rate_of_change(format_string = nil); end
|
188
|
+
def rate_of_change_with_precision; end
|
189
|
+
def rate_scale; end
|
190
|
+
def rate_scale=(arg0); end
|
191
|
+
def scaled_rate; end
|
192
|
+
def started_at; end
|
193
|
+
def started_at=(arg0); end
|
194
|
+
def stopped_at; end
|
195
|
+
def stopped_at=(arg0); end
|
196
|
+
def timer; end
|
197
|
+
def timer=(arg0); end
|
198
|
+
end
|
199
|
+
class ProgressBar::Components::Time
|
200
|
+
def elapsed; end
|
201
|
+
def elapsed_with_label; end
|
202
|
+
def estimated; end
|
203
|
+
def estimated_seconds_remaining; end
|
204
|
+
def estimated_with_elapsed_fallback; end
|
205
|
+
def estimated_with_friendly_oob; end
|
206
|
+
def estimated_with_label; end
|
207
|
+
def estimated_with_no_oob; end
|
208
|
+
def estimated_with_unknown_oob; end
|
209
|
+
def initialize(options = nil); end
|
210
|
+
def out_of_bounds_time; end
|
211
|
+
def out_of_bounds_time_format; end
|
212
|
+
def out_of_bounds_time_format=(format); end
|
213
|
+
def progress; end
|
214
|
+
def progress=(arg0); end
|
215
|
+
def timer; end
|
216
|
+
def timer=(arg0); end
|
217
|
+
end
|
218
|
+
class ProgressBar::Components::Title
|
219
|
+
def initialize(options = nil); end
|
220
|
+
def title; end
|
221
|
+
def title=(arg0); end
|
222
|
+
end
|
223
|
+
module ProgressBar::Format
|
224
|
+
end
|
225
|
+
class ProgressBar::Format::Molecule
|
226
|
+
def bar_molecule?; end
|
227
|
+
def full_key; end
|
228
|
+
def initialize(letter); end
|
229
|
+
def key; end
|
230
|
+
def key=(arg0); end
|
231
|
+
def lookup_value(environment, length = nil); end
|
232
|
+
def method_name; end
|
233
|
+
def method_name=(arg0); end
|
234
|
+
def non_bar_molecule?; end
|
235
|
+
end
|
236
|
+
class ProgressBar::Format::Formatter
|
237
|
+
def self.process(format_string, max_length, bar); end
|
238
|
+
end
|
239
|
+
class ProgressBar::Format::String < String
|
240
|
+
def bar_molecule_placeholder_length; end
|
241
|
+
def bar_molecules; end
|
242
|
+
def displayable_length; end
|
243
|
+
def molecules; end
|
244
|
+
def non_bar_molecules; end
|
245
|
+
end
|
246
|
+
class ProgressBar::Base
|
247
|
+
def autofinish; end
|
248
|
+
def autofinish=(arg0); end
|
249
|
+
def autostart; end
|
250
|
+
def autostart=(arg0); end
|
251
|
+
def bar; end
|
252
|
+
def bar=(arg0); end
|
253
|
+
def clear(*args, &block); end
|
254
|
+
def decrement; end
|
255
|
+
def finish; end
|
256
|
+
def finished; end
|
257
|
+
def finished=(arg0); end
|
258
|
+
def finished?; end
|
259
|
+
def format(other); end
|
260
|
+
def format=(other); end
|
261
|
+
def increment; end
|
262
|
+
def initialize(options = nil); end
|
263
|
+
def inspect; end
|
264
|
+
def log(*args, &block); end
|
265
|
+
def output; end
|
266
|
+
def output=(arg0); end
|
267
|
+
def pause; end
|
268
|
+
def paused?; end
|
269
|
+
def percentage; end
|
270
|
+
def percentage=(arg0); end
|
271
|
+
def progress(*args, &block); end
|
272
|
+
def progress=(new_progress); end
|
273
|
+
def progress_mark=(mark); end
|
274
|
+
def progressable; end
|
275
|
+
def progressable=(arg0); end
|
276
|
+
def rate; end
|
277
|
+
def rate=(arg0); end
|
278
|
+
def refresh(*args, &block); end
|
279
|
+
def remainder_mark=(mark); end
|
280
|
+
def reset; end
|
281
|
+
def resume; end
|
282
|
+
def start(options = nil); end
|
283
|
+
def started?; end
|
284
|
+
def stop; end
|
285
|
+
def stopped?; end
|
286
|
+
def time; end
|
287
|
+
def time=(arg0); end
|
288
|
+
def timer; end
|
289
|
+
def timer=(arg0); end
|
290
|
+
def title; end
|
291
|
+
def title=(title); end
|
292
|
+
def title_comp; end
|
293
|
+
def title_comp=(arg0); end
|
294
|
+
def to_h; end
|
295
|
+
def to_s(new_format = nil); end
|
296
|
+
def total(*args, &block); end
|
297
|
+
def total=(new_total); end
|
298
|
+
def update_progress(*args); end
|
299
|
+
extend Forwardable
|
300
|
+
end
|
301
|
+
module ProgressBar::Refinements
|
302
|
+
end
|
303
|
+
module ProgressBar::Refinements::Enumerator
|
304
|
+
end
|
@@ -0,0 +1,546 @@
|
|
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/rubyzip/all/rubyzip.rbi
|
9
|
+
#
|
10
|
+
# rubyzip-2.2.0
|
11
|
+
module Zip
|
12
|
+
def case_insensitive_match; end
|
13
|
+
def case_insensitive_match=(arg0); end
|
14
|
+
def continue_on_exists_proc; end
|
15
|
+
def continue_on_exists_proc=(arg0); end
|
16
|
+
def default_compression; end
|
17
|
+
def default_compression=(arg0); end
|
18
|
+
def force_entry_names_encoding; end
|
19
|
+
def force_entry_names_encoding=(arg0); end
|
20
|
+
def on_exists_proc; end
|
21
|
+
def on_exists_proc=(arg0); end
|
22
|
+
def reset!; end
|
23
|
+
def setup; end
|
24
|
+
def sort_entries; end
|
25
|
+
def sort_entries=(arg0); end
|
26
|
+
def unicode_names; end
|
27
|
+
def unicode_names=(arg0); end
|
28
|
+
def validate_entry_sizes; end
|
29
|
+
def validate_entry_sizes=(arg0); end
|
30
|
+
def warn_invalid_date; end
|
31
|
+
def warn_invalid_date=(arg0); end
|
32
|
+
def write_zip64_support; end
|
33
|
+
def write_zip64_support=(arg0); end
|
34
|
+
extend Zip
|
35
|
+
end
|
36
|
+
class Zip::DOSTime < Time
|
37
|
+
def dos_equals(other); end
|
38
|
+
def self.from_time(time); end
|
39
|
+
def self.parse_binary_dos_format(binaryDosDate, binaryDosTime); end
|
40
|
+
def to_binary_dos_date; end
|
41
|
+
def to_binary_dos_time; end
|
42
|
+
end
|
43
|
+
module Zip::IOExtras
|
44
|
+
def self.copy_stream(ostream, istream); end
|
45
|
+
def self.copy_stream_n(ostream, istream, nbytes); end
|
46
|
+
end
|
47
|
+
module Zip::IOExtras::AbstractInputStream
|
48
|
+
def each(a_sep_string = nil); end
|
49
|
+
def each_line(a_sep_string = nil); end
|
50
|
+
def eof; end
|
51
|
+
def eof?; end
|
52
|
+
def flush; end
|
53
|
+
def gets(a_sep_string = nil, number_of_bytes = nil); end
|
54
|
+
def initialize; end
|
55
|
+
def lineno; end
|
56
|
+
def lineno=(arg0); end
|
57
|
+
def pos; end
|
58
|
+
def read(number_of_bytes = nil, buf = nil); end
|
59
|
+
def readline(a_sep_string = nil); end
|
60
|
+
def readlines(a_sep_string = nil); end
|
61
|
+
def ungetc(byte); end
|
62
|
+
include Enumerable
|
63
|
+
include Zip::IOExtras::FakeIO
|
64
|
+
end
|
65
|
+
module Zip::IOExtras::AbstractOutputStream
|
66
|
+
def print(*params); end
|
67
|
+
def printf(a_format_string, *params); end
|
68
|
+
def putc(an_object); end
|
69
|
+
def puts(*params); end
|
70
|
+
def write(data); end
|
71
|
+
include Zip::IOExtras::FakeIO
|
72
|
+
end
|
73
|
+
module Zip::IOExtras::FakeIO
|
74
|
+
def kind_of?(object); end
|
75
|
+
end
|
76
|
+
class Zip::Entry
|
77
|
+
def <=>(other); end
|
78
|
+
def ==(other); end
|
79
|
+
def calculate_local_header_size; end
|
80
|
+
def cdir_header_size; end
|
81
|
+
def check_c_dir_entry_comment_size; end
|
82
|
+
def check_c_dir_entry_signature; end
|
83
|
+
def check_c_dir_entry_static_header_length(buf); end
|
84
|
+
def check_name(name); end
|
85
|
+
def clean_up; end
|
86
|
+
def comment; end
|
87
|
+
def comment=(arg0); end
|
88
|
+
def comment_size; end
|
89
|
+
def compressed_size; end
|
90
|
+
def compressed_size=(arg0); end
|
91
|
+
def compression_method; end
|
92
|
+
def compression_method=(arg0); end
|
93
|
+
def crc; end
|
94
|
+
def crc=(arg0); end
|
95
|
+
def create_directory(dest_path); end
|
96
|
+
def create_file(dest_path, _continue_on_exists_proc = nil); end
|
97
|
+
def create_symlink(dest_path); end
|
98
|
+
def data_descriptor_size; end
|
99
|
+
def directory?; end
|
100
|
+
def dirty; end
|
101
|
+
def dirty=(arg0); end
|
102
|
+
def encrypted?; end
|
103
|
+
def external_file_attributes; end
|
104
|
+
def external_file_attributes=(arg0); end
|
105
|
+
def extra; end
|
106
|
+
def extra=(arg0); end
|
107
|
+
def extra_size; end
|
108
|
+
def extract(dest_path = nil, &block); end
|
109
|
+
def file?; end
|
110
|
+
def file_stat(path); end
|
111
|
+
def file_type_is?(type); end
|
112
|
+
def filepath; end
|
113
|
+
def follow_symlinks; end
|
114
|
+
def follow_symlinks=(arg0); end
|
115
|
+
def fstype; end
|
116
|
+
def fstype=(arg0); end
|
117
|
+
def ftype; end
|
118
|
+
def gather_fileinfo_from_srcpath(src_path); end
|
119
|
+
def get_extra_attributes_from_path(path); end
|
120
|
+
def get_input_stream(&block); end
|
121
|
+
def get_raw_input_stream(&block); end
|
122
|
+
def gp_flags; end
|
123
|
+
def gp_flags=(arg0); end
|
124
|
+
def header_signature; end
|
125
|
+
def header_signature=(arg0); end
|
126
|
+
def incomplete?; end
|
127
|
+
def initialize(*args); end
|
128
|
+
def internal_file_attributes; end
|
129
|
+
def internal_file_attributes=(arg0); end
|
130
|
+
def local_entry_offset; end
|
131
|
+
def local_header_offset; end
|
132
|
+
def local_header_offset=(arg0); end
|
133
|
+
def mtime; end
|
134
|
+
def name; end
|
135
|
+
def name=(arg0); end
|
136
|
+
def name_is_directory?; end
|
137
|
+
def name_safe?; end
|
138
|
+
def name_size; end
|
139
|
+
def next_header_offset; end
|
140
|
+
def pack_c_dir_entry; end
|
141
|
+
def pack_local_entry; end
|
142
|
+
def parent_as_string; end
|
143
|
+
def parse_zip64_extra(for_local_header); end
|
144
|
+
def prep_zip64_extra(for_local_header); end
|
145
|
+
def read_c_dir_entry(io); end
|
146
|
+
def read_c_dir_extra_field(io); end
|
147
|
+
def read_local_entry(io); end
|
148
|
+
def restore_ownership; end
|
149
|
+
def restore_ownership=(arg0); end
|
150
|
+
def restore_permissions; end
|
151
|
+
def restore_permissions=(arg0); end
|
152
|
+
def restore_times; end
|
153
|
+
def restore_times=(arg0); end
|
154
|
+
def self.read_c_dir_entry(io); end
|
155
|
+
def self.read_local_entry(io); end
|
156
|
+
def self.read_zip_64_long(io); end
|
157
|
+
def self.read_zip_long(io); end
|
158
|
+
def self.read_zip_short(io); end
|
159
|
+
def set_default_vars_values; end
|
160
|
+
def set_extra_attributes_on_path(dest_path); end
|
161
|
+
def set_ftype_from_c_dir_entry; end
|
162
|
+
def set_time(binary_dos_date, binary_dos_time); end
|
163
|
+
def set_unix_attributes_on_path(dest_path); end
|
164
|
+
def size; end
|
165
|
+
def size=(arg0); end
|
166
|
+
def symlink?; end
|
167
|
+
def time; end
|
168
|
+
def time=(value); end
|
169
|
+
def to_s; end
|
170
|
+
def unix_gid; end
|
171
|
+
def unix_gid=(arg0); end
|
172
|
+
def unix_perms; end
|
173
|
+
def unix_perms=(arg0); end
|
174
|
+
def unix_uid; end
|
175
|
+
def unix_uid=(arg0); end
|
176
|
+
def unpack_c_dir_entry(buf); end
|
177
|
+
def unpack_local_entry(buf); end
|
178
|
+
def verify_local_header_size!; end
|
179
|
+
def write_c_dir_entry(io); end
|
180
|
+
def write_local_entry(io, rewrite = nil); end
|
181
|
+
def write_to_zip_output_stream(zip_output_stream); end
|
182
|
+
def zipfile; end
|
183
|
+
def zipfile=(arg0); end
|
184
|
+
end
|
185
|
+
class Zip::ExtraField::Generic
|
186
|
+
def ==(other); end
|
187
|
+
def initial_parse(binstr); end
|
188
|
+
def self.name; end
|
189
|
+
def self.register_map; end
|
190
|
+
def to_c_dir_bin; end
|
191
|
+
def to_local_bin; end
|
192
|
+
end
|
193
|
+
class Zip::ExtraField::UniversalTime < Zip::ExtraField::Generic
|
194
|
+
def ==(other); end
|
195
|
+
def atime; end
|
196
|
+
def atime=(time); end
|
197
|
+
def ctime; end
|
198
|
+
def ctime=(time); end
|
199
|
+
def flag; end
|
200
|
+
def initialize(binstr = nil); end
|
201
|
+
def merge(binstr); end
|
202
|
+
def mtime; end
|
203
|
+
def mtime=(time); end
|
204
|
+
def pack_for_c_dir; end
|
205
|
+
def pack_for_local; end
|
206
|
+
end
|
207
|
+
class Zip::ExtraField::OldUnix < Zip::ExtraField::Generic
|
208
|
+
def ==(other); end
|
209
|
+
def atime; end
|
210
|
+
def atime=(arg0); end
|
211
|
+
def gid; end
|
212
|
+
def gid=(arg0); end
|
213
|
+
def initialize(binstr = nil); end
|
214
|
+
def merge(binstr); end
|
215
|
+
def mtime; end
|
216
|
+
def mtime=(arg0); end
|
217
|
+
def pack_for_c_dir; end
|
218
|
+
def pack_for_local; end
|
219
|
+
def uid; end
|
220
|
+
def uid=(arg0); end
|
221
|
+
end
|
222
|
+
class Zip::ExtraField::IUnix < Zip::ExtraField::Generic
|
223
|
+
def ==(other); end
|
224
|
+
def gid; end
|
225
|
+
def gid=(arg0); end
|
226
|
+
def initialize(binstr = nil); end
|
227
|
+
def merge(binstr); end
|
228
|
+
def pack_for_c_dir; end
|
229
|
+
def pack_for_local; end
|
230
|
+
def uid; end
|
231
|
+
def uid=(arg0); end
|
232
|
+
end
|
233
|
+
class Zip::ExtraField::Zip64 < Zip::ExtraField::Generic
|
234
|
+
def ==(other); end
|
235
|
+
def compressed_size; end
|
236
|
+
def compressed_size=(arg0); end
|
237
|
+
def disk_start_number; end
|
238
|
+
def disk_start_number=(arg0); end
|
239
|
+
def extract(size, format); end
|
240
|
+
def initialize(binstr = nil); end
|
241
|
+
def merge(binstr); end
|
242
|
+
def original_size; end
|
243
|
+
def original_size=(arg0); end
|
244
|
+
def pack_for_c_dir; end
|
245
|
+
def pack_for_local; end
|
246
|
+
def parse(original_size, compressed_size, relative_header_offset = nil, disk_start_number = nil); end
|
247
|
+
def relative_header_offset; end
|
248
|
+
def relative_header_offset=(arg0); end
|
249
|
+
end
|
250
|
+
class Zip::ExtraField::Zip64Placeholder < Zip::ExtraField::Generic
|
251
|
+
def initialize(_binstr = nil); end
|
252
|
+
def pack_for_local; end
|
253
|
+
end
|
254
|
+
class Zip::ExtraField::NTFS < Zip::ExtraField::Generic
|
255
|
+
def ==(other); end
|
256
|
+
def atime; end
|
257
|
+
def atime=(arg0); end
|
258
|
+
def ctime; end
|
259
|
+
def ctime=(arg0); end
|
260
|
+
def from_ntfs_time(ntfs_time); end
|
261
|
+
def initialize(binstr = nil); end
|
262
|
+
def merge(binstr); end
|
263
|
+
def mtime; end
|
264
|
+
def mtime=(arg0); end
|
265
|
+
def pack_for_c_dir; end
|
266
|
+
def pack_for_local; end
|
267
|
+
def parse_tags(content); end
|
268
|
+
def to_ntfs_time(time); end
|
269
|
+
end
|
270
|
+
class Zip::ExtraField < Hash
|
271
|
+
def c_dir_size; end
|
272
|
+
def create(name); end
|
273
|
+
def create_unknown_item; end
|
274
|
+
def extra_field_type_exist(binstr, id, len, i); end
|
275
|
+
def extra_field_type_unknown(binstr, len, i); end
|
276
|
+
def initialize(binstr = nil); end
|
277
|
+
def length; end
|
278
|
+
def local_size; end
|
279
|
+
def merge(binstr); end
|
280
|
+
def ordered_values; end
|
281
|
+
def size; end
|
282
|
+
def to_c_dir_bin; end
|
283
|
+
def to_local_bin; end
|
284
|
+
def to_s; end
|
285
|
+
end
|
286
|
+
class Zip::EntrySet
|
287
|
+
def <<(entry); end
|
288
|
+
def ==(other); end
|
289
|
+
def delete(entry); end
|
290
|
+
def dup; end
|
291
|
+
def each; end
|
292
|
+
def entries; end
|
293
|
+
def entry_order; end
|
294
|
+
def entry_order=(arg0); end
|
295
|
+
def entry_set; end
|
296
|
+
def entry_set=(arg0); end
|
297
|
+
def find_entry(entry); end
|
298
|
+
def glob(pattern, flags = nil); end
|
299
|
+
def include?(entry); end
|
300
|
+
def initialize(an_enumerable = nil); end
|
301
|
+
def length; end
|
302
|
+
def parent(entry); end
|
303
|
+
def push(entry); end
|
304
|
+
def size; end
|
305
|
+
def sorted_entries; end
|
306
|
+
def to_key(entry); end
|
307
|
+
include Enumerable
|
308
|
+
end
|
309
|
+
class Zip::CentralDirectory
|
310
|
+
def ==(other); end
|
311
|
+
def comment; end
|
312
|
+
def each(&proc); end
|
313
|
+
def entries; end
|
314
|
+
def get_64_e_o_c_d(buf); end
|
315
|
+
def get_e_o_c_d(buf); end
|
316
|
+
def initialize(entries = nil, comment = nil); end
|
317
|
+
def read_64_e_o_c_d(buf); end
|
318
|
+
def read_central_directory_entries(io); end
|
319
|
+
def read_e_o_c_d(buf); end
|
320
|
+
def read_from_stream(io); end
|
321
|
+
def self.read_from_stream(io); end
|
322
|
+
def size; end
|
323
|
+
def start_buf(io); end
|
324
|
+
def write_64_e_o_c_d(io, offset, cdir_size); end
|
325
|
+
def write_64_eocd_locator(io, zip64_eocd_offset); end
|
326
|
+
def write_e_o_c_d(io, offset, cdir_size); end
|
327
|
+
def write_to_stream(io); end
|
328
|
+
def zip64_file?(buf); end
|
329
|
+
include Enumerable
|
330
|
+
end
|
331
|
+
class Zip::File < Zip::CentralDirectory
|
332
|
+
def add(entry, src_path, &continue_on_exists_proc); end
|
333
|
+
def add_stored(entry, src_path, &continue_on_exists_proc); end
|
334
|
+
def check_entry_exists(entryName, continue_on_exists_proc, procedureName); end
|
335
|
+
def check_file(path); end
|
336
|
+
def close; end
|
337
|
+
def comment; end
|
338
|
+
def comment=(arg0); end
|
339
|
+
def commit; end
|
340
|
+
def commit_required?; end
|
341
|
+
def directory?(newEntry, srcPath); end
|
342
|
+
def extract(entry, dest_path, &block); end
|
343
|
+
def find_entry(entry_name); end
|
344
|
+
def get_entry(entry); end
|
345
|
+
def get_input_stream(entry, &aProc); end
|
346
|
+
def get_output_stream(entry, permission_int = nil, comment = nil, extra = nil, compressed_size = nil, crc = nil, compression_method = nil, size = nil, time = nil, &aProc); end
|
347
|
+
def glob(*args, &block); end
|
348
|
+
def initialize(path_or_io, create = nil, buffer = nil, options = nil); end
|
349
|
+
def mkdir(entryName, permissionInt = nil); end
|
350
|
+
def name; end
|
351
|
+
def on_success_replace; end
|
352
|
+
def read(entry); end
|
353
|
+
def remove(entry); end
|
354
|
+
def rename(entry, new_name, &continue_on_exists_proc); end
|
355
|
+
def replace(entry, srcPath); end
|
356
|
+
def restore_ownership; end
|
357
|
+
def restore_ownership=(arg0); end
|
358
|
+
def restore_permissions; end
|
359
|
+
def restore_permissions=(arg0); end
|
360
|
+
def restore_times; end
|
361
|
+
def restore_times=(arg0); end
|
362
|
+
def self.add_buffer; end
|
363
|
+
def self.foreach(aZipFileName, &block); end
|
364
|
+
def self.get_partial_zip_file_name(zip_file_name, partial_zip_file_name); end
|
365
|
+
def self.get_segment_count_for_split(zip_file_size, segment_size); end
|
366
|
+
def self.get_segment_size_for_split(segment_size); end
|
367
|
+
def self.open(file_name, create = nil, options = nil); end
|
368
|
+
def self.open_buffer(io, options = nil); end
|
369
|
+
def self.put_split_signature(szip_file, segment_size); end
|
370
|
+
def self.save_splited_part(zip_file, partial_zip_file_name, zip_file_size, szip_file_index, segment_size, segment_count); end
|
371
|
+
def self.split(zip_file_name, segment_size = nil, delete_zip_file = nil, partial_zip_file_name = nil); end
|
372
|
+
def to_s; end
|
373
|
+
def write_buffer(io = nil); end
|
374
|
+
end
|
375
|
+
class Zip::InputStream
|
376
|
+
def close; end
|
377
|
+
def get_decompressor; end
|
378
|
+
def get_decrypted_io; end
|
379
|
+
def get_io(io_or_file, offset = nil); end
|
380
|
+
def get_next_entry; end
|
381
|
+
def initialize(context, offset = nil, decrypter = nil); end
|
382
|
+
def input_finished?; end
|
383
|
+
def open_entry; end
|
384
|
+
def produce_input; end
|
385
|
+
def rewind; end
|
386
|
+
def self.open(filename_or_io, offset = nil, decrypter = nil); end
|
387
|
+
def self.open_buffer(filename_or_io, offset = nil); end
|
388
|
+
def sysread(length = nil, outbuf = nil); end
|
389
|
+
include Zip::IOExtras::AbstractInputStream
|
390
|
+
end
|
391
|
+
class Zip::OutputStream
|
392
|
+
def <<(data); end
|
393
|
+
def close; end
|
394
|
+
def close_buffer; end
|
395
|
+
def comment; end
|
396
|
+
def comment=(arg0); end
|
397
|
+
def copy_raw_entry(entry); end
|
398
|
+
def finalize_current_entry; end
|
399
|
+
def finish; end
|
400
|
+
def get_compressor(entry, level); end
|
401
|
+
def init_next_entry(entry, level = nil); end
|
402
|
+
def initialize(file_name, stream = nil, encrypter = nil); end
|
403
|
+
def put_next_entry(entry_name, comment = nil, extra = nil, compression_method = nil, level = nil); end
|
404
|
+
def self.open(file_name, encrypter = nil); end
|
405
|
+
def self.write_buffer(io = nil, encrypter = nil); end
|
406
|
+
def update_local_headers; end
|
407
|
+
def write_central_directory; end
|
408
|
+
include Zip::IOExtras::AbstractOutputStream
|
409
|
+
end
|
410
|
+
class Zip::Decompressor
|
411
|
+
def decompressed_size; end
|
412
|
+
def initialize(input_stream, decompressed_size = nil); end
|
413
|
+
def input_stream; end
|
414
|
+
def self.decompressor_classes; end
|
415
|
+
def self.find_by_compression_method(compression_method); end
|
416
|
+
def self.register(compression_method, decompressor_class); end
|
417
|
+
end
|
418
|
+
class Zip::Compressor
|
419
|
+
def finish; end
|
420
|
+
end
|
421
|
+
module Zip::NullDecompressor
|
422
|
+
def eof; end
|
423
|
+
def eof?; end
|
424
|
+
def read(_length = nil, _outbuf = nil); end
|
425
|
+
def self.eof; end
|
426
|
+
def self.read(_length = nil, _outbuf = nil); end
|
427
|
+
end
|
428
|
+
class Zip::NullCompressor < Zip::Compressor
|
429
|
+
def <<(_data); end
|
430
|
+
def compressed_size; end
|
431
|
+
def self.allocate; end
|
432
|
+
def self.instance; end
|
433
|
+
def self.new(*arg0); end
|
434
|
+
def size; end
|
435
|
+
extend Singleton::SingletonClassMethods
|
436
|
+
include Singleton
|
437
|
+
end
|
438
|
+
module Zip::NullInputStream
|
439
|
+
include Zip::IOExtras::AbstractInputStream
|
440
|
+
include Zip::NullDecompressor
|
441
|
+
end
|
442
|
+
class Zip::PassThruCompressor < Zip::Compressor
|
443
|
+
def <<(data); end
|
444
|
+
def crc; end
|
445
|
+
def initialize(outputStream); end
|
446
|
+
def size; end
|
447
|
+
end
|
448
|
+
class Zip::PassThruDecompressor < Zip::Decompressor
|
449
|
+
def eof; end
|
450
|
+
def eof?; end
|
451
|
+
def initialize(*args); end
|
452
|
+
def read(length = nil, outbuf = nil); end
|
453
|
+
end
|
454
|
+
class Zip::DecryptedIo
|
455
|
+
def buffer; end
|
456
|
+
def eof; end
|
457
|
+
def initialize(io, decrypter); end
|
458
|
+
def input_finished?; end
|
459
|
+
def produce_input; end
|
460
|
+
def read(length = nil, outbuf = nil); end
|
461
|
+
end
|
462
|
+
class Zip::Encrypter
|
463
|
+
end
|
464
|
+
class Zip::Decrypter
|
465
|
+
end
|
466
|
+
module Zip::NullEncryption
|
467
|
+
def gp_flags; end
|
468
|
+
def header_bytesize; end
|
469
|
+
end
|
470
|
+
class Zip::NullEncrypter < Zip::Encrypter
|
471
|
+
def data_descriptor(_crc32, _compressed_size, _uncomprssed_size); end
|
472
|
+
def encrypt(data); end
|
473
|
+
def header(_mtime); end
|
474
|
+
def reset!; end
|
475
|
+
include Zip::NullEncryption
|
476
|
+
end
|
477
|
+
class Zip::NullDecrypter < Zip::Decrypter
|
478
|
+
def decrypt(data); end
|
479
|
+
def reset!(_header); end
|
480
|
+
include Zip::NullEncryption
|
481
|
+
end
|
482
|
+
module Zip::TraditionalEncryption
|
483
|
+
def decrypt_byte; end
|
484
|
+
def gp_flags; end
|
485
|
+
def header_bytesize; end
|
486
|
+
def initialize(password); end
|
487
|
+
def reset_keys!; end
|
488
|
+
def update_keys(n); end
|
489
|
+
end
|
490
|
+
class Zip::TraditionalEncrypter < Zip::Encrypter
|
491
|
+
def data_descriptor(crc32, compressed_size, uncomprssed_size); end
|
492
|
+
def encode(n); end
|
493
|
+
def encrypt(data); end
|
494
|
+
def header(mtime); end
|
495
|
+
def reset!; end
|
496
|
+
include Zip::TraditionalEncryption
|
497
|
+
end
|
498
|
+
class Zip::TraditionalDecrypter < Zip::Decrypter
|
499
|
+
def decode(n); end
|
500
|
+
def decrypt(data); end
|
501
|
+
def reset!(header); end
|
502
|
+
include Zip::TraditionalEncryption
|
503
|
+
end
|
504
|
+
class Zip::Inflater < Zip::Decompressor
|
505
|
+
def eof; end
|
506
|
+
def eof?; end
|
507
|
+
def initialize(*args); end
|
508
|
+
def input_finished?; end
|
509
|
+
def produce_input; end
|
510
|
+
def read(length = nil, outbuf = nil); end
|
511
|
+
end
|
512
|
+
class Zip::Deflater < Zip::Compressor
|
513
|
+
def <<(data); end
|
514
|
+
def crc; end
|
515
|
+
def finish; end
|
516
|
+
def initialize(output_stream, level = nil, encrypter = nil); end
|
517
|
+
def size; end
|
518
|
+
end
|
519
|
+
class Zip::StreamableStream < Anonymous_Delegator_10
|
520
|
+
def clean_up; end
|
521
|
+
def get_input_stream; end
|
522
|
+
def get_output_stream; end
|
523
|
+
def initialize(entry); end
|
524
|
+
def write_to_zip_output_stream(aZipOutputStream); end
|
525
|
+
end
|
526
|
+
class Zip::StreamableDirectory < Zip::Entry
|
527
|
+
def initialize(zipfile, entry, srcPath = nil, permissionInt = nil); end
|
528
|
+
end
|
529
|
+
class Zip::Error < StandardError
|
530
|
+
end
|
531
|
+
class Zip::EntryExistsError < Zip::Error
|
532
|
+
end
|
533
|
+
class Zip::DestinationFileExistsError < Zip::Error
|
534
|
+
end
|
535
|
+
class Zip::CompressionMethodError < Zip::Error
|
536
|
+
end
|
537
|
+
class Zip::EntryNameError < Zip::Error
|
538
|
+
end
|
539
|
+
class Zip::EntrySizeError < Zip::Error
|
540
|
+
end
|
541
|
+
class Zip::InternalError < Zip::Error
|
542
|
+
end
|
543
|
+
class Zip::GPFBit3Error < Zip::Error
|
544
|
+
end
|
545
|
+
class Zip::DecompressionError < Zip::Error
|
546
|
+
end
|