Docs and formatting, bump to 0.5.1

Author: kovaxis

CHANGELOG.md

@@ -1,9 +1,11 @@
 
 # Version changelog
 
-## 0.5
+### 0.5.1
+
+
 
-### 0.5.0
+## 0.5
 
 - Rename `number` module to `num`.
 - Simplify generic `Smf<T>` to `Smf`, `SmfBytemap` and generic `parse`/`write` functions.
@@ -26,29 +28,23 @@
     `Smf` with prebuilt tracks use `Smf { header, tracks }` construction.
 - Added `Arena` to make track construction more ergonomic.
 
-## 0.4
-
 ### 0.4.1
 
 - Add support for the `.rmi` RIFF wrapper for MIDI files.
 - Errors are now a thin pointer in release mode.
 - Add a `TrackIter::running_status_mut` method.
 - Update `README.md` to match `0.4`.
 
-### 0.4.0
+## 0.4
 
 - `EventKind::parse` and `Event::read` no longer return event bytes.
 - Simplify `lenient` and `strict` features to a simple `strict` feature.
 
 ## 0.3
 
-## 0.3.0
-
 - Add support for writing MIDI files and events.
 - Handle running status more correctly.
 
-## 0.2
-
 ### 0.2.2
 
 - Fix pitch bend messages being read with the wrong endianness.
@@ -58,7 +54,7 @@
 - Update `README.md` to match the API of `0.2`.
 - Added an `ErrorKind::mesage` method.
 
-### 0.2.0
+## 0.2
 
 - Move error framework from `error-chain` to `failure`.
 - Renamed `Varlen` to `u28`.
@@ -71,8 +67,6 @@
 - Renamed `EventKind::read` to `EventKind::parse` to match the rest of the parse methods.
 - Added an optional (enabled by default) `std` feature to make the crate `no_std + alloc`.
 
-## 0.1
-
 ### 0.1.3
 
 - Rename `Fps::as_u8` and `Fps::from_u8` to `Fps::as_int` and `Fps::from_int`.
@@ -85,7 +79,7 @@
 
 - Add `as_int` method to convert MIDI integers to primitives.
 
-### 0.1.0
+## 0.1.0
 
 - Initial release.
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "midly"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2018"
 authors = ["negamartin"]
 include = [
@@ -10,8 +10,8 @@ include = [
 description = "Fast and complete MIDI parser and writer"
 repository = "https://github.com/negamartin/midly"
 readme = "README.md"
-keywords = ["parser", "audio", "midi", "no_std"]
-categories = ["multimedia", "multimedia::audio", "multimedia::encoding"]
+keywords = ["midi", "no_std", "audio", "parser"]
+categories = ["multimedia::audio", "multimedia::encoding", "multimedia"]
 license = "Unlicense"
 
 [features]

src/io.rs

@@ -142,6 +142,7 @@ impl<'a> Cursor<'a> {
             cur: 0,
         }
     }
+
     /// Create a cursor from a buffer and the cursor within it.
     pub fn from_parts(buffer: &mut [u8], cursor: usize) -> Cursor {
         assert!(
@@ -153,6 +154,7 @@ impl<'a> Cursor<'a> {
             cur: cursor,
         }
     }
+
     /// Yield the underlying buffer and the cursor within it.
     ///
     /// The cursor is guaranteed to be `cursor <= buffer.len()`.
@@ -164,10 +166,12 @@ impl<'a> Cursor<'a> {
     pub fn slice(&self) -> &[u8] {
         self.buf
     }
+
     /// Get a mutable reference to the whole underlying buffer.
     pub fn slice_mut(&mut self) -> &mut [u8] {
         self.buf
     }
+
     /// Get the position of the cursor.
     pub fn cursor(&self) -> usize {
         self.cur
@@ -177,10 +181,12 @@ impl<'a> Cursor<'a> {
     pub fn written(&self) -> &[u8] {
         &self.buf[..self.cur]
     }
+
     /// Get a reference to the portion of the buffer that is not yet written.
     pub fn unwritten(&self) -> &[u8] {
         &self.buf[self.cur..]
     }
+
     /// Split the buffer into the written and unwritten parts.
     pub fn split(&self) -> (&[u8], &[u8]) {
         self.buf.split_at(self.cur)
@@ -190,10 +196,12 @@ impl<'a> Cursor<'a> {
     pub fn written_mut(&mut self) -> &mut [u8] {
         &mut self.buf[..self.cur]
     }
+
     /// Get a mutable reference to the portion of the buffer that is not yet written.
     pub fn unwritten_mut(&mut self) -> &mut [u8] {
         &mut self.buf[self.cur..]
     }
+
     /// Split the buffer into the written and unwritten parts.
     pub fn split_mut(&mut self) -> (&mut [u8], &mut [u8]) {
         self.buf.split_at_mut(self.cur)

src/primitive.rs

@@ -359,6 +359,7 @@ impl Format {
             _ => bail!(err_invalid!("invalid smf format")),
         })
     }
+
     pub(crate) fn encode(&self) -> [u8; 2] {
         let code: u16 = match self {
             Format::SingleTrack => 0,
@@ -399,6 +400,7 @@ impl Timing {
             Ok(Timing::Metrical(u15::from(raw)))
         }
     }
+
     pub(crate) fn encode(&self) -> [u8; 2] {
         match self {
             Timing::Metrical(ticksperbeat) => ticksperbeat.as_int().to_be_bytes(),
@@ -457,24 +459,31 @@ impl SmpteTime {
             fps,
         })
     }
+
     pub fn hour(&self) -> u8 {
         self.hour
     }
+
     pub fn minute(&self) -> u8 {
         self.minute
     }
+
     pub fn second(&self) -> u8 {
         self.second
     }
+
     pub fn frame(&self) -> u8 {
         self.frame
     }
+
     pub fn subframe(&self) -> u8 {
         self.subframe
     }
+
     pub fn fps(&self) -> Fps {
         self.fps
     }
+
     pub fn second_f32(&self) -> f32 {
         self.second as f32
             + ((self.frame as f32 + self.subframe as f32 / 100.0) / self.fps.as_f32())
@@ -494,6 +503,7 @@ impl SmpteTime {
         Ok(SmpteTime::new(hour, minute, second, frame, subframe, fps)
             .ok_or(err_invalid!("invalid smpte time"))?)
     }
+
     pub(crate) fn encode(&self) -> [u8; 5] {
         let hour_fps = self.hour() | self.fps().as_code().as_int() << 5;
         [
@@ -531,6 +541,7 @@ impl Fps {
             _ => unreachable!(),
         }
     }
+
     /// Does the conversion to a 2-bit fps code.
     pub(crate) fn as_code(self) -> u2 {
         u2::from(match self {
@@ -540,6 +551,7 @@ impl Fps {
             Fps::Fps30 => 3,
         })
     }
+
     /// Converts an integer representing the semantic fps to an `Fps` value (ie. `24` -> `Fps24`).
     pub fn from_int(raw: u8) -> Option<Fps> {
         Some(match raw {
@@ -550,6 +562,7 @@ impl Fps {
             _ => return None,
         })
     }
+
     /// Get the integral approximate fps out.
     pub fn as_int(self) -> u8 {
         match self {
@@ -559,6 +572,7 @@ impl Fps {
             Fps::Fps30 => 30,
         }
     }
+
     /// Get the actual `f32` fps out.
     pub fn as_f32(self) -> f32 {
         match self.as_int() {

src/smf.rs

@@ -553,6 +553,7 @@ impl Header {
 }
 
 /// An iterator over all *tracks* in a Standard Midi File.
+/// Created by the [`parse`](fn.parse.html) function.
 ///
 /// This type is always available, even in `no_std` environments.
 #[derive(Clone, Debug)]
@@ -728,6 +729,7 @@ impl<'a, T: EventKind<'a>> Iterator for EventIterGeneric<'a, T> {
 }
 
 /// An iterator over the events of a single track.
+/// Yielded by the [`TrackIter`](struct.TrackIter.html) iterator.
 ///
 /// This iterator is lazy, it parses events as it goes, and therefore produces `Result<TrackEvent>>`
 /// rather than `TrackEvent`.
@@ -801,6 +803,7 @@ impl<'a> Iterator for EventIter<'a> {
 
 /// An iterator over the events of a single track that keeps track of the raw bytes that make up
 /// each event.
+/// Created by the [`EventIter::bytemapped`](struct.EventIter.html#method.bytemapped) method.
 ///
 /// This iterator is lazy, it parses events as it goes, and therefore produces
 /// `Result<(&[u8], TrackEvent)>>` rather than just `(&[u8], TrackEvent)`.