chore: setup Cargo workspace

examples/custom.rs

@@ -1,81 +0,0 @@
-use std::convert::From;
-use std::env::args;
-use std::fs;
-use std::io::{Error as IOError, Write};
-use std::result::Result;
-use std::string::FromUtf8Error;
-
-use orgize::export::{DefaultHtmlHandler, HtmlHandler};
-use orgize::{Element, Org};
-use slugify::slugify;
-
-#[derive(Debug)]
-enum MyError {
-    IO(IOError),
-    Heading,
-    Utf8(FromUtf8Error),
-}
-
-// From<std::io::Error> trait is required for custom error type
-impl From<IOError> for MyError {
-    fn from(err: IOError) -> Self {
-        MyError::IO(err)
-    }
-}
-
-impl From<FromUtf8Error> for MyError {
-    fn from(err: FromUtf8Error) -> Self {
-        MyError::Utf8(err)
-    }
-}
-
-struct MyHtmlHandler(DefaultHtmlHandler);
-
-impl HtmlHandler<MyError> for MyHtmlHandler {
-    fn start<W: Write>(&mut self, mut w: W, element: &Element<'_>) -> Result<(), MyError> {
-        match element {
-            Element::Title(title) => {
-                if title.level > 6 {
-                    return Err(MyError::Heading);
-                } else {
-                    write!(
-                        w,
-                        "<h{0}><a id=\"{1}\" href=\"#{1}\">",
-                        title.level,
-                        slugify!(&title.raw),
-                    )?;
-                }
-            }
-            // fallthrough to default handler
-            _ => self.0.start(w, element)?,
-        }
-        Ok(())
-    }
-
-    fn end<W: Write>(&mut self, mut w: W, element: &Element<'_>) -> Result<(), MyError> {
-        match element {
-            Element::Title(title) => {
-                write!(w, "</a></h{}>", title.level,)?;
-            }
-            _ => self.0.end(w, element)?,
-        }
-        Ok(())
-    }
-}
-
-fn main() -> Result<(), MyError> {
-    let args: Vec<_> = args().collect();
-
-    if args.len() < 2 {
-        eprintln!("Usage: {} <org-file>", args[0]);
-    } else {
-        let contents = String::from_utf8(fs::read(&args[1])?)?;
-
-        let mut writer = Vec::new();
-        Org::parse(&contents).html_with_handler(&mut writer, MyHtmlHandler(DefaultHtmlHandler))?;
-
-        println!("{}", String::from_utf8(writer)?);
-    }
-
-    Ok(())
-}

examples/iter.rs

@@ -1,19 +0,0 @@
-use orgize::Org;
-use std::env::args;
-use std::fs;
-use std::io::Result;
-
-fn main() -> Result<()> {
-    let args: Vec<_> = args().collect();
-
-    if args.len() < 2 {
-        eprintln!("Usage: {} <org-file>", args[0]);
-    } else {
-        let contents = String::from_utf8(fs::read(&args[1])?).unwrap();
-
-        for event in Org::parse(&contents).iter() {
-            println!("{:?}", event);
-        }
-    }
-    Ok(())
-}

examples/json.rs

@@ -1,17 +0,0 @@
-use orgize::Org;
-use serde_json::to_string;
-use std::env::args;
-use std::fs;
-use std::io::Result;
-
-fn main() -> Result<()> {
-    let args: Vec<_> = args().collect();
-
-    if args.len() < 2 {
-        eprintln!("Usage: {} <org-file>", args[0]);
-    } else {
-        let contents = String::from_utf8(fs::read(&args[1])?).unwrap();
-        println!("{}", to_string(&Org::parse(&contents)).unwrap());
-    }
-    Ok(())
-}

examples/syntect.rs

@@ -1,94 +0,0 @@
-use std::env::args;
-use std::fs;
-use std::io::{Error, Result, Write};
-use syntect::{
-    easy::HighlightLines,
-    highlighting::ThemeSet,
-    html::{styled_line_to_highlighted_html, IncludeBackground},
-    parsing::SyntaxSet,
-};
-
-use orgize::export::{DefaultHtmlHandler, HtmlHandler};
-use orgize::{Element, Org};
-
-pub struct SyntectHtmlHandler {
-    syntax_set: SyntaxSet,
-    theme_set: ThemeSet,
-    default_hanlder: DefaultHtmlHandler,
-}
-
-impl Default for SyntectHtmlHandler {
-    fn default() -> Self {
-        SyntectHtmlHandler {
-            syntax_set: SyntaxSet::load_defaults_newlines(),
-            theme_set: ThemeSet::load_defaults(),
-            default_hanlder: DefaultHtmlHandler,
-        }
-    }
-}
-
-impl SyntectHtmlHandler {
-    fn highlight(&self, language: Option<&str>, content: &str) -> String {
-        let mut highlighter = HighlightLines::new(
-            language
-                .and_then(|lang| self.syntax_set.find_syntax_by_token(lang))
-                .unwrap_or_else(|| self.syntax_set.find_syntax_plain_text()),
-            &self.theme_set.themes["InspiredGitHub"],
-        );
-        let regions = highlighter.highlight(content, &self.syntax_set);
-        styled_line_to_highlighted_html(&regions[..], IncludeBackground::No)
-    }
-}
-
-impl HtmlHandler<Error> for SyntectHtmlHandler {
-    fn start<W: Write>(&mut self, mut w: W, element: &Element<'_>) -> Result<()> {
-        match element {
-            Element::InlineSrc(inline_src) => write!(
-                w,
-                "<code>{}</code>",
-                self.highlight(Some(&inline_src.lang), &inline_src.body)
-            )?,
-            Element::SourceBlock(block) => {
-                if block.language.is_empty() {
-                    write!(w, "<pre class=\"example\">{}</pre>", block.contents)?;
-                } else {
-                    write!(
-                        w,
-                        "<div class=\"org-src-container\"><pre class=\"src src-{}\">{}</pre></div>",
-                        block.language,
-                        self.highlight(Some(&block.language), &block.contents)
-                    )?
-                }
-            }
-            Element::FixedWidth { value } => write!(
-                w,
-                "<pre class=\"example\">{}</pre>",
-                self.highlight(None, value)
-            )?,
-            Element::ExampleBlock(block) => write!(
-                w,
-                "<pre class=\"example\">{}</pre>",
-                self.highlight(None, &block.contents)
-            )?,
-            _ => self.default_hanlder.start(w, element)?,
-        }
-        Ok(())
-    }
-}
-
-fn main() {
-    let args: Vec<_> = args().collect();
-
-    if args.len() < 2 {
-        eprintln!("Usage: {} <org-file>", args[0]);
-    } else {
-        let contents = String::from_utf8(fs::read(&args[1]).unwrap()).unwrap();
-
-        let mut writer = Vec::new();
-        Org::parse(&contents)
-            .html_with_handler(&mut writer, SyntectHtmlHandler::default())
-            .unwrap();
-
-        println!("{}", String::from_utf8(writer).unwrap());
-    }
-}