serve_byte_range 1.0.0 → 1.1.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.
@@ -0,0 +1,224 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "bundler"
4
+ Bundler.setup
5
+
6
+ require_relative "../lib/serve_byte_range"
7
+ require "minitest"
8
+ require "minitest/autorun"
9
+ require_relative "support/bytes_assertions"
10
+ require "stringio"
11
+
12
+ class SequenceTest < Minitest::Test
13
+ include BytesAssertions
14
+
15
+ # Stands in for an object in remote storage which supports ranged GETs
16
+ RemoteObject = Struct.new(:bytes) do
17
+ def size
18
+ bytes.bytesize
19
+ end
20
+
21
+ def get_range(range)
22
+ bytes.byteslice(range)
23
+ end
24
+ end
25
+
26
+ def fetch(segment, range_in_segment)
27
+ (segment.is_a?(String) ? segment.byteslice(range_in_segment) : segment.get_range(range_in_segment)).b
28
+ end
29
+
30
+ def build_sequence_and_expected_bytes
31
+ rng = Random.new(Minitest.seed)
32
+ remote = RemoteObject.new(rng.bytes(200))
33
+ inner = ServeByteRange::Sequence.new("«inner — ✂»").add_segment(RemoteObject.new(rng.bytes(7)), size: 7, etag: "inner-v1")
34
+
35
+ seq = ServeByteRange::Sequence.new
36
+ seq.add_segment(remote, size: remote.size, etag: "v1")
37
+ seq << "«redacted — ✂»\n"
38
+ seq << ""
39
+ seq << inner
40
+ seq.add_segment(RemoteObject.new(rng.bytes(3)), size: 3, etag: "tail-v1")
41
+
42
+ expected = remote.bytes + "«redacted — ✂»\n".b + inner.each_in_range(0..(inner.size - 1)).map { |s, r| fetch(s, r) }.join.b
43
+ seq.each_in_range((seq.size - 3)..(seq.size - 1)) { |s, r| expected << fetch(s, r) }
44
+ [seq, expected]
45
+ end
46
+
47
+ def test_size_and_each_in_range_cover_every_byte
48
+ seq, expected = build_sequence_and_expected_bytes
49
+ assert_equal expected.bytesize, seq.size
50
+
51
+ rng = Random.new(Minitest.seed)
52
+ ranges = [0..0, 0..(seq.size - 1), 195..215, 199..200, (seq.size - 1)..(seq.size - 1)]
53
+ 50.times do
54
+ a, b = [rng.rand(seq.size), rng.rand(seq.size)].sort
55
+ ranges << (a..b)
56
+ end
57
+
58
+ ranges.each do |range|
59
+ out = +"".b
60
+ seq.each_in_range(range) { |segment, range_in_segment| out << fetch(segment, range_in_segment) }
61
+ assert_same_bytes expected.byteslice(range), out, "Mismatch for #{range}"
62
+ end
63
+ end
64
+
65
+ def test_each_in_range_yields_leaf_segments_with_ranges_inside_them
66
+ seq = ServeByteRange::Sequence.new("abc", ServeByteRange::Sequence.new("de", "fgh"), "ij")
67
+ assert_equal [["abc", 2..2], ["de", 0..1], ["fgh", 0..0]], seq.each_in_range(2..5).to_a
68
+ assert_equal [["fgh", 2..2], ["ij", 0..1]], seq.each_in_range(7..9).to_a
69
+ assert_equal [], seq.each_in_range(10..12).to_a
70
+ assert_equal [], ServeByteRange::Sequence.new.each_in_range(0..1).to_a
71
+ end
72
+
73
+ def test_add_segment_skips_empty_segments_and_refuses_bad_sizes
74
+ seq = ServeByteRange::Sequence.new
75
+ seq.add_segment(:nothing, size: 0)
76
+ assert_equal 0, seq.size
77
+ assert_raises(ArgumentError) { seq.add_segment(:x, size: -1) }
78
+ assert_raises(ArgumentError) { seq.add_segment(:x, size: "1") }
79
+ end
80
+
81
+ def test_etag_changes_when_a_segment_does
82
+ a = ServeByteRange::Sequence.new("abc", "def")
83
+ b = ServeByteRange::Sequence.new("abc", "deF")
84
+ assert_match(/\A"[0-9a-f]{40}"\z/, a.etag)
85
+ assert_equal a.etag, ServeByteRange::Sequence.new("abc", "def").etag
86
+ refute_equal a.etag, b.etag
87
+ refute_equal ServeByteRange::Sequence.new("ab", "c").etag, ServeByteRange::Sequence.new("a", "bc").etag
88
+
89
+ nested_a = ServeByteRange::Sequence.new("x", a)
90
+ nested_b = ServeByteRange::Sequence.new("x", b)
91
+ refute_equal nested_a.etag, nested_b.etag
92
+ end
93
+
94
+ def test_serve_sequence_serves_whole_body_single_and_multiple_ranges
95
+ seq, expected = build_sequence_and_expected_bytes
96
+ serve = ->(env) { ServeByteRange.serve_sequence(env, seq, multipart_boundary: "azuleju") { |segment, r, io| io.write(fetch(segment, r)) } }
97
+ read = ->(body) { StringIO.new.binmode.tap { |out| body.each { |chunk| out.write(chunk) } }.string }
98
+
99
+ status, headers, body = serve.call({})
100
+ assert_equal 200, status
101
+ assert_equal seq.etag, headers["ETag"]
102
+ assert_equal expected.bytesize.to_s, headers["Content-Length"]
103
+ assert_same_bytes expected, read.call(body)
104
+
105
+ status, headers, body = serve.call("HTTP_RANGE" => "bytes=195-215")
106
+ assert_equal 206, status
107
+ assert_equal "bytes 195-215/#{seq.size}", headers["Content-Range"]
108
+ assert_same_bytes expected.byteslice(195..215), read.call(body)
109
+
110
+ status, headers, body = serve.call("HTTP_RANGE" => "bytes=0-3,201-204", "HTTP_IF_RANGE" => seq.etag)
111
+ assert_equal 206, status
112
+ output = read.call(body)
113
+ assert_equal headers["Content-Length"].to_i, output.bytesize
114
+ assert_includes output, expected.byteslice(0..3)
115
+ assert_includes output, expected.byteslice(201..204)
116
+
117
+ status, _, _ = serve.call("HTTP_IF_NONE_MATCH" => seq.etag)
118
+ assert_equal 304, status
119
+ end
120
+
121
+ def test_serve_sequence_complains_about_the_segment_which_wrote_the_wrong_amount
122
+ seq = ServeByteRange::Sequence.new("abc", "def")
123
+ _, _, body = ServeByteRange.serve_sequence({}, seq) { |segment, r, io| io.write(segment[r]) unless segment == "def" }
124
+ error = assert_raises(RuntimeError) { body.each {} }
125
+ assert_includes error.message, "segment (String, bytes 0-2 of it) requires 3 bytes"
126
+
127
+ _, _, body = ServeByteRange.serve_sequence({}, seq) { |segment, r, io| io.write(segment + "!") }
128
+ error = assert_raises(RuntimeError) { body.each {} }
129
+ assert_includes error.message, "the limit for this segment (String, bytes 0-2 of it) is 3"
130
+ end
131
+
132
+ def test_etag_is_weak_unless_every_segment_has_an_etag
133
+ assert ServeByteRange::Sequence.new("abc").strong_etag?
134
+ assert_match(/\A"[0-9a-f]{40}"\z/, ServeByteRange::Sequence.new("abc").etag)
135
+
136
+ seq = ServeByteRange::Sequence.new("abc").add_segment(:remote, size: 10, etag: "v1")
137
+ assert seq.strong_etag?
138
+
139
+ seq.add_segment(:other_remote, size: 10)
140
+ refute seq.strong_etag?
141
+ assert_match(/\AW\/"[0-9a-f]{40}"\z/, seq.etag)
142
+
143
+ refute ServeByteRange::Sequence.new("x", seq).strong_etag? # weakness carries over from nested sequences
144
+ end
145
+
146
+ def test_serves_range_regardless_of_if_range_when_etag_is_weak
147
+ seq = ServeByteRange::Sequence.new.add_segment("abcdef", size: 6)
148
+ env = {"HTTP_RANGE" => "bytes=0-1", "HTTP_IF_RANGE" => seq.etag}
149
+ status, headers, _ = ServeByteRange.serve_sequence(env, seq) { |segment, r, io| io.write(segment[r]) }
150
+ assert_equal 200, status # a weak validator can not be used for If-Range
151
+ assert_equal seq.etag, headers["ETag"]
152
+
153
+ status, _, _ = ServeByteRange.serve_sequence({"HTTP_IF_NONE_MATCH" => seq.etag}, seq) { |segment, r, io| io.write(segment[r]) }
154
+ assert_equal 304, status
155
+ end
156
+
157
+ def test_etag_includes_segment_sizes
158
+ a = ServeByteRange::Sequence.new.add_segment(:obj, size: 10, etag: "v1")
159
+ b = ServeByteRange::Sequence.new.add_segment(:obj, size: 20, etag: "v1")
160
+ refute_equal a.etag, b.etag
161
+ end
162
+
163
+ def test_etag_changes_when_segments_are_added_after_it_was_computed
164
+ seq = ServeByteRange::Sequence.new("abc")
165
+ etag_before = seq.etag
166
+ seq << "def"
167
+ refute_equal etag_before, seq.etag
168
+ assert_same seq.etag, seq.etag
169
+ end
170
+
171
+ def test_append_only_takes_objects_it_can_size_in_bytes
172
+ seq = ServeByteRange::Sequence.new
173
+ seq << StringIO.new("abcdef")
174
+ seq << Struct.new(:bytesize).new(4)
175
+ assert_equal 10, seq.size
176
+
177
+ [["aaa", "bbb"], {k: "v"}, 42, :sym].each do |unsizeable|
178
+ assert_raises(ArgumentError) { seq << unsizeable }
179
+ end
180
+ assert_equal 10, seq.size
181
+ end
182
+
183
+ def test_each_in_range_with_exclusive_empty_and_open_ranges
184
+ seq = ServeByteRange::Sequence.new("abc", "def")
185
+ assert_equal [["abc", 0..2]], seq.each_in_range(0...3).to_a
186
+ assert_equal [["abc", 2..2], ["def", 0..0]], seq.each_in_range(2...4).to_a
187
+ assert_equal [], seq.each_in_range(3...3).to_a
188
+ assert_raises(ArgumentError) { seq.each_in_range(5..3).to_a }
189
+ assert_raises(ArgumentError) { seq.each_in_range(Range.new(1, nil)).to_a }
190
+ assert_raises(ArgumentError) { seq.each_in_range(Range.new(nil, 1)).to_a }
191
+ end
192
+
193
+ def test_segments_can_not_change_after_being_added
194
+ str = +"hello"
195
+ seq = ServeByteRange::Sequence.new(str)
196
+ str << " world"
197
+ assert_equal 5, seq.size
198
+ assert_equal [["hello", 0..4]], seq.each_in_range(0..4).to_a
199
+
200
+ inner = ServeByteRange::Sequence.new("ab")
201
+ outer = ServeByteRange::Sequence.new(inner, "cd")
202
+ assert inner.frozen?
203
+ assert_raises(FrozenError) { inner << "XY" }
204
+ assert_equal 4, outer.size
205
+ assert_equal 2, inner.size
206
+ end
207
+
208
+ def test_frozen_sequence_keeps_its_etag
209
+ seq = ServeByteRange::Sequence.new("abc").freeze
210
+ assert_match(/\A"[0-9a-f]{40}"\z/, seq.etag)
211
+ assert_raises(FrozenError) { seq.add_segment(:x, size: 1, etag: "x") }
212
+ end
213
+
214
+ def test_segment_etags_are_compared_without_quotes
215
+ quoted = ServeByteRange::Sequence.new.add_segment(:obj, size: 3, etag: '"abc"')
216
+ bare = ServeByteRange::Sequence.new.add_segment(:obj, size: 3, etag: "abc")
217
+ assert_equal bare.etag, quoted.etag
218
+ assert quoted.strong_etag?
219
+
220
+ weak = ServeByteRange::Sequence.new.add_segment(:obj, size: 3, etag: 'W/"abc"')
221
+ refute weak.strong_etag?
222
+ assert_equal "W/#{bare.etag}", weak.etag
223
+ end
224
+ end
@@ -0,0 +1,47 @@
1
+ # frozen_string_literal: true
2
+
3
+ # Compares two strings byte for byte, and describes where they differ - showing the offset and
4
+ # what the bytes there should have been - instead of a diff of a binary blob
5
+ class ByteComparator
6
+ CONTEXT_BYTES = 8
7
+ BLOCK_SIZE = 4096
8
+
9
+ def initialize(expected, actual)
10
+ @expected = expected.b
11
+ @actual = actual.b
12
+ end
13
+
14
+ def same?
15
+ @expected == @actual
16
+ end
17
+
18
+ # @return [Integer,nil] the offset of the first differing byte, or nil if the strings are the same
19
+ def first_difference_offset
20
+ return if same?
21
+ common = [@expected.bytesize, @actual.bytesize].min
22
+ # Skip over equal blocks first, comparing byte by byte over 100KB+ strings is slow-ish
23
+ offset = 0
24
+ offset += BLOCK_SIZE while offset + BLOCK_SIZE <= common && @expected.byteslice(offset, BLOCK_SIZE) == @actual.byteslice(offset, BLOCK_SIZE)
25
+ offset += 1 while offset < common && @expected.getbyte(offset) == @actual.getbyte(offset)
26
+ offset
27
+ end
28
+
29
+ # @return [String,nil] the description of the difference, or nil if the strings are the same
30
+ def describe_difference
31
+ offset = first_difference_offset
32
+ return unless offset
33
+ [
34
+ (@expected.bytesize == @actual.bytesize) ? "Bytes differ" : "Bytes differ (expected #{@expected.bytesize} bytes, got #{@actual.bytesize})",
35
+ "diff at offset #{offset},",
36
+ "should have been #{format_bytes(@expected.byteslice(offset, CONTEXT_BYTES))}",
37
+ "but was #{format_bytes(@actual.byteslice(offset, CONTEXT_BYTES))}"
38
+ ].join("\n")
39
+ end
40
+
41
+ private
42
+
43
+ def format_bytes(bytes)
44
+ return "[empty]" if bytes.nil? || bytes.empty?
45
+ "[" + bytes.unpack("C*").map { |b| "0x%02X" % b }.join(" ") + "]"
46
+ end
47
+ end
@@ -0,0 +1,10 @@
1
+ # frozen_string_literal: true
2
+
3
+ require_relative "byte_comparator"
4
+
5
+ module BytesAssertions
6
+ def assert_same_bytes(expected, actual, message = nil)
7
+ comparator = ByteComparator.new(expected, actual)
8
+ assert(comparator.same?, -> { [message, comparator.describe_difference].compact.join("\n") })
9
+ end
10
+ end
metadata CHANGED
@@ -1,15 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: serve_byte_range
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.0
4
+ version: 1.1.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Julik Tarkhanov
8
8
  - Sebastian van Hesteren
9
- autorequire:
10
9
  bindir: exe
11
10
  cert_chain: []
12
- date: 2025-03-27 00:00:00.000000000 Z
11
+ date: 1980-01-02 00:00:00.000000000 Z
13
12
  dependencies:
14
13
  - !ruby/object:Gem::Dependency
15
14
  name: rack
@@ -17,22 +16,22 @@ dependencies:
17
16
  requirements:
18
17
  - - ">="
19
18
  - !ruby/object:Gem::Version
20
- version: '1.0'
19
+ version: '2.0'
21
20
  type: :runtime
22
21
  prerelease: false
23
22
  version_requirements: !ruby/object:Gem::Requirement
24
23
  requirements:
25
24
  - - ">="
26
25
  - !ruby/object:Gem::Version
27
- version: '1.0'
26
+ version: '2.0'
28
27
  - !ruby/object:Gem::Dependency
29
- name: minitest
28
+ name: base64
30
29
  requirement: !ruby/object:Gem::Requirement
31
30
  requirements:
32
31
  - - ">="
33
32
  - !ruby/object:Gem::Version
34
33
  version: '0'
35
- type: :development
34
+ type: :runtime
36
35
  prerelease: false
37
36
  version_requirements: !ruby/object:Gem::Requirement
38
37
  requirements:
@@ -40,7 +39,7 @@ dependencies:
40
39
  - !ruby/object:Gem::Version
41
40
  version: '0'
42
41
  - !ruby/object:Gem::Dependency
43
- name: rake
42
+ name: minitest
44
43
  requirement: !ruby/object:Gem::Requirement
45
44
  requirements:
46
45
  - - ">="
@@ -54,35 +53,7 @@ dependencies:
54
53
  - !ruby/object:Gem::Version
55
54
  version: '0'
56
55
  - !ruby/object:Gem::Dependency
57
- name: standard
58
- requirement: !ruby/object:Gem::Requirement
59
- requirements:
60
- - - '='
61
- - !ruby/object:Gem::Version
62
- version: 1.28.5
63
- type: :development
64
- prerelease: false
65
- version_requirements: !ruby/object:Gem::Requirement
66
- requirements:
67
- - - '='
68
- - !ruby/object:Gem::Version
69
- version: 1.28.5
70
- - !ruby/object:Gem::Dependency
71
- name: yard
72
- requirement: !ruby/object:Gem::Requirement
73
- requirements:
74
- - - "~>"
75
- - !ruby/object:Gem::Version
76
- version: '0.9'
77
- type: :development
78
- prerelease: false
79
- version_requirements: !ruby/object:Gem::Requirement
80
- requirements:
81
- - - "~>"
82
- - !ruby/object:Gem::Version
83
- version: '0.9'
84
- - !ruby/object:Gem::Dependency
85
- name: sord
56
+ name: rake
86
57
  requirement: !ruby/object:Gem::Requirement
87
58
  requirements:
88
59
  - - ">="
@@ -96,25 +67,26 @@ dependencies:
96
67
  - !ruby/object:Gem::Version
97
68
  version: '0'
98
69
  - !ruby/object:Gem::Dependency
99
- name: redcarpet
70
+ name: standard
100
71
  requirement: !ruby/object:Gem::Requirement
101
72
  requirements:
102
- - - ">="
73
+ - - '='
103
74
  - !ruby/object:Gem::Version
104
- version: '0'
75
+ version: 1.28.5
105
76
  type: :development
106
77
  prerelease: false
107
78
  version_requirements: !ruby/object:Gem::Requirement
108
79
  requirements:
109
- - - ">="
80
+ - - '='
110
81
  - !ruby/object:Gem::Version
111
- version: '0'
82
+ version: 1.28.5
112
83
  description: Serve byte range HTTP responses lazily
113
84
  email:
114
85
  - me@julik.nl
115
86
  executables: []
116
87
  extensions: []
117
- extra_rdoc_files: []
88
+ extra_rdoc_files:
89
+ - README.md
118
90
  files:
119
91
  - ".github/workflows/ci.yml"
120
92
  - ".gitignore"
@@ -122,18 +94,35 @@ files:
122
94
  - Gemfile
123
95
  - README.md
124
96
  - Rakefile
97
+ - Steepfile
98
+ - gemfiles/rack_2.gemfile
99
+ - gemfiles/rack_3.gemfile
100
+ - gemfiles/typecheck.gemfile
125
101
  - lib/serve_byte_range.rb
102
+ - lib/serve_byte_range/sequence.rb
126
103
  - lib/serve_byte_range/version.rb
127
- - rbi/serve_byte_range.rbi
128
104
  - serve_byte_range.gemspec
105
+ - sig/serve_byte_range.rbs
106
+ - sig/serve_byte_range/sequence.rbs
107
+ - sig/serve_byte_range/version.rbs
108
+ - sig_shims/rack.rbs
109
+ - test/byte_comparator_test.rb
129
110
  - test/range_server_test.rb
111
+ - test/sequence_test.rb
112
+ - test/support/byte_comparator.rb
113
+ - test/support/bytes_assertions.rb
130
114
  homepage: https://github.com/julik/serve_byte_range
131
115
  licenses:
132
116
  - MIT
133
117
  metadata:
118
+ homepage_uri: https://github.com/julik/serve_byte_range
119
+ source_code_uri: https://github.com/julik/serve_byte_range
134
120
  allowed_push_host: https://rubygems.org
135
- post_install_message:
136
- rdoc_options: []
121
+ rdoc_options:
122
+ - "--markup"
123
+ - markdown
124
+ - "--main"
125
+ - README.md
137
126
  require_paths:
138
127
  - lib
139
128
  required_ruby_version: !ruby/object:Gem::Requirement
@@ -147,8 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
147
136
  - !ruby/object:Gem::Version
148
137
  version: '0'
149
138
  requirements: []
150
- rubygems_version: 3.1.6
151
- signing_key:
139
+ rubygems_version: 3.6.9
152
140
  specification_version: 4
153
141
  summary: Serve byte range HTTP responses lazily
154
142
  test_files: []
@@ -1,208 +0,0 @@
1
- # typed: strong
2
- module ServeByteRange
3
- VERSION = T.let("1.0.0", T.untyped)
4
-
5
- # sord omit - no YARD return type given, using untyped
6
- # Strictly - the boundary is supposed to not appear in any of the parts of the multipart response, so _first_
7
- # you need to scan the response, pick a byte sequence that does not occur in it, and then use that. In practice,
8
- # nobody does that - and a well-behaved HTTP client should honor the Content-Range header when extracting
9
- # the byte range from the response. See https://stackoverflow.com/questions/37413715
10
- sig { returns(T.untyped) }
11
- def self.generate_boundary; end
12
-
13
- # The RFC specifically gives an example of non-canonical, but still
14
- # valid request for overlapping ranges:
15
- # > Several legal but not canonical specifications of the second 500
16
- # > bytes (byte offsets 500-999, inclusive):
17
- # > bytes=500-600,601-999
18
- # > bytes=500-700,601-999
19
- # In such cases, ranges need to be collapsed together. First, to avoid serving
20
- # a tiny byte range over and over - causing excessive requests to upstream,
21
- # second - to optimize for doing less requests in total.
22
- #
23
- # _@param_ `ranges` — an array of inclusive, limited ranges of integers
24
- #
25
- # _@return_ — ranges squashed together honoring their overlaps
26
- sig { params(ranges: T::Array[T::Range[T.untyped]]).returns(T::Array[T.untyped]) }
27
- def self.coalesce_ranges(ranges); end
28
-
29
- # _@param_ `env` — the Rack env
30
- #
31
- # _@param_ `resource_size` — the size of the complete resource in bytes
32
- #
33
- # _@param_ `etag` — the current ETag of the resource, or nil if none
34
- #
35
- # _@param_ `resource_content_type` — the MIME type string of the resource
36
- #
37
- # _@param_ `multipart_boundary` — The string to use as multipart boundary. Default is an automatically generated pseudo-random string.
38
- #
39
- # _@return_ — the Rack response triplet of `[status, header_hash, enumerable_body]`
40
- #
41
- # ```ruby
42
- # status, headers, body = serve_ranges(env, resource_size: file.size) do |range, io|
43
- # file.seek(range.begin)
44
- # IO.copy_stream(file, io, range.size)
45
- # end
46
- # [status, headers, body]
47
- # ```
48
- sig do
49
- params(
50
- env: T::Hash[T.untyped, T.untyped],
51
- resource_size: Integer,
52
- etag: T.nilable(String),
53
- resource_content_type: String,
54
- multipart_boundary: String,
55
- range_serving_block: T.untyped
56
- ).returns(T::Array[T.untyped])
57
- end
58
- def self.serve_ranges(env, resource_size:, etag: nil, resource_content_type: "binary/octet-stream", multipart_boundary: generate_boundary, &range_serving_block); end
59
-
60
- class BlockWritableWithLimit
61
- # sord omit - no YARD type given for "limit", using untyped
62
- sig { params(limit: T.untyped, block_that_accepts_writes: T.untyped).void }
63
- def initialize(limit, &block_that_accepts_writes); end
64
-
65
- # sord omit - no YARD type given for "string", using untyped
66
- # sord omit - no YARD return type given, using untyped
67
- sig { params(string: T.untyped).returns(T.untyped) }
68
- def write(string); end
69
-
70
- # sord omit - no YARD return type given, using untyped
71
- sig { returns(T.untyped) }
72
- def verify!; end
73
- end
74
-
75
- class ByteRangeBody
76
- # sord omit - no YARD type given for "http_range:", using untyped
77
- # sord omit - no YARD type given for "resource_size:", using untyped
78
- # sord omit - no YARD type given for "resource_content_type:", using untyped
79
- sig do
80
- params(
81
- http_range: T.untyped,
82
- resource_size: T.untyped,
83
- resource_content_type: T.untyped,
84
- serving_block: T.untyped
85
- ).void
86
- end
87
- def initialize(http_range:, resource_size:, resource_content_type: "binary/octet-stream", &serving_block); end
88
-
89
- # sord omit - no YARD return type given, using untyped
90
- sig { returns(T.untyped) }
91
- def status; end
92
-
93
- # sord omit - no YARD return type given, using untyped
94
- sig { params(blk: T.untyped).returns(T.untyped) }
95
- def each(&blk); end
96
-
97
- # sord omit - no YARD return type given, using untyped
98
- sig { returns(T.untyped) }
99
- def content_length; end
100
-
101
- # sord omit - no YARD return type given, using untyped
102
- sig { returns(T.untyped) }
103
- def content_type; end
104
-
105
- # sord omit - no YARD return type given, using untyped
106
- sig { returns(T.untyped) }
107
- def headers; end
108
- end
109
-
110
- class EmptyBody
111
- # sord omit - no YARD return type given, using untyped
112
- sig { returns(T.untyped) }
113
- def status; end
114
-
115
- # sord omit - no YARD return type given, using untyped
116
- sig { returns(T.untyped) }
117
- def content_length; end
118
-
119
- # sord omit - no YARD return type given, using untyped
120
- sig { params(blk: T.untyped).returns(T.untyped) }
121
- def each(&blk); end
122
-
123
- # sord omit - no YARD return type given, using untyped
124
- sig { returns(T.untyped) }
125
- def headers; end
126
- end
127
-
128
- class NotModifiedBody < ServeByteRange::EmptyBody
129
- # sord omit - no YARD return type given, using untyped
130
- sig { returns(T.untyped) }
131
- def status; end
132
- end
133
-
134
- class WholeBody < ServeByteRange::ByteRangeBody
135
- # sord omit - no YARD type given for "resource_size:", using untyped
136
- # sord omit - no YARD type given for "**more", using untyped
137
- sig { params(resource_size: T.untyped, more: T.untyped, serving_block: T.untyped).void }
138
- def initialize(resource_size:, **more, &serving_block); end
139
-
140
- # sord omit - no YARD return type given, using untyped
141
- sig { returns(T.untyped) }
142
- def status; end
143
-
144
- # sord omit - no YARD return type given, using untyped
145
- sig { returns(T.untyped) }
146
- def headers; end
147
- end
148
-
149
- class Unsatisfiable < ServeByteRange::EmptyBody
150
- # sord omit - no YARD type given for "resource_size:", using untyped
151
- sig { params(resource_size: T.untyped).void }
152
- def initialize(resource_size:); end
153
-
154
- # sord omit - no YARD return type given, using untyped
155
- sig { returns(T.untyped) }
156
- def status; end
157
-
158
- # sord omit - no YARD return type given, using untyped
159
- sig { returns(T.untyped) }
160
- def headers; end
161
- end
162
-
163
- # See https://www.ietf.org/archive/id/draft-ietf-httpbis-p5-range-09.html
164
- class MultipartByteRangesBody < ServeByteRange::ByteRangeBody
165
- # sord omit - no YARD type given for "boundary:", using untyped
166
- # sord omit - no YARD type given for "**params_for_single_range", using untyped
167
- # _@param_ `http_ranges`
168
- sig do
169
- params(
170
- http_ranges: T::Array[T::Range[T.untyped]],
171
- boundary: T.untyped,
172
- params_for_single_range: T.untyped,
173
- serving_block: T.untyped
174
- ).void
175
- end
176
- def initialize(http_ranges:, boundary:, **params_for_single_range, &serving_block); end
177
-
178
- # sord omit - no YARD return type given, using untyped
179
- sig { params(blk: T.untyped).returns(T.untyped) }
180
- def each(&blk); end
181
-
182
- # sord omit - no YARD return type given, using untyped
183
- sig { returns(T.untyped) }
184
- def content_length; end
185
-
186
- # sord omit - no YARD return type given, using untyped
187
- sig { returns(T.untyped) }
188
- def content_type; end
189
-
190
- # sord omit - no YARD return type given, using untyped
191
- sig { returns(T.untyped) }
192
- def headers; end
193
-
194
- # sord omit - no YARD return type given, using untyped
195
- sig { returns(T.untyped) }
196
- def compute_envelope_size; end
197
-
198
- # sord omit - no YARD return type given, using untyped
199
- sig { returns(T.untyped) }
200
- def trailer; end
201
-
202
- # sord omit - no YARD type given for "http_range", using untyped
203
- # sord omit - no YARD type given for "part_index", using untyped
204
- # sord omit - no YARD return type given, using untyped
205
- sig { params(http_range: T.untyped, part_index: T.untyped).returns(T.untyped) }
206
- def part_header(http_range, part_index); end
207
- end
208
- end