first init

Author: robin

.gitignore

@@ -0,0 +1,8 @@
+target/
+.DS_Store
+.idea
+*.iml
+*.log
+*.bak
+*.lock
+

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "fred"
+version = "0.1.0"
+authors = ["robin <[email protected]>"]
+
+[dependencies]
+zip = { version = "0.2", default-features = false }
+quick-xml = "0.9.4"

data/filosofi-logo.docx

@@ -0,0 +1,16 @@
+
+
+extern crate fred;
+
+use fred::Docx;
+use std::io::Read;
+
+fn main(){
+    let mut file = Docx::open("data/sample.docx").unwrap();
+    let mut isi = String::new();
+    let _ = file.read_to_string(&mut isi);
+    println!("ISI:");
+    println!("----------BEGIN----------");
+    println!("{}", isi);
+    println!("----------EOF----------");
+}

data/sample.docx

@@ -0,0 +1,123 @@
+
+#![allow(unused_imports, dead_code, unused_must_use)]
+
+extern crate zip;
+extern crate quick_xml as xml;
+
+use zip::ZipArchive;
+
+use xml::reader::Reader;
+use xml::events::Event;
+
+use std::path::{Path, PathBuf};
+use std::fs::File;
+use std::io::prelude::*;
+use std::io;
+use std::clone::Clone;
+use zip::read::ZipFile;
+
+pub struct Docx {
+    path: PathBuf,
+    data: String,
+    offset: usize
+}
+
+impl Docx {
+    pub fn open<P: AsRef<Path>>(path: P) -> io::Result<Docx> {
+        let file = File::open(path.as_ref())?;
+        let mut archive = ZipArchive::new(file)?;
+
+        let mut xml_data = String::new();
+
+//        let doc_xml_file:File;
+
+        for i in 0..archive.len(){
+            let mut c_file = archive.by_index(i).unwrap();
+            if c_file.name() == "word/document.xml" {
+                c_file.read_to_string(&mut xml_data);
+                break
+            }
+        }
+
+        let mut xml_reader = Reader::from_str(xml_data.as_ref());
+
+        let mut buf = Vec::new();
+        let mut txt = Vec::new();
+
+        if xml_data.len() > 0 {
+            let mut to_read = false;
+            loop {
+                match xml_reader.read_event(&mut buf){
+                    Ok(Event::Start(ref e)) => {
+                        match e.name() {
+                            b"w:p" => {
+                                to_read = true;
+                                txt.push("\n\n".to_string());
+                            },
+                            b"w:t" => to_read = true,
+                            _ => (),
+                        }
+                    },
+                    Ok(Event::Text(e)) => {
+                        if to_read {
+                            txt.push(e.unescape_and_decode(&xml_reader).unwrap());
+                            to_read = false;
+                        }
+                    },
+                    Ok(Event::Eof) => break, // exits the loop when reaching end of file
+                    Err(e) => panic!("Error at position {}: {:?}", xml_reader.buffer_position(), e),
+                    _ => (),
+                }
+            }
+        }
+
+        Ok(
+            Docx {
+                path: path.as_ref().to_path_buf(),
+                data: txt.join(""),
+                offset: 0
+            }
+        )
+    }
+
+}
+
+impl Read for Docx {
+    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+        let bytes = self.data.as_bytes();
+        let limit = if bytes.len() < self.offset + 10 {
+            bytes.len()
+        }else{
+            self.offset + 10
+        };
+
+        if self.offset > limit {
+            Ok(0)
+        }else{
+            let rv = buf.write(&bytes[self.offset..limit])?;
+            self.offset = self.offset + 10;
+            Ok(rv)
+        }
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use std::path::{Path, PathBuf};
+    use super::*;
+
+    #[test]
+    fn instantiate(){
+        let _ = Docx::open(Path::new("./tmp"));
+    }
+
+    #[test]
+    fn read_docx(){
+        let mut f = Docx::open(Path::new("data/filosofi-logo.docx")).unwrap();
+
+        let mut data = String::new();
+        let len = f.read_to_string(&mut data).unwrap();
+        println!("len: {}, data: {}", len, data);
+    }
+}