m3u8 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbf61a694bdc2daf585ad9f405be821f09ba53289ef075e4342f267e674eb21b
-  data.tar.gz: d599367f1344f9b1ad91c20590bc0b4c57a6d0369c71e3a34fd69325ae0c7f44
+  metadata.gz: 3a4ef59c0103a519f686f38d7eb24e99286f698bfbee43d7e8ad48827dfd00e5
+  data.tar.gz: b776355294c670836ecc6598ad169d71eedc40e017a686c28042828bf724e805
 SHA512:
-  metadata.gz: 9574b7ac1a95fe6b2fabe0bd28576b2b21713a1bed68e2a18d4ea9f644920a91a08e4696df69a19d7b8392eda87fc8fa14b090338ffebe31524cd5f3f4235539
-  data.tar.gz: 2f34f676d931929f6671b4e3b3ba3efc0e49e73fc2dc54f6c3a64f499e8d2c1a20b974fcad3febcb0f17252d6aef1f9fb612b1c1ec9ad1911e41aa28314f8ea1
+  metadata.gz: e2f761adbf62244f9f175fc28f7f00f0d77d78acb5af19906f70fff656777e97bbbe787454ce47accd0e72f4e702baeda20dde763a72ac87174cb9ccd24dca15
+  data.tar.gz: bf19a4de08cc5216b939c77eedc147e93e134bc284a90464f138f3a31f0d679d88e5bd6e306db63dbf0e26ce7a40fba618bb67d41c15443899a2824b6fd4776c

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+**1.4.0**
+
+* Added `Playlist#errors` method returning an array of validation error messages. `Playlist#valid?` now delegates to `errors.empty?`. Validates mixed item types, target duration, segment items, playlist items, media items, encryption keys, session keys, session data, and LL-HLS part items.
+* Updated CLI `validate` command to display specific error messages.
+* Updated `Writer` to include specific errors in the exception message.
+
+***
+
+**1.3.1**
+
+* Excluded CLAUDE.md and AGENTS.md from gem package.
+
+***
+
 **1.3.0**
 
 * Added CLI tool (`bin/m3u8`) with `inspect` and `validate` subcommands for inspecting playlist metadata and checking validity from the command line. Supports file arguments and stdin piping.

data/README.md

@@ -79,7 +79,8 @@ $ m3u8 validate playlist.m3u8
 Valid
 
 $ m3u8 validate bad.m3u8
-Invalid: mixed playlist and segment items
+Invalid
+  - Playlist contains both master and media items
 ```
 
 ## Usage (Builder DSL)
@@ -343,6 +344,41 @@ options = { width: 1920, height: 1080, codecs: 'avc1.66.30,mp4a.40.2',
 item = M3u8::PlaylistItem.new(options)
 ```
 
+## Validation
+
+Check whether a playlist is valid and inspect specific errors:
+
+```ruby
+playlist.valid?
+# => true
+
+playlist.errors
+# => []
+```
+
+When a playlist has issues, `errors` returns descriptive messages:
+
+```ruby
+playlist.valid?
+# => false
+
+playlist.errors
+# => ["Playlist contains both master and media items"]
+```
+
+The following validations are performed:
+
+* Mixed item types (both master and media items in one playlist)
+* Target duration less than any segment's rounded duration
+* Segment items missing a URI or having a negative duration
+* Playlist items missing a URI or valid bandwidth
+* Media items missing type, group ID, or name
+* Key and session key items missing a URI when method is not NONE
+* Session data items missing data ID, or having both/neither value and URI
+* Part items missing a URI or duration
+
+`valid?` delegates to `errors.empty?` and both are recomputed on each call.
+
 ## Usage (parsing playlists)
 
 ```ruby

data/lib/m3u8/cli/validate_command.rb

@@ -14,7 +14,8 @@ module M3u8
           @stdout.puts 'Valid'
           0
         else
-          @stdout.puts 'Invalid: mixed playlist and segment items'
+          @stdout.puts 'Invalid'
+          @playlist.errors.each { |e| @stdout.puts "  - #{e}" }
           1
         end
       end

data/lib/m3u8/playlist.rb

@@ -59,10 +59,22 @@ module M3u8
       output.string
     end
 
-    def valid?
-      return false if playlist_size.positive? && segment_size.positive?
+    def errors
+      [].tap do |errors|
+        validate_mixed_items(errors)
+        validate_target_duration(errors)
+        validate_segment_items(errors)
+        validate_playlist_items(errors)
+        validate_media_items(errors)
+        validate_key_items(errors)
+        validate_session_key_items(errors)
+        validate_session_data_items(errors)
+        validate_part_items(errors)
+      end
+    end
 
-      true
+    def valid?
+      errors.empty?
     end
 
     def segments
@@ -134,6 +146,78 @@ module M3u8
       }
     end
 
+    def validate_part_items(errors)
+      parts.each do |item|
+        errors << 'Part item requires a URI' if item.uri.nil?
+        errors << 'Part item requires a duration' if item.duration.nil?
+      end
+    end
+
+    def validate_session_data_items(errors)
+      session_data.each do |item|
+        errors << 'Session data item requires a data ID' if item.data_id.nil?
+        if !item.value.nil? && !item.uri.nil?
+          errors << 'Session data item cannot have both value and URI'
+        elsif item.value.nil? && item.uri.nil?
+          errors << 'Session data item requires a value or URI'
+        end
+      end
+    end
+
+    def validate_key_items(errors)
+      keys.each do |item|
+        next if item.method == 'NONE'
+
+        errors << 'Key item requires a URI when method is not NONE' if item.uri.nil?
+      end
+    end
+
+    def validate_session_key_items(errors)
+      session_keys.each do |item|
+        next if item.method == 'NONE'
+
+        errors << 'Session key item requires a URI when method is not NONE' if item.uri.nil?
+      end
+    end
+
+    def validate_playlist_items(errors)
+      playlists.each do |item|
+        errors << 'Playlist item requires a bandwidth' unless item.bandwidth&.positive?
+        errors << 'Playlist item requires a URI' if item.uri.nil?
+      end
+    end
+
+    def validate_media_items(errors)
+      media_items.each do |item|
+        errors << 'Media item requires a type' if item.type.nil?
+        errors << 'Media item requires a group ID' if item.group_id.nil?
+        errors << 'Media item requires a name' if item.name.nil?
+      end
+    end
+
+    def validate_segment_items(errors)
+      segments.each do |segment|
+        errors << 'Segment item requires a segment URI' if segment.segment.nil?
+        errors << 'Segment item has negative duration' if segment.duration&.negative?
+      end
+    end
+
+    def validate_target_duration(errors)
+      return if master?
+
+      max = segments.filter_map { |s| s.duration&.round }.max
+      return if max.nil? || target >= max
+
+      errors << "Target duration #{target} is less than " \
+                "segment duration of #{max}"
+    end
+
+    def validate_mixed_items(errors)
+      return unless playlist_size.positive? && segment_size.positive?
+
+      errors << 'Playlist contains both master and media items'
+    end
+
     def playlist_size
       playlists.size
     end

data/lib/m3u8/playlist_item.rb

@@ -69,7 +69,7 @@ module M3u8
         codecs: attributes['CODECS'],
         width: resolution[:width],
         height: resolution[:height],
-        bandwidth: attributes['BANDWIDTH'].to_i,
+        bandwidth: parse_bandwidth(attributes['BANDWIDTH']),
         average_bandwidth:
           parse_average_bandwidth(attributes['AVERAGE-BANDWIDTH']),
         frame_rate: parse_frame_rate(attributes['FRAME-RATE']),
@@ -90,6 +90,12 @@ module M3u8
       value&.to_i
     end
 
+    def parse_bandwidth(value)
+      return if value.nil?
+
+      value.to_i
+    end
+
     def parse_resolution(resolution)
       return { width: nil, height: nil } if resolution.nil?
 

data/lib/m3u8/version.rb

@@ -2,5 +2,5 @@
 
 # M3u8 provides parsing, generation, and validation of m3u8 playlists
 module M3u8
-  VERSION = '1.3.0'
+  VERSION = '1.4.0'
 end

data/lib/m3u8/writer.rb

@@ -44,7 +44,8 @@ module M3u8
     def validate(playlist)
       return if playlist.valid?
 
-      raise PlaylistTypeError, 'Playlist is invalid.'
+      raise PlaylistTypeError,
+            "Playlist is invalid: #{playlist.errors.join('; ')}"
     end
 
     def write_cache_tag(cache)

data/m3u8.gemspec

@@ -15,6 +15,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 3.0'
 
   spec.files         = `git ls-files -z`.split("\x0")
+                                        .grep_v(/\A(CLAUDE|AGENTS)\.md\z/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 

data/spec/lib/m3u8/cli/validate_command_spec.rb

@@ -18,7 +18,7 @@ describe M3u8::CLI::ValidateCommand do
     end
 
     context 'when playlist is invalid' do
-      it 'prints Invalid and returns 1' do
+      it 'prints Invalid with specific errors and returns 1' do
         playlist = M3u8::Playlist.new
         playlist.items << M3u8::PlaylistItem.new(
           bandwidth: 540, uri: 'test.url'
@@ -28,7 +28,11 @@ describe M3u8::CLI::ValidateCommand do
         )
         code = described_class.new(playlist, stdout).run
         expect(code).to eq(1)
-        expect(stdout.string.strip).to include('Invalid')
+        lines = stdout.string.split("\n")
+        expect(lines[0]).to eq('Invalid')
+        expect(lines[1]).to eq(
+          '  - Playlist contains both master and media items'
+        )
       end
     end
   end

data/spec/lib/m3u8/playlist_item_spec.rb

@@ -94,6 +94,12 @@ describe M3u8::PlaylistItem do
       expect(item.supplemental_codecs).to eq('dvh1.05.06/db4g')
       expect(item.req_video_layout).to eq('CH-MONO')
     end
+
+    it 'keeps bandwidth nil when BANDWIDTH is missing' do
+      input = '#EXT-X-STREAM-INF:CODECS="avc",URI="test.url"'
+      item = M3u8::PlaylistItem.parse(input)
+      expect(item.bandwidth).to be_nil
+    end
   end
 
   describe '#to_s' do

data/spec/lib/m3u8/playlist_spec.rb

@@ -182,6 +182,7 @@ describe M3u8::Playlist do
     end
 
     it 'returns media playlist text' do
+      playlist = described_class.new(target: 12)
       options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
       item =  M3u8::SegmentItem.new(options)
       playlist.items << item
@@ -192,7 +193,7 @@ describe M3u8::Playlist do
 
       expected = "#EXTM3U\n" \
                  "#EXT-X-MEDIA-SEQUENCE:0\n" \
-                 "#EXT-X-TARGETDURATION:10\n" \
+                 "#EXT-X-TARGETDURATION:12\n" \
                  "#EXTINF:11.344644,\n" \
                  "1080-7mbps00000.ts\n" \
                  "#EXTINF:11.261233,\n" \
@@ -237,6 +238,329 @@ describe M3u8::Playlist do
     end
   end
 
+  describe '#errors' do
+    context 'when playlist is empty' do
+      it 'returns no errors' do
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when playlist has only master items' do
+      it 'returns no errors' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when playlist has only media items' do
+      it 'returns no errors' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.0, segment: 'test.ts'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when segment duration exceeds target duration' do
+      it 'returns target duration error' do
+        playlist = described_class.new(target: 10)
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 12.1, segment: 'test.ts'
+        )
+        expect(playlist.errors).to include(
+          'Target duration 10 is less than segment duration of 12'
+        )
+      end
+    end
+
+    context 'when segment duration rounds to target' do
+      it 'returns no errors' do
+        playlist = described_class.new(target: 11)
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.5, segment: 'test.ts'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when playlist is master' do
+      it 'skips target duration check' do
+        playlist = described_class.new(master: true)
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when segment has no URI' do
+      it 'returns missing segment error' do
+        playlist.items << M3u8::SegmentItem.new(duration: 10.0)
+        expect(playlist.errors).to include(
+          'Segment item requires a segment URI'
+        )
+      end
+    end
+
+    context 'when segment has negative duration' do
+      it 'returns negative duration error' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: -1.0, segment: 'test.ts'
+        )
+        expect(playlist.errors).to include(
+          'Segment item has negative duration'
+        )
+      end
+    end
+
+    context 'when segment has zero duration' do
+      it 'returns no errors' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 0.0, segment: 'test.ts'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when multiple segments are invalid' do
+      it 'accumulates errors' do
+        playlist.items << M3u8::SegmentItem.new(duration: 10.0)
+        playlist.items << M3u8::SegmentItem.new(
+          duration: -1.0, segment: 'test.ts'
+        )
+        errors = playlist.errors
+        expect(errors).to include(
+          'Segment item requires a segment URI'
+        )
+        expect(errors).to include(
+          'Segment item has negative duration'
+        )
+      end
+    end
+
+    context 'when playlist item has no bandwidth' do
+      it 'returns missing bandwidth error' do
+        playlist.items << M3u8::PlaylistItem.new(uri: 'test.url')
+        expect(playlist.errors).to include(
+          'Playlist item requires a bandwidth'
+        )
+      end
+    end
+
+    context 'when playlist item has no URI and is not iframe' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::PlaylistItem.new(bandwidth: 540)
+        expect(playlist.errors).to include(
+          'Playlist item requires a URI'
+        )
+      end
+    end
+
+    context 'when playlist item has zero bandwidth' do
+      it 'returns missing bandwidth error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 0, uri: 'test.url'
+        )
+        expect(playlist.errors).to include(
+          'Playlist item requires a bandwidth'
+        )
+      end
+    end
+
+    context 'when iframe playlist item has no URI' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, iframe: true
+        )
+        expect(playlist.errors).to include(
+          'Playlist item requires a URI'
+        )
+      end
+    end
+
+    context 'when media item is missing type' do
+      it 'returns missing type error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::MediaItem.new(
+          group_id: 'audio', name: 'English'
+        )
+        expect(playlist.errors).to include(
+          'Media item requires a type'
+        )
+      end
+    end
+
+    context 'when media item is missing group_id' do
+      it 'returns missing group_id error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::MediaItem.new(
+          type: 'AUDIO', name: 'English'
+        )
+        expect(playlist.errors).to include(
+          'Media item requires a group ID'
+        )
+      end
+    end
+
+    context 'when media item is missing name' do
+      it 'returns missing name error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::MediaItem.new(
+          type: 'AUDIO', group_id: 'audio'
+        )
+        expect(playlist.errors).to include(
+          'Media item requires a name'
+        )
+      end
+    end
+
+    context 'when key item has method but no URI' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.0, segment: 'test.ts'
+        )
+        playlist.items << M3u8::KeyItem.new(method: 'AES-128')
+        expect(playlist.errors).to include(
+          'Key item requires a URI when method is not NONE'
+        )
+      end
+    end
+
+    context 'when key item method is NONE' do
+      it 'returns no errors' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.0, segment: 'test.ts'
+        )
+        playlist.items << M3u8::KeyItem.new(method: 'NONE')
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when session key item has method but no URI' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionKeyItem.new(
+          method: 'AES-128'
+        )
+        expect(playlist.errors).to include(
+          'Session key item requires a URI when method is not NONE'
+        )
+      end
+    end
+
+    context 'when session data item has no data_id' do
+      it 'returns missing data_id error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionDataItem.new(
+          value: 'Test'
+        )
+        expect(playlist.errors).to include(
+          'Session data item requires a data ID'
+        )
+      end
+    end
+
+    context 'when session data item has both value and uri' do
+      it 'returns conflict error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionDataItem.new(
+          data_id: 'com.test', value: 'Test',
+          uri: 'http://test'
+        )
+        expect(playlist.errors).to include(
+          'Session data item cannot have both value and URI'
+        )
+      end
+    end
+
+    context 'when session data item has neither value nor uri' do
+      it 'returns missing value error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionDataItem.new(
+          data_id: 'com.test'
+        )
+        expect(playlist.errors).to include(
+          'Session data item requires a value or URI'
+        )
+      end
+    end
+
+    context 'when session data item has only value' do
+      it 'returns no session data errors' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SessionDataItem.new(
+          data_id: 'com.test', value: 'Test'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when part item has no URI' do
+      it 'returns missing URI error' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 4.0, segment: 'seg.mp4'
+        )
+        playlist.items << M3u8::PartItem.new(duration: 0.5)
+        expect(playlist.errors).to include(
+          'Part item requires a URI'
+        )
+      end
+    end
+
+    context 'when part item has no duration' do
+      it 'returns missing duration error' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 4.0, segment: 'seg.mp4'
+        )
+        playlist.items << M3u8::PartItem.new(uri: 'seg.0.mp4')
+        expect(playlist.errors).to include(
+          'Part item requires a duration'
+        )
+      end
+    end
+
+    context 'when part item is valid' do
+      it 'returns no part errors' do
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 4.0, segment: 'seg.mp4'
+        )
+        playlist.items << M3u8::PartItem.new(
+          duration: 0.5, uri: 'seg.0.mp4'
+        )
+        expect(playlist.errors).to be_empty
+      end
+    end
+
+    context 'when playlist has mixed items' do
+      it 'returns mixed items error' do
+        playlist.items << M3u8::PlaylistItem.new(
+          bandwidth: 540, uri: 'test.url'
+        )
+        playlist.items << M3u8::SegmentItem.new(
+          duration: 10.0, segment: 'test.ts'
+        )
+        expect(playlist.errors).to include(
+          'Playlist contains both master and media items'
+        )
+      end
+    end
+  end
+
   describe '#segments' do
     it 'returns only segment items' do
       playlist = described_class.read(
@@ -356,7 +680,8 @@ describe M3u8::Playlist do
         item = M3u8::SegmentItem.new(options)
         playlist.items << item
 
-        message = 'Playlist is invalid.'
+        message = 'Playlist is invalid: Playlist contains both ' \
+                  'master and media items'
         io = StringIO.new
         expect { playlist.write(io) }
           .to raise_error(M3u8::PlaylistTypeError, message)

data/spec/lib/m3u8/writer_spec.rb

@@ -17,7 +17,7 @@ describe M3u8::Writer do
         item = M3u8::PlaylistItem.new(options)
         playlist.items << item
         options = { data_id: 'com.test.movie.title', value: 'Test',
-                    uri: 'http://test', language: 'en' }
+                    language: 'en' }
         item = M3u8::SessionDataItem.new(options)
         playlist.items << item
 
@@ -28,7 +28,7 @@ describe M3u8::Writer do
                    %(RESOLUTION=1920x1080,CODECS="avc1.640029,mp4a.40.2") +
                    ",BANDWIDTH=50000\nplaylist_url\n" +
                    %(#EXT-X-SESSION-DATA:DATA-ID="com.test.movie.title",) +
-                   %(VALUE="Test",URI="http://test",LANGUAGE="en"\n)
+                   %(VALUE="Test",LANGUAGE="en"\n)
 
         io = StringIO.open
         writer = described_class.new(io)
@@ -101,7 +101,7 @@ describe M3u8::Writer do
 
     context 'when playlist is a media playlist' do
       it 'writes playlist to io' do
-        options = { version: 4, cache: false, target: 6.2, sequence: 1,
+        options = { version: 4, cache: false, target: 12, sequence: 1,
                     discontinuity_sequence: 10, type: 'EVENT',
                     iframes_only: true }
         playlist = M3u8::Playlist.new(options)
@@ -116,7 +116,7 @@ describe M3u8::Writer do
                    "#EXT-X-MEDIA-SEQUENCE:1\n" \
                    "#EXT-X-DISCONTINUITY-SEQUENCE:10\n" \
                    "#EXT-X-ALLOW-CACHE:NO\n" \
-                   "#EXT-X-TARGETDURATION:6\n" \
+                   "#EXT-X-TARGETDURATION:12\n" \
                    "#EXTINF:11.344644,\n" \
                    "1080-7mbps00000.ts\n" \
                    "#EXT-X-ENDLIST\n"
@@ -132,7 +132,7 @@ describe M3u8::Writer do
       it 'writes playlist to io' do
         options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
         item =  M3u8::SegmentItem.new(options)
-        playlist = M3u8::Playlist.new(version: 7)
+        playlist = M3u8::Playlist.new(version: 7, target: 12)
         playlist.items << item
 
         options = { method: 'AES-128', uri: 'http://test.key',
@@ -148,7 +148,7 @@ describe M3u8::Writer do
         expected = "#EXTM3U\n" \
                    "#EXT-X-VERSION:7\n" \
                    "#EXT-X-MEDIA-SEQUENCE:0\n" \
-                   "#EXT-X-TARGETDURATION:10\n" \
+                   "#EXT-X-TARGETDURATION:12\n" \
                    "#EXTINF:11.344644,\n" \
                    "1080-7mbps00000.ts\n" +
                    %(#EXT-X-KEY:METHOD=AES-128,URI="http://test.key",) +
@@ -204,10 +204,10 @@ describe M3u8::Writer do
       end
     end
 
-    it 'raises error if item types are mixed' do
+    it 'raises error with specific messages if item types are mixed' do
       playlist = M3u8::Playlist.new
-      options = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-                  bandwidth: 540, playlist: 'test.url' }
+      options = { program_id: 1, width: 1920, height: 1080,
+                  codecs: 'avc', bandwidth: 540, uri: 'test.url' }
       item = M3u8::PlaylistItem.new(options)
       playlist.items << item
 
@@ -215,7 +215,8 @@ describe M3u8::Writer do
       item = M3u8::SegmentItem.new(options)
       playlist.items << item
 
-      message = 'Playlist is invalid.'
+      message = 'Playlist is invalid: Playlist contains both ' \
+                'master and media items'
       io = StringIO.new
       writer = described_class.new(io)
       expect { writer.write(playlist) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: m3u8
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Seth Deckard
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-28 00:00:00.000000000 Z
+date: 2026-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -135,9 +135,7 @@ files:
 - ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
-- AGENTS.md
 - CHANGELOG.md
-- CLAUDE.md
 - Gemfile
 - Guardfile
 - LICENSE.txt

data/AGENTS.md

@@ -1,27 +0,0 @@
-# AGENTS.md
-
-## Development Workflow
-
-- Git workflow: GitHub flow
-- Small (but logical) commits that can each be deployed independently
-- Each commit must not break CI
-- Prefer incremental changes over large feature branches
-
-### Commit Messages
-
-**Subject:** Max 50 chars, capitalized, no period, imperative mood ("Add" not "Added")
-
-**Body:** Wrap at 72 chars, explain what/why not how, blank line after subject
-
-**Leading verbs:** Add, Remove, Fix, Upgrade, Refactor, Reformat, Document, Reword
-
-## Development Standards
-
-- README updated with API changes
-- **Tests must cover all behavior** - check with `coverage/index.html` after running specs
-- RuboCop enforces 80-char line limit and other style
-
-## Deployment
-
-- Kicking off PR: `ghprcw`
-- Never deploy anything

data/CLAUDE.md

@@ -1 +0,0 @@
-AGENTS.md