fix clippy lints

src/line.rs

@@ -26,8 +26,7 @@ impl FromStr for Lines {
         for l in input.lines() {
             let line = l.trim();
 
-            // ignore empty lines
+            if line.is_empty() {
-            if line.len() == 0 {
                 continue;
             }
 
@@ -39,7 +38,7 @@ impl FromStr for Lines {
                     continue;
                 } else if line.starts_with("#EXT") {
                     Line::Tag(line.parse()?)
-                } else if line.starts_with("#") {
+                } else if line.starts_with('#') {
                     continue; // ignore comments
                 } else {
                     // stream inf line needs special treatment

src/master_playlist.rs

@@ -103,7 +103,7 @@ impl MasterPlaylistBuilder {
         let required_version = self.required_version();
         let specified_version = self
             .version_tag
-            .unwrap_or(required_version.into())
+            .unwrap_or_else(|| required_version.into())
             .version();
 
         if required_version > specified_version {
@@ -164,7 +164,7 @@ impl MasterPlaylistBuilder {
                     .flatten(),
             )
             .max()
-            .unwrap_or(ProtocolVersion::latest())
+            .unwrap_or_else(ProtocolVersion::latest)
     }
 
     fn validate_stream_inf_tags(&self) -> crate::Result<()> {
@@ -199,13 +199,12 @@ impl MasterPlaylistBuilder {
                     None => {}
                 }
             }
-            if has_none_closed_captions {
+            if has_none_closed_captions
-                if !value
+                && !value
                     .iter()
                     .all(|t| t.closed_captions() == Some(&ClosedCaptions::None))
-                {
+            {
-                    return Err(Error::invalid_input());
+                return Err(Error::invalid_input());
-                }
             }
         }
         Ok(())

src/media_playlist.rs

@@ -70,7 +70,7 @@ impl MediaPlaylistBuilder {
         let required_version = self.required_version();
         let specified_version = self
             .version_tag
-            .unwrap_or(required_version.into())
+            .unwrap_or_else(|| required_version.into())
             .version();
 
         if required_version > specified_version {
@@ -109,7 +109,7 @@ impl MediaPlaylistBuilder {
                     }
                 };
 
-                if !(rounded_segment_duration <= max_segment_duration) {
+                if rounded_segment_duration > max_segment_duration {
                     return Err(Error::custom(format!(
                         "Too large segment duration: actual={:?}, max={:?}, target_duration={:?}, uri={:?}",
                         segment_duration,
@@ -122,7 +122,7 @@ impl MediaPlaylistBuilder {
                 // CHECK: `#EXT-X-BYTE-RANGE`
                 if let Some(tag) = s.byte_range_tag() {
                     if tag.to_range().start().is_none() {
-                        let last_uri = last_range_uri.ok_or(Error::invalid_input())?;
+                        let last_uri = last_range_uri.ok_or_else(Error::invalid_input)?;
                         if last_uri != s.uri() {
                             return Err(Error::invalid_input());
                         }
@@ -200,7 +200,7 @@ impl MediaPlaylistBuilder {
                     .unwrap_or(ProtocolVersion::V1)
             }))
             .max()
-            .unwrap_or(ProtocolVersion::latest())
+            .unwrap_or_else(ProtocolVersion::latest)
     }
 
     /// Adds a media segment to the resulting playlist.

src/tags/basic/version.rs

@@ -50,7 +50,7 @@ impl ExtXVersion {
     ///     ProtocolVersion::V6
     /// );
     /// ```
-    pub const fn version(&self) -> ProtocolVersion {
+    pub const fn version(self) -> ProtocolVersion {
         self.0
     }
 }

src/tags/master_playlist/i_frame_stream_inf.rs

@@ -91,13 +91,12 @@ impl FromStr for ExtXIFrameStreamInf {
         let mut uri = None;
 
         for (key, value) in input.parse::<AttributePairs>()? {
-            match key.as_str() {
+            if let "URI" = key.as_str() {
-                "URI" => uri = Some(unquote(value)),
+                uri = Some(unquote(value));
-                _ => {}
             }
         }
 
-        let uri = uri.ok_or(Error::missing_value("URI"))?;
+        let uri = uri.ok_or_else(|| Error::missing_value("URI"))?;
 
         Ok(Self {
             uri,

src/tags/master_playlist/media.rs

@@ -68,7 +68,7 @@ impl ExtXMediaBuilder {
     fn validate(&self) -> Result<(), String> {
         let media_type = self
             .media_type
-            .ok_or(Error::missing_attribute("MEDIA-TYPE").to_string())?;
+            .ok_or_else(|| Error::missing_attribute("MEDIA-TYPE").to_string())?;
 
         if MediaType::ClosedCaptions == media_type {
             if self.uri.is_some() {
@@ -78,11 +78,9 @@ impl ExtXMediaBuilder {
                 .to_string());
             }
             self.instream_id
-                .ok_or(Error::missing_attribute("INSTREAM-ID").to_string())?;
+                .ok_or_else(|| Error::missing_attribute("INSTREAM-ID").to_string())?;
-        } else {
+        } else if self.instream_id.is_some() {
-            if self.instream_id.is_some() {
+            return Err(Error::custom("Unexpected attribute: \"INSTREAM-ID\"!").to_string());
-                return Err(Error::custom("Unexpected attribute: \"INSTREAM-ID\"!").to_string());
-            }
         }
 
         if self.is_default.unwrap_or(false) && !self.is_autoselect.unwrap_or(false) {
@@ -91,10 +89,8 @@ impl ExtXMediaBuilder {
             );
         }
 
-        if MediaType::Subtitles != media_type {
+        if MediaType::Subtitles != media_type && self.is_forced.is_some() {
-            if self.is_forced.is_some() {
+            return Err(Error::invalid_input().to_string());
-                return Err(Error::invalid_input().to_string());
-            }
         }
 
         Ok(())

src/tags/master_playlist/session_data.rs

@@ -291,7 +291,7 @@ impl FromStr for ExtXSessionData {
             }
         }
 
-        let data_id = data_id.ok_or(Error::missing_value("EXT-X-DATA-ID"))?;
+        let data_id = data_id.ok_or_else(|| Error::missing_value("EXT-X-DATA-ID"))?;
         let data = {
             if let Some(value) = session_value {
                 if uri.is_some() {

src/tags/master_playlist/stream_inf.rs

@@ -63,7 +63,7 @@ impl ExtXStreamInf {
 
     /// Returns the maximum frame rate for all the video in the variant stream.
     pub fn frame_rate(&self) -> Option<f64> {
-        self.frame_rate.map_or(None, |v| Some(v.as_f64()))
+        self.frame_rate.map(|v| v.as_f64())
     }
 
     /// Returns the group identifier for the audio in the variant stream.
@@ -113,8 +113,10 @@ impl FromStr for ExtXStreamInf {
 
     fn from_str(input: &str) -> Result<Self, Self::Err> {
         let mut lines = input.lines();
-        let first_line = lines.next().ok_or(Error::missing_value("first_line"))?;
+        let first_line = lines
-        let uri = lines.next().ok_or(Error::missing_value("URI"))?;
+            .next()
+            .ok_or_else(|| Error::missing_value("first_line"))?;
+        let uri = lines.next().ok_or_else(|| Error::missing_value("URI"))?;
 
         let input = tag(first_line, Self::PREFIX)?;
 

src/tags/media_playlist/discontinuity_sequence.rs

@@ -47,7 +47,7 @@ impl ExtXDiscontinuitySequence {
     ///
     /// assert_eq!(discontinuity_sequence.seq_num(), 5);
     /// ```
-    pub const fn seq_num(&self) -> u64 {
+    pub const fn seq_num(self) -> u64 {
         self.0
     }
 

src/tags/media_playlist/media_sequence.rs

@@ -45,7 +45,7 @@ impl ExtXMediaSequence {
     ///
     /// assert_eq!(media_sequence.seq_num(), 5);
     /// ```
-    pub const fn seq_num(&self) -> u64 {
+    pub const fn seq_num(self) -> u64 {
         self.0
     }
 

src/tags/media_segment/byte_range.rs

@@ -98,11 +98,11 @@ impl FromStr for ExtXByteRange {
         let length = tokens[0].parse()?;
 
         let start = {
-            let mut result = None;
             if tokens.len() == 2 {
-                result = Some(tokens[1].parse()?);
+                Some(tokens[1].parse()?)
+            } else {
+                None
             }
-            result
         };
 
         Ok(ExtXByteRange::new(length, start))

src/tags/media_segment/date_range.rs

@@ -164,15 +164,13 @@ impl FromStr for ExtXDateRange {
             }
         }
 
-        let id = id.ok_or(Error::missing_value("EXT-X-ID"))?;
+        let id = id.ok_or_else(|| Error::missing_value("EXT-X-ID"))?;
         let start_date = start_date
-            .ok_or(Error::missing_value("EXT-X-START-DATE"))?
+            .ok_or_else(|| Error::missing_value("EXT-X-START-DATE"))?
             .parse()?;
 
-        if end_on_next {
+        if end_on_next && class.is_none() {
-            if class.is_none() {
+            return Err(Error::invalid_input());
-                return Err(Error::invalid_input());
-            }
         }
         Ok(ExtXDateRange {
             id,

src/tags/media_segment/inf.rs

@@ -173,7 +173,7 @@ impl FromStr for ExtInf {
         dbg!(&input);
         let tokens = input.splitn(2, ',').collect::<Vec<_>>();
 
-        if tokens.len() == 0 {
+        if tokens.is_empty() {
             return Err(Error::custom(format!(
                 "failed to parse #EXTINF tag, couldn't split input: {:?}",
                 input

src/tags/media_segment/map.rs

@@ -93,7 +93,7 @@ impl FromStr for ExtXMap {
             }
         }
 
-        let uri = uri.ok_or(Error::missing_value("EXT-X-URI"))?;
+        let uri = uri.ok_or_else(|| Error::missing_value("EXT-X-URI"))?;
         Ok(ExtXMap { uri, range })
     }
 }

src/tags/shared/start.rs

@@ -97,7 +97,7 @@ impl FromStr for ExtXStart {
             }
         }
 
-        let time_offset = time_offset.ok_or(Error::missing_value("EXT-X-TIME-OFFSET"))?;
+        let time_offset = time_offset.ok_or_else(|| Error::missing_value("EXT-X-TIME-OFFSET"))?;
 
         Ok(ExtXStart {
             time_offset,

src/types/byte_range.rs

@@ -97,11 +97,11 @@ impl FromStr for ByteRange {
         let length = tokens[0].parse()?;
 
         let start = {
-            let mut result = None;
             if tokens.len() == 2 {
-                result = Some(tokens[1].parse()?);
+                Some(tokens[1].parse()?)
+            } else {
+                None
             }
-            result
         };
         Ok(ByteRange::new(length, start))
     }

src/types/decryption_key.rs

@@ -355,7 +355,7 @@ impl FromStr for DecryptionKey {
             }
         }
 
-        let method = method.ok_or(Error::missing_value("METHOD"))?;
+        let method = method.ok_or_else(|| Error::missing_value("METHOD"))?;
         if method != EncryptionMethod::None && uri.is_none() {
             return Err(Error::missing_value("URI"));
         }
@@ -365,7 +365,7 @@ impl FromStr for DecryptionKey {
             uri,
             iv,
             key_format,
-            key_format_versions: key_format_versions.unwrap_or(KeyFormatVersions::new()),
+            key_format_versions: key_format_versions.unwrap_or_default(),
         })
     }
 }

src/types/initialization_vector.rs

@@ -61,8 +61,8 @@ impl FromStr for InitializationVector {
 
         let mut v = [0; 16];
         for (i, c) in s.as_bytes().chunks(2).skip(1).enumerate() {
-            let d = std::str::from_utf8(c).map_err(|e| Error::custom(e))?;
+            let d = std::str::from_utf8(c).map_err(Error::custom)?;
-            let b = u8::from_str_radix(d, 16).map_err(|e| Error::custom(e))?;
+            let b = u8::from_str_radix(d, 16).map_err(Error::custom)?;
             v[i] = b;
         }
 

src/types/key_format_versions.rs

@@ -66,7 +66,7 @@ impl FromStr for KeyFormatVersions {
 
     fn from_str(input: &str) -> Result<Self, Self::Err> {
         let mut result = unquote(input)
-            .split("/")
+            .split('/')
             .filter_map(|v| v.parse().ok())
             .collect::<Vec<_>>();
 

src/types/stream_inf.rs

@@ -272,7 +272,7 @@ impl FromStr for StreamInf {
             }
         }
 
-        let bandwidth = bandwidth.ok_or(Error::missing_value("BANDWIDTH"))?;
+        let bandwidth = bandwidth.ok_or_else(|| Error::missing_value("BANDWIDTH"))?;
 
         Ok(Self {
             bandwidth,