Merge pull request #6 from rtk-rs/submodule

gwbres · web-flow · commit 0314ed461a93 · 2025-03-08T09:25:34.000+01:00
Submodule
diff --git a/.github/workflows/daily.yml b/.github/workflows/daily.yml
@@ -42,6 +42,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
+      with:
+        submodules: recursive
+        fetch-depth: 0
     - uses: actions-rs/toolchain@v1
       name: Install Rust
       with:
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -18,6 +18,9 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
+      with:
+        submodules: recursive
+        fetch-depth: 0
     - name: Build
       run: cargo build
     - name: Build
diff --git a/.gitignore b/.gitignore
@@ -15,4 +15,3 @@ Cargo.lock
 
 *.swo
 *.swp
-data/
diff --git a/.gitmodules b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "data"]
+	path = data
+	url = https://github.com/rtk-rs/data
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "binex"
-version = "0.4.1"
+version = "0.4.2"
 license = "MPL-2.0"
 authors = ["Guillaume W. Bres <guillaume.bressaix@gmail.com>"]
 description = "BINEX (Binary EXchange) encoder and decoder for GNSS"
diff --git a/README.md b/README.md
@@ -43,12 +43,13 @@ that it cannot interprate:
 
 ```rust
 use std::fs::File;
+use flate2::read::GzDecoder;
 use binex::prelude::{Decoder, StreamElement, Provider, Error};
 
-let fd = File::open("data/mfle20190130.bnx")
+let fd = File::open("data/BIN/mfle20200105.bnx.gz")
     .unwrap();
 
-let mut decoder = Decoder::new(fd);
+let mut decoder = Decoder::new(GzDecoder::new(fd));
 
 loop {
     match decoder.next() {
diff --git a/data b/data
@@ -0,0 +1 @@
+Subproject commit fd998de28ac4a10300aa90fda5a95457ccf23092
diff --git a/data/mfle20190130.bnx b/data/mfle20190130.bnx
diff --git a/data/mfle20200105.bnx.gz b/data/mfle20200105.bnx.gz
diff --git a/data/mfle20200113.bnx.gz b/data/mfle20200113.bnx.gz
diff --git a/src/decoder.rs b/src/decoder.rs
@@ -59,46 +59,8 @@ pub struct Decoder<'a, R: Read> {
 
 impl<'a, R: Read> Decoder<'a, R> {
     /// Creates a new BINEX [Decoder] from [R] readable interface,
-    /// ready to parse incoming bytes.
-    /// ```
-    /// use std::fs::File;
-    /// use binex::prelude::{Decoder, Error};
-    ///
-    /// // Create the Decoder:
-    /// //  * works from our local source
-    /// //  * needs to be mutable due to iterating process
-    /// let mut fd = File::open("data/mfle20190130.bnx")
-    ///     .unwrap();
-    ///
-    /// // Two generics: with M the internal buffer depth
-    /// let mut decoder = Decoder::new(fd);
-    ///
-    /// // Consume data stream
-    /// loop {
-    ///     match decoder.next() {
-    ///         Some(Ok(msg)) => {
-    ///             // do something
-    ///         },
-    ///         Some(Err(e)) => match e {
-    ///             Error::IoError => {
-    ///                 // any I/O error should be handled
-    ///                 // and user should react accordingly,
-    ///                 break;
-    ///             },
-    ///             Error::ReversedStream => {
-    ///                 // this library is currently limited:
-    ///                 //  - reversed streams are not supported yet
-    ///                 //  - little endian streams are not supported yet
-    ///             },
-    ///             _ => {},
-    ///         },
-    ///         None => {
-    ///             // End of stream!
-    ///             break;
-    ///         },
-    ///     }
-    /// }
-    /// ```
+    /// ready to parse incoming bytes. We only host gzip compressed
+    /// BINEX files, refer to [Decoder::new_gzip] for an example.
     pub fn new(reader: R) -> Self {
         Self {
             eos: false,
@@ -116,15 +78,16 @@ impl<'a, R: Read> Decoder<'a, R> {
     /// interface, that must stream Gzip encoded bytes.
     /// ```
     /// use std::fs::File;
+    /// use flate2::read::GzDecoder;
     /// use binex::prelude::{Decoder, Error};
     ///
     /// // Create the Decoder:
     /// //  * works from our local source
     /// //  * needs to be mutable due to iterating process
-    /// let mut fd = File::open("data/mfle20200105.bnx.gz")
+    /// let mut fd = File::open("data/BIN/mfle20200105.bnx.gz")
     ///     .unwrap();
     ///
-    /// let mut decoder = Decoder::new(fd);
+    /// let mut decoder = Decoder::new(GzDecoder::new(fd));
     ///
     /// // Consume data stream
     /// loop {
diff --git a/tests/decoder.rs b/tests/decoder.rs
@@ -1,40 +1,12 @@
 use binex::prelude::{Decoder, Error, StreamElement};
 use std::fs::File;
 
-#[test]
-fn mfle20190130() {
-    let mut found = 0;
-    let fd = File::open("data/mfle20190130.bnx").unwrap();
-
-    let mut decoder = Decoder::new(fd);
-
-    loop {
-        match decoder.next() {
-            Some(Ok(StreamElement::OpenSource(msg))) => {
-                found += 1;
-                println!("parsed: {:?}", msg);
-            },
-            Some(Ok(StreamElement::ClosedSource(_))) => {},
-            Some(Err(e)) => match e {
-                Error::IoError => panic!("i/o error"),
-                e => {
-                    println!("err={:?}", e);
-                },
-            },
-            None => {
-                break;
-            },
-        }
-    }
-    assert!(found > 0, "not a single msg decoded");
-}
-
 #[cfg(feature = "flate2")]
 #[test]
 fn gziped_files() {
     let mut found = 0;
     for fp in ["mfle20200105.bnx.gz", "mfle20200113.bnx.gz"] {
-        let fp = format!("data/{}", fp);
+        let fp = format!("data/BIN/{}", fp);
         let fd = File::open(fp).unwrap();
         let mut decoder = Decoder::new_gzip(fd);
 

Original file line number	Diff line number	Diff line change
`@@ -15,4 +15,3 @@ Cargo.lock`
`15`	`15`
`16`	`16`	`*.swo`
`17`	`17`	`*.swp`
`18`		`-data/`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+[submodule "data"]`
	`2`	`+ path = data`
	`3`	`+ url = https://github.com/rtk-rs/data`