talexander/organic
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Remove all pub.

Browse Source
This commit is contained in:
Tom Alexander 2023-09-11 13:11:08 -04:00
parent a74319d381
commit 7650a9edff
Signed by: talexander
GPG Key ID: D3A179C9A53C0EDE
71 changed files with 493 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/compare/diff.rs
View File

@ -69,13 +69,13 @@ use crate::types::Verbatim;
use crate::types::VerseBlock;
#[derive(Debug)]
pub enum DiffEntry<'s> {
enum DiffEntry<'s> {
DiffResult(DiffResult<'s>),
DiffLayer(DiffLayer<'s>),
}
#[derive(Debug)]
pub struct DiffResult<'s> {
struct DiffResult<'s> {
status: DiffStatus,
name: String,
message: Option<String>,
@ -86,13 +86,13 @@ pub struct DiffResult<'s> {
}
#[derive(Debug, PartialEq)]
pub enum DiffStatus {
enum DiffStatus {
Good,
Bad,
}
#[derive(Debug)]
pub struct DiffLayer<'s> {
struct DiffLayer<'s> {
name: String,
children: Vec<DiffEntry<'s>>,
}
@ -126,11 +126,11 @@ impl<'s> DiffEntry<'s> {
}
}
pub fn is_bad(&self) -> bool {
fn is_bad(&self) -> bool {
self.is_immediately_bad() || self.has_bad_children()
}
pub fn print(&self, original_document: &str) -> Result<(), Box<dyn std::error::Error>> {
fn print(&self, original_document: &str) -> Result<(), Box<dyn std::error::Error>> {
self.print_indented(0, original_document)
}
@ -374,7 +374,7 @@ fn compare_object<'s>(
}
}
pub fn compare_document<'s>(
fn compare_document<'s>(
emacs: &'s Token<'s>,
rust: &'s Document<'s>,
) -> Result<DiffEntry<'s>, Box<dyn std::error::Error>> {

10
src/compare/mod.rs
View File

@ -1,8 +1,8 @@
mod diff;
mod parse;
mod util;
pub use diff::compare_document;
pub use parse::emacs_parse_anonymous_org_document;
pub use parse::emacs_parse_file_org_document;
pub use parse::get_emacs_version;
pub use parse::get_org_mode_version;
use diff::compare_document;
use parse::emacs_parse_anonymous_org_document;
use parse::emacs_parse_file_org_document;
use parse::get_emacs_version;
use parse::get_org_mode_version;

8
src/compare/parse.rs
View File

@ -1,7 +1,7 @@
use std::path::Path;
use std::process::Command;
pub fn emacs_parse_anonymous_org_document<C>(
fn emacs_parse_anonymous_org_document<C>(
file_contents: C,
) -> Result<String, Box<dyn std::error::Error>>
where
@ -31,7 +31,7 @@ where
Ok(String::from_utf8(org_sexp)?)
}
pub fn emacs_parse_file_org_document<P>(file_path: P) -> Result<String, Box<dyn std::error::Error>>
fn emacs_parse_file_org_document<P>(file_path: P) -> Result<String, Box<dyn std::error::Error>>
where
P: AsRef<Path>,
{
@ -85,7 +85,7 @@ where
output
}
pub fn get_emacs_version() -> Result<String, Box<dyn std::error::Error>> {
fn get_emacs_version() -> Result<String, Box<dyn std::error::Error>> {
let elisp_script = r#"(progn
(message "%s" (version))
)"#;
@ -103,7 +103,7 @@ pub fn get_emacs_version() -> Result<String, Box<dyn std::error::Error>> {
Ok(String::from_utf8(out.stderr)?)
}
pub fn get_org_mode_version() -> Result<String, Box<dyn std::error::Error>> {
fn get_org_mode_version() -> Result<String, Box<dyn std::error::Error>> {
let elisp_script = r#"(progn
(org-mode)
(message "%s" (org-version nil t nil))

6
src/compare/util.rs
View File

@ -21,7 +21,7 @@ fn get_offsets<'s, S: Source<'s>>(source: &'s str, rust_object: &'s S) -> (usize
(offset, end)
}
pub fn assert_name<'s>(emacs: &'s Token<'s>, name: &str) -> Result<(), Box<dyn std::error::Error>> {
fn assert_name<'s>(emacs: &'s Token<'s>, name: &str) -> Result<(), Box<dyn std::error::Error>> {
let children = emacs.as_list()?;
let first_child = children
.first()
@ -37,7 +37,7 @@ pub fn assert_name<'s>(emacs: &'s Token<'s>, name: &str) -> Result<(), Box<dyn s
Ok(())
}
pub fn assert_bounds<'s, S: Source<'s>>(
fn assert_bounds<'s, S: Source<'s>>(
source: &'s str,
emacs: &'s Token<'s>,
rust: &'s S,
@ -146,7 +146,7 @@ fn maybe_token_to_usize(
/// Returns Ok(None) if value is nil.
///
/// Returns error if the attribute is not specified on the token at all.
pub fn get_property<'s, 'x>(
fn get_property<'s, 'x>(
emacs: &'s Token<'s>,
key: &'x str,
) -> Result<Option<&'s Token<'s>>, Box<dyn std::error::Error>> {

34
src/context/context.rs
View File

@ -14,7 +14,7 @@ use crate::error::Res;
use crate::parser::OrgSource;
#[derive(Debug)]
pub enum ContextElement<'r, 's> {
enum ContextElement<'r, 's> {
/// Stores a parser that indicates that children should exit upon matching an exit matcher.
ExitMatcherNode(ExitMatcherNode<'r>),
@ -31,10 +31,10 @@ pub enum ContextElement<'r, 's> {
Placeholder(PhantomData<&'s str>),
}
pub struct ExitMatcherNode<'r> {
struct ExitMatcherNode<'r> {
// TODO: Should this be "&'r DynContextMatcher<'c>" ?
pub exit_matcher: &'r DynContextMatcher<'r>,
pub class: ExitClass,
exit_matcher: &'r DynContextMatcher<'r>,
class: ExitClass,
}
impl<'r> std::fmt::Debug for ExitMatcherNode<'r> {
@ -46,13 +46,13 @@ impl<'r> std::fmt::Debug for ExitMatcherNode<'r> {
}
#[derive(Debug)]
pub struct Context<'g, 'r, 's> {
struct Context<'g, 'r, 's> {
global_settings: &'g GlobalSettings<'g, 's>,
tree: List<'r, &'r ContextElement<'r, 's>>,
}
impl<'g, 'r, 's> Context<'g, 'r, 's> {
pub fn new(
fn new(
global_settings: &'g GlobalSettings<'g, 's>,
tree: List<'r, &'r ContextElement<'r, 's>>,
) -> Self {
@ -62,38 +62,38 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
}
}
pub fn with_additional_node(&'r self, new_element: &'r ContextElement<'r, 's>) -> Self {
fn with_additional_node(&'r self, new_element: &'r ContextElement<'r, 's>) -> Self {
let new_tree = self.tree.push(new_element);
Self::new(self.global_settings, new_tree)
}
pub fn iter(&'r self) -> super::list::Iter<'r, &'r ContextElement<'r, 's>> {
fn iter(&'r self) -> super::list::Iter<'r, &'r ContextElement<'r, 's>> {
self.tree.iter()
}
pub fn iter_context(&'r self) -> Iter<'g, 'r, 's> {
fn iter_context(&'r self) -> Iter<'g, 'r, 's> {
Iter {
next: self.tree.iter_list(),
global_settings: self.global_settings,
}
}
pub fn get_parent(&'r self) -> Option<Self> {
fn get_parent(&'r self) -> Option<Self> {
self.tree.get_parent().map(|parent_tree| Self {
global_settings: self.global_settings,
tree: parent_tree.clone(),
})
}
pub fn get_data(&self) -> &ContextElement<'r, 's> {
fn get_data(&self) -> &ContextElement<'r, 's> {
self.tree.get_data()
}
pub fn get_global_settings(&self) -> &'g GlobalSettings<'g, 's> {
fn get_global_settings(&self) -> &'g GlobalSettings<'g, 's> {
self.global_settings
}
pub fn with_global_settings<'gg>(
fn with_global_settings<'gg>(
&self,
new_settings: &'gg GlobalSettings<'gg, 's>,
) -> Context<'gg, 'r, 's> {
@ -104,7 +104,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn check_exit_matcher(
fn check_exit_matcher(
&'r self,
i: OrgSource<'s>,
) -> IResult<OrgSource<'s>, OrgSource<'s>, CustomError<OrgSource<'s>>> {
@ -133,7 +133,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
/// Indicates if elements should consume the whitespace after them.
///
/// Defaults to true.
pub fn should_consume_trailing_whitespace(&self) -> bool {
fn should_consume_trailing_whitespace(&self) -> bool {
self._should_consume_trailing_whitespace().unwrap_or(true)
}
@ -158,7 +158,7 @@ fn document_end<'b, 'g, 'r, 's>(
eof(input)
}
pub struct Iter<'g, 'r, 's> {
struct Iter<'g, 'r, 's> {
global_settings: &'g GlobalSettings<'g, 's>,
next: super::list::IterList<'r, &'r ContextElement<'r, 's>>,
}
@ -175,7 +175,7 @@ impl<'g, 'r, 's> Iterator for Iter<'g, 'r, 's> {
}
impl<'r, 's> ContextElement<'r, 's> {
pub fn document_context() -> Self {
fn document_context() -> Self {
Self::ExitMatcherNode(ExitMatcherNode {
exit_matcher: &document_end,
class: ExitClass::Document,

2
src/context/exiting.rs
View File

@ -1,5 +1,5 @@
#[derive(Debug, Copy, Clone)]
pub enum ExitClass {
enum ExitClass {
Document = 1,
Alpha = 2,
Beta = 3,

6
src/context/file_access_interface.rs
View File

@ -1,13 +1,13 @@
use std::fmt::Debug;
use std::path::PathBuf;
pub trait FileAccessInterface: Debug {
trait FileAccessInterface: Debug {
fn read_file(&self, path: &str) -> Result<String, std::io::Error>;
}
#[derive(Debug, Clone)]
pub struct LocalFileAccessInterface {
pub working_directory: Option<PathBuf>,
struct LocalFileAccessInterface {
working_directory: Option<PathBuf>,
}
impl FileAccessInterface for LocalFileAccessInterface {

12
src/context/global_settings.rs
View File

@ -7,15 +7,15 @@ use crate::types::Object;
// TODO: Ultimately, I think we'll need most of this: https://orgmode.org/manual/In_002dbuffer-Settings.html
#[derive(Debug, Clone)]
pub struct GlobalSettings<'g, 's> {
pub radio_targets: Vec<&'g Vec<Object<'s>>>,
pub file_access: &'g dyn FileAccessInterface,
pub in_progress_todo_keywords: BTreeSet<String>,
pub complete_todo_keywords: BTreeSet<String>,
struct GlobalSettings<'g, 's> {
radio_targets: Vec<&'g Vec<Object<'s>>>,
file_access: &'g dyn FileAccessInterface,
in_progress_todo_keywords: BTreeSet<String>,
complete_todo_keywords: BTreeSet<String>,
}
impl<'g, 's> GlobalSettings<'g, 's> {
pub fn new() -> GlobalSettings<'g, 's> {
fn new() -> GlobalSettings<'g, 's> {
GlobalSettings {
radio_targets: Vec::new(),
file_access: &LocalFileAccessInterface {

18
src/context/list.rs
View File

@ -1,7 +1,7 @@
use std::fmt::Debug;
#[derive(Debug, Clone)]
pub struct List<'parent, T> {
struct List<'parent, T> {
data: T,
parent: Link<'parent, T>,
}
@ -9,30 +9,30 @@ pub struct List<'parent, T> {
type Link<'parent, T> = Option<&'parent List<'parent, T>>;
impl<'parent, T> List<'parent, T> {
pub fn new(first_item: T) -> Self {
fn new(first_item: T) -> Self {
Self {
data: first_item,
parent: None,
}
}
pub fn get_data(&self) -> &T {
fn get_data(&self) -> &T {
&self.data
}
pub fn get_parent(&'parent self) -> Link<'parent, T> {
fn get_parent(&'parent self) -> Link<'parent, T> {
self.parent
}
pub fn iter(&self) -> Iter<'_, T> {
fn iter(&self) -> Iter<'_, T> {
Iter { next: Some(self) }
}
pub fn iter_list(&self) -> IterList<'_, T> {
fn iter_list(&self) -> IterList<'_, T> {
IterList { next: Some(self) }
}
pub fn push(&'parent self, item: T) -> Self {
fn push(&'parent self, item: T) -> Self {
Self {
data: item,
parent: Some(self),
@ -40,7 +40,7 @@ impl<'parent, T> List<'parent, T> {
}
}
pub struct Iter<'a, T> {
struct Iter<'a, T> {
next: Link<'a, T>,
}
@ -54,7 +54,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
}
}
pub struct IterList<'a, T> {
struct IterList<'a, T> {
next: Link<'a, T>,
}

28
src/context/mod.rs
View File

@ -8,22 +8,22 @@ mod global_settings;
mod list;
mod parser_with_context;
pub type RefContext<'b, 'g, 'r, 's> = &'b Context<'g, 'r, 's>;
pub trait ContextMatcher = for<'b, 'g, 'r, 's> Fn(
type RefContext<'b, 'g, 'r, 's> = &'b Context<'g, 'r, 's>;
trait ContextMatcher = for<'b, 'g, 'r, 's> Fn(
RefContext<'b, 'g, 'r, 's>,
OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>>;
pub type DynContextMatcher<'c> = dyn ContextMatcher + 'c;
pub trait Matcher = for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>;
type DynContextMatcher<'c> = dyn ContextMatcher + 'c;
trait Matcher = for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>;
#[allow(dead_code)]
pub type DynMatcher<'c> = dyn Matcher + 'c;
type DynMatcher<'c> = dyn Matcher + 'c;
pub use context::Context;
pub use context::ContextElement;
pub use context::ExitMatcherNode;
pub use exiting::ExitClass;
pub use file_access_interface::FileAccessInterface;
pub use file_access_interface::LocalFileAccessInterface;
pub use global_settings::GlobalSettings;
pub use list::List;
pub(crate) use parser_with_context::parser_with_context;
use context::Context;
use context::ContextElement;
use context::ExitMatcherNode;
use exiting::ExitClass;
use file_access_interface::FileAccessInterface;
use file_access_interface::LocalFileAccessInterface;
use global_settings::GlobalSettings;
use list::List;
(crate) use parser_with_context::parser_with_context;

2
src/context/parser_with_context.rs
View File

@ -3,4 +3,4 @@ macro_rules! parser_with_context {
move |context| move |i| $target(context, i)
};
}
pub(crate) use parser_with_context;
(crate) use parser_with_context;

6
src/error/error.rs
View File

@ -2,18 +2,18 @@ use nom::error::ErrorKind;
use nom::error::ParseError;
use nom::IResult;
pub type Res<T, U> = IResult<T, U, CustomError<T>>;
type Res<T, U> = IResult<T, U, CustomError<T>>;
// TODO: MyError probably shouldn't be based on the same type as the input type since it's used exclusively with static strings right now.
#[derive(Debug)]
pub enum CustomError<I> {
enum CustomError<I> {
MyError(MyError<I>),
Nom(I, ErrorKind),
IO(std::io::Error),
}
#[derive(Debug)]
pub struct MyError<I>(pub I);
struct MyError<I>( I);
impl<I> ParseError<I> for CustomError<I> {
fn from_error_kind(input: I, kind: ErrorKind) -> Self {

6
src/error/mod.rs
View File

@ -1,4 +1,4 @@
mod error;
pub use error::CustomError;
pub use error::MyError;
pub use error::Res;
use error::CustomError;
use error::MyError;
use error::Res;

8
src/init_tracing.rs
View File

@ -10,7 +10,7 @@ const SERVICE_NAME: &'static str = "organic";
// Despite the obvious verbosity that fully-qualifying everything causes, in these functions I am fully-qualifying everything relating to tracing. This is because the tracing feature involves multiple libraries working together and so I think it is beneficial to see which libraries contribute which bits.
#[cfg(feature = "tracing")]
pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
// by default it will hit http://localhost:4317 with a gRPC payload
// TODO: I think the endpoint can be controlled by the OTEL_EXPORTER_OTLP_TRACES_ENDPOINT env variable instead of hard-coded into this code base. Regardless, I am the only developer right now so I am not too concerned.
let exporter = opentelemetry_otlp::new_exporter()
@ -55,17 +55,17 @@ pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
}
#[cfg(feature = "tracing")]
pub fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
opentelemetry::global::shutdown_tracer_provider();
Ok(())
}
#[cfg(not(feature = "tracing"))]
pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}
#[cfg(not(feature = "tracing"))]
pub fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}

18
src/lib.rs
View File

@ -6,20 +6,20 @@
#[cfg(feature = "compare")]
mod compare;
#[cfg(feature = "compare")]
pub use compare::compare_document;
use compare::compare_document;
#[cfg(feature = "compare")]
pub use compare::emacs_parse_anonymous_org_document;
use compare::emacs_parse_anonymous_org_document;
#[cfg(feature = "compare")]
pub use compare::emacs_parse_file_org_document;
use compare::emacs_parse_file_org_document;
#[cfg(feature = "compare")]
pub use compare::get_emacs_version;
use compare::get_emacs_version;
#[cfg(feature = "compare")]
pub use compare::get_org_mode_version;
use compare::get_org_mode_version;
mod context;
mod error;
pub mod parser;
pub mod types;
mod parser;
mod types;
pub use context::GlobalSettings;
pub use context::LocalFileAccessInterface;
use context::GlobalSettings;
use context::LocalFileAccessInterface;

2
src/parser/angle_link.rs
View File

@ -18,7 +18,7 @@ use crate::parser::util::get_consumed;
use crate::types::AngleLink;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn angle_link<'b, 'g, 'r, 's>(
fn angle_link<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, AngleLink<'s>> {

2
src/parser/citation.rs
View File

@ -31,7 +31,7 @@ use crate::types::Citation;
use crate::types::Object;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn citation<'b, 'g, 'r, 's>(
fn citation<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Citation<'s>> {

6
src/parser/citation_reference.rs
View File

@ -29,7 +29,7 @@ use crate::types::CitationReference;
use crate::types::Object;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn citation_reference<'b, 'g, 'r, 's>(
fn citation_reference<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, CitationReference<'s>> {
@ -49,7 +49,7 @@ pub fn citation_reference<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn citation_reference_key<'b, 'g, 'r, 's>(
fn citation_reference_key<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -161,7 +161,7 @@ fn _key_suffix_end<'b, 'g, 'r, 's>(
tag(";")(input)
}
pub fn must_balance_bracket<'s, F, O>(
fn must_balance_bracket<'s, F, O>(
mut inner: F,
) -> impl FnMut(OrgSource<'s>) -> Res<OrgSource<'s>, O>
where

2
src/parser/clock.rs
View File

@ -20,7 +20,7 @@ use crate::parser::util::start_of_line;
use crate::types::Clock;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn clock<'b, 'g, 'r, 's>(
fn clock<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Clock<'s>> {

4
src/parser/comment.rs
View File

@ -25,7 +25,7 @@ use crate::parser::util::start_of_line;
use crate::types::Comment;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn comment<'b, 'g, 'r, 's>(
fn comment<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Comment<'s>> {
@ -68,7 +68,7 @@ fn comment_line<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_comment<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn detect_comment<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
tuple((
start_of_line,
space0,

4
src/parser/diary_sexp.rs
View File

@ -13,7 +13,7 @@ use crate::parser::util::start_of_line;
use crate::types::DiarySexp;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn diary_sexp<'b, 'g, 'r, 's>(
fn diary_sexp<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, DiarySexp<'s>> {
@ -32,7 +32,7 @@ pub fn diary_sexp<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_diary_sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn detect_diary_sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
tuple((start_of_line, tag("%%(")))(input)?;
Ok((input, ()))
}

8
src/parser/document.rs
View File

@ -28,7 +28,7 @@ use crate::types::Object;
///
/// This is the main entry point for Organic. It will parse the full contents of the input string as an org-mode document.
#[allow(dead_code)]
pub fn parse<'s>(input: &'s str) -> Result<Document<'s>, String> {
fn parse<'s>(input: &'s str) -> Result<Document<'s>, String> {
parse_with_settings(input, &GlobalSettings::default())
}
@ -38,7 +38,7 @@ pub fn parse<'s>(input: &'s str) -> Result<Document<'s>, String> {
///
/// This will not prevent additional settings from being learned during parsing, for example when encountering a "#+TODO".
#[allow(dead_code)]
pub fn parse_with_settings<'g, 's>(
fn parse_with_settings<'g, 's>(
input: &'s str,
global_settings: &'g GlobalSettings<'g, 's>,
) -> Result<Document<'s>, String> {
@ -58,7 +58,7 @@ pub fn parse_with_settings<'g, 's>(
///
/// This will not prevent additional settings from being learned during parsing, for example when encountering a "#+TODO".
#[allow(dead_code)]
pub fn document<'b, 'g, 'r, 's>(
fn document<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: &'s str,
) -> Res<&'s str, Document<'s>> {
@ -157,7 +157,7 @@ fn _document<'b, 'g, 'r, 's>(
}
impl<'s> Document<'s> {
pub fn iter_tokens<'r>(&'r self) -> impl Iterator<Item = Token<'r, 's>> {
fn iter_tokens<'r>(&'r self) -> impl Iterator<Item = Token<'r, 's>> {
AllTokensIterator::new(Token::Document(self))
}
}

2
src/parser/drawer.rs
View File

@ -32,7 +32,7 @@ use crate::types::Paragraph;
use crate::types::SetSource;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn drawer<'b, 'g, 'r, 's>(
fn drawer<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Drawer<'s>> {

2
src/parser/dynamic_block.rs
View File

@ -32,7 +32,7 @@ use crate::types::Paragraph;
use crate::types::SetSource;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn dynamic_block<'b, 'g, 'r, 's>(
fn dynamic_block<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, DynamicBlock<'s>> {

4
src/parser/element_parser.rs
View File

@ -40,7 +40,7 @@ use crate::parser::table::org_mode_table;
use crate::types::Element;
use crate::types::SetSource;
pub const fn element(
const fn element(
can_be_paragraph: bool,
) -> impl for<'b, 'g, 'r, 's> Fn(
RefContext<'b, 'g, 'r, 's>,
@ -127,7 +127,7 @@ fn _element<'b, 'g, 'r, 's>(
Ok((remaining, element))
}
pub const fn detect_element(
const fn detect_element(
can_be_paragraph: bool,
) -> impl for<'b, 'g, 'r, 's> Fn(RefContext<'b, 'g, 'r, 's>, OrgSource<'s>) -> Res<OrgSource<'s>, ()>
{

2
src/parser/entity.rs
View File

@ -433,7 +433,7 @@ const ORG_ENTITIES: [&'static str; 413] = [
];
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn entity<'b, 'g, 'r, 's>(
fn entity<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Entity<'s>> {

2
src/parser/export_snippet.rs
View File

@ -20,7 +20,7 @@ use crate::parser::util::get_consumed;
use crate::types::ExportSnippet;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn export_snippet<'b, 'g, 'r, 's>(
fn export_snippet<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ExportSnippet<'s>> {

4
src/parser/fixed_width_area.rs
View File

@ -21,7 +21,7 @@ use crate::parser::util::start_of_line;
use crate::types::FixedWidthArea;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn fixed_width_area<'b, 'g, 'r, 's>(
fn fixed_width_area<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, FixedWidthArea<'s>> {
@ -57,7 +57,7 @@ fn fixed_width_area_line<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_fixed_width_area<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn detect_fixed_width_area<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
tuple((
start_of_line,
space0,

6
src/parser/footnote_definition.rs
View File

@ -33,7 +33,7 @@ use crate::parser::util::start_of_line;
use crate::types::FootnoteDefinition;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn footnote_definition<'b, 'g, 'r, 's>(
fn footnote_definition<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, FootnoteDefinition<'s>> {
@ -93,7 +93,7 @@ pub fn footnote_definition<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn label<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
fn label<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
alt((
digit1,
take_while(|c| WORD_CONSTITUENT_CHARACTERS.contains(c) || "-_".contains(c)),
@ -122,7 +122,7 @@ fn footnote_definition_end<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_footnote_definition<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn detect_footnote_definition<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
tuple((start_of_line, tag_no_case("[fn:"), label, tag("]")))(input)?;
Ok((input, ()))
}

2
src/parser/footnote_reference.rs
View File

@ -23,7 +23,7 @@ use crate::parser::util::get_consumed;
use crate::types::FootnoteReference;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn footnote_reference<'b, 'g, 'r, 's>(
fn footnote_reference<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, FootnoteReference<'s>> {

2
src/parser/greater_block.rs
View File

@ -33,7 +33,7 @@ use crate::types::Paragraph;
use crate::types::SetSource;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn greater_block<'b, 'g, 'r, 's>(
fn greater_block<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, GreaterBlock<'s>> {

4
src/parser/headline.rs
View File

@ -36,7 +36,7 @@ use crate::types::Object;
use crate::types::PriorityCookie;
use crate::types::TodoKeywordType;
pub const fn heading(
const fn heading(
parent_stars: usize,
) -> impl for<'b, 'g, 'r, 's> Fn(
RefContext<'b, 'g, 'r, 's>,
@ -95,7 +95,7 @@ fn _heading<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_headline<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn detect_headline<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
tuple((start_of_line, many1(tag("*")), space1))(input)?;
Ok((input, ()))
}

2
src/parser/horizontal_rule.rs
View File

@ -15,7 +15,7 @@ use crate::parser::util::start_of_line;
use crate::types::HorizontalRule;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn horizontal_rule<'b, 'g, 'r, 's>(
fn horizontal_rule<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, HorizontalRule<'s>> {

4
src/parser/in_buffer_settings.rs
View File

@ -13,7 +13,7 @@ use crate::types::Keyword;
use crate::GlobalSettings;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn scan_for_in_buffer_settings<'s>(
fn scan_for_in_buffer_settings<'s>(
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Vec<Keyword<'s>>> {
// TODO: Optimization idea: since this is slicing the OrgSource at each character, it might be more efficient to do a parser that uses a search function like take_until, and wrap it in a function similar to consumed but returning the input along with the normal output, then pass all of that into a verify that confirms we were at the start of a line using the input we just returned.
@ -44,7 +44,7 @@ fn in_buffer_settings_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSou
))(input)
}
pub fn apply_in_buffer_settings<'g, 's, 'sf>(
fn apply_in_buffer_settings<'g, 's, 'sf>(
keywords: Vec<Keyword<'sf>>,
original_settings: &'g GlobalSettings<'g, 's>,
) -> Result<GlobalSettings<'g, 's>, String> {

2
src/parser/inline_babel_call.rs
View File

@ -26,7 +26,7 @@ use crate::parser::util::get_consumed;
use crate::types::InlineBabelCall;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn inline_babel_call<'b, 'g, 'r, 's>(
fn inline_babel_call<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, InlineBabelCall<'s>> {

2
src/parser/inline_source_block.rs
View File

@ -28,7 +28,7 @@ use crate::parser::util::get_consumed;
use crate::types::InlineSourceBlock;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn inline_source_block<'b, 'g, 'r, 's>(
fn inline_source_block<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, InlineSourceBlock<'s>> {

10
src/parser/keyword.rs
View File

@ -31,7 +31,7 @@ const ORG_ELEMENT_AFFILIATED_KEYWORDS: [&'static str; 13] = [
];
const ORG_ELEMENT_DUAL_KEYWORDS: [&'static str; 2] = ["caption", "results"];
pub fn filtered_keyword<F: Matcher>(
fn filtered_keyword<F: Matcher>(
key_parser: F,
) -> impl for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, Keyword<'s>> {
move |input| _filtered_keyword(&key_parser, input)
@ -83,7 +83,7 @@ fn _filtered_keyword<'s, F: Matcher>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn keyword<'b, 'g, 'r, 's>(
fn keyword<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Keyword<'s>> {
@ -91,7 +91,7 @@ pub fn keyword<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn affiliated_keyword<'b, 'g, 'r, 's>(
fn affiliated_keyword<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Keyword<'s>> {
@ -99,7 +99,7 @@ pub fn affiliated_keyword<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn babel_call_keyword<'b, 'g, 'r, 's>(
fn babel_call_keyword<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Keyword<'s>> {
@ -112,7 +112,7 @@ fn babel_call_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn table_formula_keyword<'b, 'g, 'r, 's>(
fn table_formula_keyword<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Keyword<'s>> {

2
src/parser/keyword_todo.rs
View File

@ -19,7 +19,7 @@ use crate::error::Res;
/// Parses the text in the value of a #+TODO keyword.
///
/// Example input: "foo bar baz | lorem ipsum"
pub fn todo_keywords<'s>(input: &'s str) -> Res<&'s str, (Vec<&'s str>, Vec<&'s str>)> {
fn todo_keywords<'s>(input: &'s str) -> Res<&'s str, (Vec<&'s str>, Vec<&'s str>)> {
let (remaining, mut before_pipe_words) = separated_list0(space1, todo_keyword_word)(input)?;
let (remaining, after_pipe_words) = opt(tuple((
tuple((space0, tag("|"), space0)),

2
src/parser/latex_environment.rs
View File

@ -25,7 +25,7 @@ use crate::parser::util::start_of_line;
use crate::types::LatexEnvironment;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn latex_environment<'b, 'g, 'r, 's>(
fn latex_environment<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, LatexEnvironment<'s>> {

10
src/parser/latex_fragment.rs
View File

@ -24,7 +24,7 @@ use crate::parser::util::get_consumed;
use crate::types::LatexFragment;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn latex_fragment<'b, 'g, 'r, 's>(
fn latex_fragment<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, LatexFragment<'s>> {
@ -174,7 +174,7 @@ fn dollar_char_fragment<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn pre<'b, 'g, 'r, 's>(
fn pre<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
@ -188,7 +188,7 @@ pub fn pre<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn post<'b, 'g, 'r, 's>(
fn post<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
@ -226,7 +226,7 @@ fn bordered_dollar_fragment<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn open_border<'b, 'g, 'r, 's>(
fn open_border<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -234,7 +234,7 @@ pub fn open_border<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn close_border<'b, 'g, 'r, 's>(
fn close_border<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {

10
src/parser/lesser_block.rs
View File

@ -35,7 +35,7 @@ use crate::types::SrcBlock;
use crate::types::VerseBlock;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn verse_block<'b, 'g, 'r, 's>(
fn verse_block<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, VerseBlock<'s>> {
@ -90,7 +90,7 @@ pub fn verse_block<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn comment_block<'b, 'g, 'r, 's>(
fn comment_block<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, CommentBlock<'s>> {
@ -130,7 +130,7 @@ pub fn comment_block<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn example_block<'b, 'g, 'r, 's>(
fn example_block<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ExampleBlock<'s>> {
@ -170,7 +170,7 @@ pub fn example_block<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn export_block<'b, 'g, 'r, 's>(
fn export_block<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ExportBlock<'s>> {
@ -211,7 +211,7 @@ pub fn export_block<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn src_block<'b, 'g, 'r, 's>(
fn src_block<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, SrcBlock<'s>> {

2
src/parser/line_break.rs
View File

@ -13,7 +13,7 @@ use crate::parser::util::get_consumed;
use crate::types::LineBreak;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn line_break<'b, 'g, 'r, 's>(
fn line_break<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, LineBreak<'s>> {

10
src/parser/mod.rs
View File

@ -37,7 +37,7 @@ mod property_drawer;
mod radio_link;
mod regular_link;
mod section;
pub mod sexp;
mod sexp;
mod statistics_cookie;
mod subscript_and_superscript;
mod table;
@ -46,7 +46,7 @@ mod text_markup;
mod timestamp;
mod token;
mod util;
pub use document::document;
pub use document::parse;
pub use document::parse_with_settings;
pub use org_source::OrgSource;
use document::document;
use document::parse;
use document::parse_with_settings;
use org_source::OrgSource;

16
src/parser/object_parser.rs
View File

@ -32,7 +32,7 @@ use crate::parser::timestamp::timestamp;
use crate::types::Object;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn standard_set_object<'b, 'g, 'r, 's>(
fn standard_set_object<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
@ -47,7 +47,7 @@ pub fn standard_set_object<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn minimal_set_object<'b, 'g, 'r, 's>(
fn minimal_set_object<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
@ -140,7 +140,7 @@ fn minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
@ -174,7 +174,7 @@ fn detect_minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn regular_link_description_set_object<'b, 'g, 'r, 's>(
fn regular_link_description_set_object<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
@ -221,7 +221,7 @@ fn regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
@ -238,7 +238,7 @@ pub fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn table_cell_set_object<'b, 'g, 'r, 's>(
fn table_cell_set_object<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
@ -253,7 +253,7 @@ pub fn table_cell_set_object<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
@ -287,7 +287,7 @@ pub fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
fn detect_table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {

2
src/parser/org_macro.rs
View File

@ -18,7 +18,7 @@ use crate::parser::util::get_consumed;
use crate::types::OrgMacro;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn org_macro<'b, 'g, 'r, 's>(
fn org_macro<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgMacro<'s>> {

24
src/parser/org_source.rs
View File

@ -11,10 +11,10 @@ use nom::Slice;
use crate::error::CustomError;
use crate::error::MyError;
pub type BracketDepth = i16;
type BracketDepth = i16;
#[derive(Copy, Clone)]
pub struct OrgSource<'s> {
struct OrgSource<'s> {
full_source: &'s str,
start: usize,
end: usize, // exclusive
@ -37,7 +37,7 @@ impl<'s> OrgSource<'s> {
/// Returns a wrapped string that keeps track of values we need for parsing org-mode.
///
/// Only call this on the full original string. Calling this on a substring can result in invalid values.
pub fn new(input: &'s str) -> Self {
fn new(input: &'s str) -> Self {
OrgSource {
full_source: input,
start: 0,
@ -51,37 +51,37 @@ impl<'s> OrgSource<'s> {
}
/// Get the text since the line break preceding the start of this WrappedInput.
pub fn text_since_line_break(&self) -> &'s str {
fn text_since_line_break(&self) -> &'s str {
&self.full_source[self.start_of_line..self.start]
}
pub fn len(&self) -> usize {
fn len(&self) -> usize {
self.end - self.start
}
pub fn get_preceding_character(&self) -> Option<char> {
fn get_preceding_character(&self) -> Option<char> {
self.preceding_character
}
pub fn is_at_start_of_line(&self) -> bool {
fn is_at_start_of_line(&self) -> bool {
self.start == self.start_of_line
}
pub fn get_until(&self, other: OrgSource<'s>) -> OrgSource<'s> {
fn get_until(&self, other: OrgSource<'s>) -> OrgSource<'s> {
assert!(other.start >= self.start);
assert!(other.end <= self.end);
self.slice(..(other.start - self.start))
}
pub fn get_bracket_depth(&self) -> BracketDepth {
fn get_bracket_depth(&self) -> BracketDepth {
self.bracket_depth
}
pub fn get_brace_depth(&self) -> BracketDepth {
fn get_brace_depth(&self) -> BracketDepth {
self.brace_depth
}
pub fn get_parenthesis_depth(&self) -> BracketDepth {
fn get_parenthesis_depth(&self) -> BracketDepth {
self.parenthesis_depth
}
}
@ -306,7 +306,7 @@ impl<'s> InputTakeAtPosition for OrgSource<'s> {
}
}
pub fn convert_error<'a, I: Into<CustomError<&'a str>>>(
fn convert_error<'a, I: Into<CustomError<&'a str>>>(
err: nom::Err<I>,
) -> nom::Err<CustomError<&'a str>> {
match err {

2
src/parser/paragraph.rs
View File

@ -22,7 +22,7 @@ use crate::parser::util::start_of_line;
use crate::types::Paragraph;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn paragraph<'b, 'g, 'r, 's>(
fn paragraph<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Paragraph<'s>> {

4
src/parser/plain_link.rs
View File

@ -53,7 +53,7 @@ const ORG_LINK_PARAMETERS: [&'static str; 23] = [
];
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn plain_link<'b, 'g, 'r, 's>(
fn plain_link<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, PlainLink<'s>> {
@ -105,7 +105,7 @@ fn post<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn protocol<'b, 'g, 'r, 's>(
fn protocol<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {

6
src/parser/plain_list.rs
View File

@ -41,7 +41,7 @@ use crate::types::PlainList;
use crate::types::PlainListItem;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_plain_list<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn detect_plain_list<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
if verify(
tuple((
start_of_line,
@ -63,7 +63,7 @@ pub fn detect_plain_list<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn plain_list<'b, 'g, 'r, 's>(
fn plain_list<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, PlainList<'s>> {
@ -137,7 +137,7 @@ pub fn plain_list<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn plain_list_item<'b, 'g, 'r, 's>(
fn plain_list_item<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, PlainListItem<'s>> {

2
src/parser/plain_text.rs
View File

@ -16,7 +16,7 @@ use crate::error::Res;
use crate::types::Object;
use crate::types::PlainText;
pub fn plain_text<F>(
fn plain_text<F>(
end_condition: F,
) -> impl for<'b, 'g, 'r, 's> Fn(
RefContext<'b, 'g, 'r, 's>,

2
src/parser/planning.rs
View File

@ -18,7 +18,7 @@ use crate::parser::util::start_of_line;
use crate::types::Planning;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn planning<'b, 'g, 'r, 's>(
fn planning<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Planning<'s>> {

2
src/parser/property_drawer.rs
View File

@ -31,7 +31,7 @@ use crate::types::NodeProperty;
use crate::types::PropertyDrawer;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn property_drawer<'b, 'g, 'r, 's>(
fn property_drawer<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, PropertyDrawer<'s>> {

8
src/parser/radio_link.rs
View File

@ -23,7 +23,7 @@ use crate::types::RadioLink;
use crate::types::RadioTarget;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn radio_link<'b, 'g, 'r, 's>(
fn radio_link<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, RadioLink<'s>> {
@ -47,7 +47,7 @@ pub fn radio_link<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn rematch_target<'x, 'b, 'g, 'r, 's>(
fn rematch_target<'x, 'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
target: &'x Vec<Object<'x>>,
input: OrgSource<'s>,
@ -78,7 +78,7 @@ pub fn rematch_target<'x, 'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn radio_target<'b, 'g, 'r, 's>(
fn radio_target<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, RadioTarget<'s>> {
@ -118,7 +118,7 @@ fn radio_target_end<'b, 'g, 'r, 's>(
alt((tag("<"), tag(">"), line_ending))(input)
}
pub trait RematchObject<'x> {
trait RematchObject<'x> {
fn rematch_object<'b, 'g, 'r, 's>(
&'x self,
context: RefContext<'b, 'g, 'r, 's>,

10
src/parser/regular_link.rs
View File

@ -21,7 +21,7 @@ use crate::types::Object;
use crate::types::RegularLink;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn regular_link<'b, 'g, 'r, 's>(
fn regular_link<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, RegularLink<'s>> {
@ -32,7 +32,7 @@ pub fn regular_link<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn regular_link_without_description<'b, 'g, 'r, 's>(
fn regular_link_without_description<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, RegularLink<'s>> {
@ -51,7 +51,7 @@ pub fn regular_link_without_description<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn regular_link_with_description<'b, 'g, 'r, 's>(
fn regular_link_with_description<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, RegularLink<'s>> {
@ -72,7 +72,7 @@ pub fn regular_link_with_description<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn pathreg<'b, 'g, 'r, 's>(
fn pathreg<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -88,7 +88,7 @@ pub fn pathreg<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn description<'b, 'g, 'r, 's>(
fn description<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Vec<Object<'s>>> {

4
src/parser/section.rs
View File

@ -25,7 +25,7 @@ use crate::types::Element;
use crate::types::Section;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn zeroth_section<'b, 'g, 'r, 's>(
fn zeroth_section<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Section<'s>> {
@ -83,7 +83,7 @@ pub fn zeroth_section<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn section<'b, 'g, 'r, 's>(
fn section<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
mut input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Section<'s>> {

24
src/parser/sexp.rs
View File

@ -22,7 +22,7 @@ use super::util::get_consumed;
use crate::error::Res;
#[derive(Debug)]
pub enum Token<'s> {
enum Token<'s> {
Atom(&'s str),
List(Vec<Token<'s>>),
TextWithProperties(TextWithProperties<'s>),
@ -30,9 +30,9 @@ pub enum Token<'s> {
}
#[derive(Debug)]
pub struct TextWithProperties<'s> {
pub text: &'s str,
pub properties: Vec<Token<'s>>,
struct TextWithProperties<'s> {
text: &'s str,
properties: Vec<Token<'s>>,
}
enum ParseState {
@ -41,35 +41,35 @@ enum ParseState {
}
impl<'s> Token<'s> {
pub fn as_vector<'p>(&'p self) -> Result<&'p Vec<Token<'s>>, Box<dyn std::error::Error>> {
fn as_vector<'p>(&'p self) -> Result<&'p Vec<Token<'s>>, Box<dyn std::error::Error>> {
Ok(match self {
Token::Vector(children) => Ok(children),
_ => Err(format!("wrong token type, expected vector: {:?}", self)),
}?)
}
pub fn as_list<'p>(&'p self) -> Result<&'p Vec<Token<'s>>, Box<dyn std::error::Error>> {
fn as_list<'p>(&'p self) -> Result<&'p Vec<Token<'s>>, Box<dyn std::error::Error>> {
Ok(match self {
Token::List(children) => Ok(children),
_ => Err(format!("wrong token type, expected list: {:?}", self)),
}?)
}
pub fn as_atom<'p>(&'p self) -> Result<&'s str, Box<dyn std::error::Error>> {
fn as_atom<'p>(&'p self) -> Result<&'s str, Box<dyn std::error::Error>> {
Ok(match self {
Token::Atom(body) => Ok(*body),
_ => Err(format!("wrong token type, expected atom: {:?}", self)),
}?)
}
pub fn as_text<'p>(&'p self) -> Result<&'p TextWithProperties<'s>, Box<dyn std::error::Error>> {
fn as_text<'p>(&'p self) -> Result<&'p TextWithProperties<'s>, Box<dyn std::error::Error>> {
Ok(match self {
Token::TextWithProperties(body) => Ok(body),
_ => Err(format!("wrong token type, expected text: {:?}", self)),
}?)
}
pub fn as_map<'p>(
fn as_map<'p>(
&'p self,
) -> Result<HashMap<&'s str, &'p Token<'s>>, Box<dyn std::error::Error>> {
let mut hashmap = HashMap::new();
@ -95,7 +95,7 @@ impl<'s> Token<'s> {
}
}
pub fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
let mut out = String::with_capacity(text.len());
if !text.starts_with(r#"""#) {
return Err("Quoted text does not start with quote.".into());
@ -132,7 +132,7 @@ pub fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn sexp_with_padding<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
fn sexp_with_padding<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
let (remaining, _) = multispace0(input)?;
let remaining = OrgSource::new(remaining);
let (remaining, tkn) = token(remaining)
@ -143,7 +143,7 @@ pub fn sexp_with_padding<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
fn sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
let (remaining, tkn) = token(input)?;
Ok((remaining, tkn))
}

6
src/parser/statistics_cookie.rs
View File

@ -13,7 +13,7 @@ use crate::error::Res;
use crate::types::StatisticsCookie;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn statistics_cookie<'b, 'g, 'r, 's>(
fn statistics_cookie<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, StatisticsCookie<'s>> {
@ -24,7 +24,7 @@ pub fn statistics_cookie<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn percent_statistics_cookie<'b, 'g, 'r, 's>(
fn percent_statistics_cookie<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, StatisticsCookie<'s>> {
@ -45,7 +45,7 @@ pub fn percent_statistics_cookie<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn fraction_statistics_cookie<'b, 'g, 'r, 's>(
fn fraction_statistics_cookie<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, StatisticsCookie<'s>> {

6
src/parser/subscript_and_superscript.rs
View File

@ -33,7 +33,7 @@ use crate::types::Subscript;
use crate::types::Superscript;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
// This does not have to detect all valid subscript/superscript but all that it detects must be valid.
let (remaining, _) = one_of("_^")(input)?;
pre(input)?;
@ -46,7 +46,7 @@ pub fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<OrgSourc
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn subscript<'b, 'g, 'r, 's>(
fn subscript<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Subscript<'s>> {
@ -66,7 +66,7 @@ pub fn subscript<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn superscript<'b, 'g, 'r, 's>(
fn superscript<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Superscript<'s>> {

12
src/parser/table.rs
View File

@ -33,7 +33,7 @@ use crate::types::TableRow;
///
/// This is not the table.el style.
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn org_mode_table<'b, 'g, 'r, 's>(
fn org_mode_table<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Table<'s>> {
@ -74,7 +74,7 @@ pub fn org_mode_table<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn detect_table<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn detect_table<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
tuple((start_of_line, space0, tag("|")))(input)?;
Ok((input, ()))
}
@ -89,7 +89,7 @@ fn table_end<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn org_mode_table_row<'b, 'g, 'r, 's>(
fn org_mode_table_row<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, TableRow<'s>> {
@ -100,7 +100,7 @@ pub fn org_mode_table_row<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, TableRow<'s>> {
@ -117,7 +117,7 @@ pub fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, TableRow<'s>> {
@ -137,7 +137,7 @@ pub fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn org_mode_table_cell<'b, 'g, 'r, 's>(
fn org_mode_table_cell<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, TableCell<'s>> {

2
src/parser/target.rs
View File

@ -21,7 +21,7 @@ use crate::parser::util::get_consumed;
use crate::types::Target;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn target<'b, 'g, 'r, 's>(
fn target<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Target<'s>> {

18
src/parser/text_markup.rs
View File

@ -42,7 +42,7 @@ use crate::types::Underline;
use crate::types::Verbatim;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn text_markup<'b, 'g, 'r, 's>(
fn text_markup<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
@ -60,7 +60,7 @@ pub fn text_markup<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn bold<'b, 'g, 'r, 's>(
fn bold<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Bold<'s>> {
@ -77,7 +77,7 @@ pub fn bold<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn italic<'b, 'g, 'r, 's>(
fn italic<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Italic<'s>> {
@ -94,7 +94,7 @@ pub fn italic<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn underline<'b, 'g, 'r, 's>(
fn underline<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Underline<'s>> {
@ -111,7 +111,7 @@ pub fn underline<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn strike_through<'b, 'g, 'r, 's>(
fn strike_through<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, StrikeThrough<'s>> {
@ -128,7 +128,7 @@ pub fn strike_through<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn verbatim<'b, 'g, 'r, 's>(
fn verbatim<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Verbatim<'s>> {
@ -145,7 +145,7 @@ pub fn verbatim<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn code<'b, 'g, 'r, 's>(
fn code<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Code<'s>> {
@ -288,7 +288,7 @@ fn _text_markup_string<'b, 'g, 'r, 's, 'c>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn pre<'b, 'g, 'r, 's>(
fn pre<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
@ -307,7 +307,7 @@ pub fn pre<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn post<'b, 'g, 'r, 's>(
fn post<'b, 'g, 'r, 's>(
_context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {

2
src/parser/timestamp.rs
View File

@ -23,7 +23,7 @@ use crate::parser::util::get_consumed;
use crate::types::Timestamp;
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn timestamp<'b, 'g, 'r, 's>(
fn timestamp<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Timestamp<'s>> {

8
src/parser/token.rs
View File

@ -11,7 +11,7 @@ use crate::types::Section;
use crate::types::TableCell;
use crate::types::TableRow;
pub enum Token<'r, 's> {
enum Token<'r, 's> {
Document(&'r Document<'s>),
Heading(&'r Heading<'s>),
Section(&'r Section<'s>),
@ -24,7 +24,7 @@ pub enum Token<'r, 's> {
}
impl<'r, 's> Token<'r, 's> {
pub fn iter_tokens(&self) -> Box<dyn Iterator<Item = Token<'r, 's>> + '_> {
fn iter_tokens(&self) -> Box<dyn Iterator<Item = Token<'r, 's>> + '_> {
match self {
Token::Document(document) => Box::new(
document
@ -109,12 +109,12 @@ impl<'r, 's> Token<'r, 's> {
}
}
pub struct AllTokensIterator<'r, 's> {
struct AllTokensIterator<'r, 's> {
queued_tokens: VecDeque<Token<'r, 's>>,
}
impl<'r, 's> AllTokensIterator<'r, 's> {
pub fn new(tkn: Token<'r, 's>) -> Self {
fn new(tkn: Token<'r, 's>) -> Self {
let mut queued_tokens = VecDeque::new();
queued_tokens.push_back(tkn);
AllTokensIterator { queued_tokens }

36
src/parser/util.rs
View File

@ -21,11 +21,11 @@ use crate::error::CustomError;
use crate::error::MyError;
use crate::error::Res;
pub const WORD_CONSTITUENT_CHARACTERS: &str =
const WORD_CONSTITUENT_CHARACTERS: &str =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
/// Check if we are below a section of the given section type regardless of depth
pub fn in_section<'b, 'g, 'r, 's, 'x>(
fn in_section<'b, 'g, 'r, 's, 'x>(
context: RefContext<'b, 'g, 'r, 's>,
section_name: &'x str,
) -> bool {
@ -39,7 +39,7 @@ pub fn in_section<'b, 'g, 'r, 's, 'x>(
}
/// Checks if we are currently an immediate child of the given section type
pub fn immediate_in_section<'b, 'g, 'r, 's, 'x>(
fn immediate_in_section<'b, 'g, 'r, 's, 'x>(
context: RefContext<'b, 'g, 'r, 's>,
section_name: &'x str,
) -> bool {
@ -54,7 +54,7 @@ pub fn immediate_in_section<'b, 'g, 'r, 's, 'x>(
}
/// Check if we are below a section of the given section type regardless of depth
pub fn in_object_section<'b, 'g, 'r, 's, 'x>(
fn in_object_section<'b, 'g, 'r, 's, 'x>(
context: RefContext<'b, 'g, 'r, 's>,
section_name: &'x str,
) -> bool {
@ -68,7 +68,7 @@ pub fn in_object_section<'b, 'g, 'r, 's, 'x>(
}
/// Get a slice of the string that was consumed in a parser using the original input to the parser and the remaining input after the parser.
pub fn get_consumed<'s>(input: OrgSource<'s>, remaining: OrgSource<'s>) -> OrgSource<'s> {
fn get_consumed<'s>(input: OrgSource<'s>, remaining: OrgSource<'s>) -> OrgSource<'s> {
input.get_until(remaining)
}
@ -76,19 +76,19 @@ pub fn get_consumed<'s>(input: OrgSource<'s>, remaining: OrgSource<'s>) -> OrgSo
///
/// It is up to the caller to ensure this is called at the start of a line.
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn blank_line(input: OrgSource<'_>) -> Res<OrgSource<'_>, OrgSource<'_>> {
fn blank_line(input: OrgSource<'_>) -> Res<OrgSource<'_>, OrgSource<'_>> {
not(eof)(input)?;
recognize(tuple((space0, alt((line_ending, eof)))))(input)
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn element_trailing_whitespace<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
fn element_trailing_whitespace<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
start_of_line(input)?;
alt((eof, recognize(many0(blank_line))))(input)
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Option<OrgSource<'s>>> {
@ -104,7 +104,7 @@ pub fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Option<OrgSource<'s>>> {
@ -117,7 +117,7 @@ pub fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn maybe_consume_trailing_whitespace<'b, 'g, 'r, 's>(
fn maybe_consume_trailing_whitespace<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Option<OrgSource<'s>>> {
@ -130,7 +130,7 @@ pub fn maybe_consume_trailing_whitespace<'b, 'g, 'r, 's>(
/// Check that we are at the start of a line
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn start_of_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
fn start_of_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
if input.is_at_start_of_line() {
Ok((input, ()))
} else {
@ -140,7 +140,7 @@ pub fn start_of_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
}
}
pub fn preceded_by_whitespace(
fn preceded_by_whitespace(
allow_start_of_file: bool,
) -> impl for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
move |input| _preceded_by_whitespace(allow_start_of_file, input)
@ -168,13 +168,13 @@ fn _preceded_by_whitespace<'s>(
///
/// This function only operates on spaces, tabs, carriage returns, and line feeds. It does not handle fancy unicode whitespace.
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn non_whitespace_character(input: OrgSource<'_>) -> Res<OrgSource<'_>, char> {
fn non_whitespace_character(input: OrgSource<'_>) -> Res<OrgSource<'_>, char> {
none_of(" \t\r\n")(input)
}
/// Check that we are at the start of a line
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn exit_matcher_parser<'b, 'g, 'r, 's>(
fn exit_matcher_parser<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -182,7 +182,7 @@ pub fn exit_matcher_parser<'b, 'g, 'r, 's>(
}
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn text_until_exit<'b, 'g, 'r, 's>(
fn text_until_exit<'b, 'g, 'r, 's>(
context: RefContext<'b, 'g, 'r, 's>,
input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -193,7 +193,7 @@ pub fn text_until_exit<'b, 'g, 'r, 's>(
}
#[allow(dead_code)]
pub fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
return Err(nom::Err::Error(CustomError::MyError(MyError(
"Not implemented yet.".into(),
))));
@ -204,7 +204,7 @@ pub fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
/// Text from the current point until the next line break or end of file
///
/// Useful for debugging.
pub fn text_until_eol<'r, 's>(
fn text_until_eol<'r, 's>(
input: OrgSource<'s>,
) -> Result<&'s str, nom::Err<CustomError<OrgSource<'s>>>> {
let line = recognize(many_till(anychar, alt((line_ending, eof))))(input)
@ -212,7 +212,7 @@ pub fn text_until_eol<'r, 's>(
Ok(line.trim())
}
pub fn include_input<'s, F, O>(
fn include_input<'s, F, O>(
mut inner: F,
) -> impl FnMut(OrgSource<'s>) -> Res<OrgSource<'s>, (OrgSource<'s>, O)>
where

40
src/types/document.rs
View File

@ -2,42 +2,42 @@ use super::Element;
use super::Object;
use super::Source;
pub type PriorityCookie = u8;
type PriorityCookie = u8;
#[derive(Debug)]
pub struct Document<'s> {
pub source: &'s str,
pub zeroth_section: Option<Section<'s>>,
pub children: Vec<Heading<'s>>,
struct Document<'s> {
source: &'s str,
zeroth_section: Option<Section<'s>>,
children: Vec<Heading<'s>>,
}
#[derive(Debug)]
pub struct Heading<'s> {
pub source: &'s str,
pub stars: usize,
pub todo_keyword: Option<(TodoKeywordType, &'s str)>,
pub priority_cookie: Option<PriorityCookie>,
pub title: Vec<Object<'s>>,
pub tags: Vec<&'s str>,
pub children: Vec<DocumentElement<'s>>,
pub is_comment: bool,
pub is_archived: bool,
struct Heading<'s> {
source: &'s str,
stars: usize,
todo_keyword: Option<(TodoKeywordType, &'s str)>,
priority_cookie: Option<PriorityCookie>,
title: Vec<Object<'s>>,
tags: Vec<&'s str>,
children: Vec<DocumentElement<'s>>,
is_comment: bool,
is_archived: bool,
}
#[derive(Debug)]
pub struct Section<'s> {
pub source: &'s str,
pub children: Vec<Element<'s>>,
struct Section<'s> {
source: &'s str,
children: Vec<Element<'s>>,
}
#[derive(Debug)]
pub enum DocumentElement<'s> {
enum DocumentElement<'s> {
Heading(Heading<'s>),
Section(Section<'s>),
}
#[derive(Debug)]
pub enum TodoKeywordType {
enum TodoKeywordType {
Todo,
Done,
}

2
src/types/element.rs
View File

@ -23,7 +23,7 @@ use super::SetSource;
use super::Source;
#[derive(Debug)]
pub enum Element<'s> {
enum Element<'s> {
Paragraph(Paragraph<'s>),
PlainList(PlainList<'s>),
GreaterBlock(GreaterBlock<'s>),

80
src/types/greater_element.rs
View File

@ -5,73 +5,73 @@ use super::Object;
use super::Source;
#[derive(Debug)]
pub struct PlainList<'s> {
pub source: &'s str,
pub children: Vec<PlainListItem<'s>>,
struct PlainList<'s> {
source: &'s str,
children: Vec<PlainListItem<'s>>,
}
#[derive(Debug)]
pub struct PlainListItem<'s> {
pub source: &'s str,
pub indentation: usize,
pub bullet: &'s str,
pub tag: Vec<Object<'s>>,
pub children: Vec<Element<'s>>,
struct PlainListItem<'s> {
source: &'s str,
indentation: usize,
bullet: &'s str,
tag: Vec<Object<'s>>,
children: Vec<Element<'s>>,
}
#[derive(Debug)]
pub struct GreaterBlock<'s> {
pub source: &'s str,
pub name: &'s str,
pub parameters: Option<&'s str>,
pub children: Vec<Element<'s>>,
struct GreaterBlock<'s> {
source: &'s str,
name: &'s str,
parameters: Option<&'s str>,
children: Vec<Element<'s>>,
}
#[derive(Debug)]
pub struct DynamicBlock<'s> {
pub source: &'s str,
pub name: &'s str,
pub parameters: Option<&'s str>,
pub children: Vec<Element<'s>>,
struct DynamicBlock<'s> {
source: &'s str,
name: &'s str,
parameters: Option<&'s str>,
children: Vec<Element<'s>>,
}
#[derive(Debug)]
pub struct FootnoteDefinition<'s> {
pub source: &'s str,
pub label: &'s str,
pub children: Vec<Element<'s>>,
struct FootnoteDefinition<'s> {
source: &'s str,
label: &'s str,
children: Vec<Element<'s>>,
}
#[derive(Debug)]
pub struct Drawer<'s> {
pub source: &'s str,
pub name: &'s str,
pub children: Vec<Element<'s>>,
struct Drawer<'s> {
source: &'s str,
name: &'s str,
children: Vec<Element<'s>>,
}
#[derive(Debug)]
pub struct PropertyDrawer<'s> {
pub source: &'s str,
pub children: Vec<NodeProperty<'s>>,
struct PropertyDrawer<'s> {
source: &'s str,
children: Vec<NodeProperty<'s>>,
}
#[derive(Debug)]
pub struct NodeProperty<'s> {
pub source: &'s str,
pub value: Option<&'s str>,
struct NodeProperty<'s> {
source: &'s str,
value: Option<&'s str>,
}
#[derive(Debug)]
pub struct Table<'s> {
pub source: &'s str,
pub formulas: Vec<Keyword<'s>>,
pub children: Vec<TableRow<'s>>,
struct Table<'s> {
source: &'s str,
formulas: Vec<Keyword<'s>>,
children: Vec<TableRow<'s>>,
}
#[derive(Debug)]
pub struct TableRow<'s> {
pub source: &'s str,
pub children: Vec<TableCell<'s>>,
struct TableRow<'s> {
source: &'s str,
children: Vec<TableCell<'s>>,
}
impl<'s> Source<'s> for PlainList<'s> {

100
src/types/lesser_element.rs
View File

@ -3,101 +3,101 @@ use super::PlainText;
use super::Source;
#[derive(Debug)]
pub struct Paragraph<'s> {
pub source: &'s str,
pub children: Vec<Object<'s>>,
struct Paragraph<'s> {
source: &'s str,
children: Vec<Object<'s>>,
}
#[derive(Debug)]
pub struct Comment<'s> {
pub source: &'s str,
struct Comment<'s> {
source: &'s str,
}
#[derive(Debug)]
pub struct TableCell<'s> {
pub source: &'s str,
pub children: Vec<Object<'s>>,
struct TableCell<'s> {
source: &'s str,
children: Vec<Object<'s>>,
}
#[derive(Debug)]
pub struct VerseBlock<'s> {
pub source: &'s str,
pub name: &'s str,
pub data: Option<&'s str>,
pub children: Vec<Object<'s>>,
struct VerseBlock<'s> {
source: &'s str,
name: &'s str,
data: Option<&'s str>,
children: Vec<Object<'s>>,
}
#[derive(Debug)]
pub struct CommentBlock<'s> {
pub source: &'s str,
pub name: &'s str,
pub data: Option<&'s str>,
pub contents: &'s str,
struct CommentBlock<'s> {
source: &'s str,
name: &'s str,
data: Option<&'s str>,
contents: &'s str,
}
#[derive(Debug)]
pub struct ExampleBlock<'s> {
pub source: &'s str,
pub name: &'s str,
pub data: Option<&'s str>,
pub contents: &'s str,
struct ExampleBlock<'s> {
source: &'s str,
name: &'s str,
data: Option<&'s str>,
contents: &'s str,
}
#[derive(Debug)]
pub struct ExportBlock<'s> {
pub source: &'s str,
pub name: &'s str,
pub data: Option<&'s str>,
pub contents: &'s str,
struct ExportBlock<'s> {
source: &'s str,
name: &'s str,
data: Option<&'s str>,
contents: &'s str,
}
#[derive(Debug)]
pub struct SrcBlock<'s> {
pub source: &'s str,
pub name: &'s str,
pub data: Option<&'s str>,
pub contents: &'s str,
struct SrcBlock<'s> {
source: &'s str,
name: &'s str,
data: Option<&'s str>,
contents: &'s str,
}
#[derive(Debug)]
pub struct Clock<'s> {
pub source: &'s str,
struct Clock<'s> {
source: &'s str,
}
#[derive(Debug)]
pub struct DiarySexp<'s> {
pub source: &'s str,
struct DiarySexp<'s> {
source: &'s str,
}
#[derive(Debug)]
pub struct Planning<'s> {
pub source: &'s str,
struct Planning<'s> {
source: &'s str,
}
#[derive(Debug)]
pub struct FixedWidthArea<'s> {
pub source: &'s str,
struct FixedWidthArea<'s> {
source: &'s str,
}
#[derive(Debug)]
pub struct HorizontalRule<'s> {
pub source: &'s str,
struct HorizontalRule<'s> {
source: &'s str,
}
#[derive(Debug)]
pub struct Keyword<'s> {
pub source: &'s str,
pub key: &'s str,
pub value: &'s str,
struct Keyword<'s> {
source: &'s str,
key: &'s str,
value: &'s str,
}
#[derive(Debug)]
pub struct LatexEnvironment<'s> {
pub source: &'s str,
struct LatexEnvironment<'s> {
source: &'s str,
}
impl<'s> Paragraph<'s> {
pub fn of_text(input: &'s str) -> Self {
fn of_text(input: &'s str) -> Self {
let mut objects = Vec::with_capacity(1);
objects.push(Object::PlainText(PlainText { source: input }));
Paragraph {

124
src/types/mod.rs
View File

@ -4,65 +4,65 @@ mod greater_element;
mod lesser_element;
mod object;
mod source;
pub use document::Document;
pub use document::DocumentElement;
pub use document::Heading;
pub use document::PriorityCookie;
pub use document::Section;
pub use document::TodoKeywordType;
pub use element::Element;
pub use greater_element::Drawer;
pub use greater_element::DynamicBlock;
pub use greater_element::FootnoteDefinition;
pub use greater_element::GreaterBlock;
pub use greater_element::NodeProperty;
pub use greater_element::PlainList;
pub use greater_element::PlainListItem;
pub use greater_element::PropertyDrawer;
pub use greater_element::Table;
pub use greater_element::TableRow;
pub use lesser_element::Clock;
pub use lesser_element::Comment;
pub use lesser_element::CommentBlock;
pub use lesser_element::DiarySexp;
pub use lesser_element::ExampleBlock;
pub use lesser_element::ExportBlock;
pub use lesser_element::FixedWidthArea;
pub use lesser_element::HorizontalRule;
pub use lesser_element::Keyword;
pub use lesser_element::LatexEnvironment;
pub use lesser_element::Paragraph;
pub use lesser_element::Planning;
pub use lesser_element::SrcBlock;
pub use lesser_element::TableCell;
pub use lesser_element::VerseBlock;
pub use object::AngleLink;
pub use object::Bold;
pub use object::Citation;
pub use object::CitationReference;
pub use object::Code;
pub use object::Entity;
pub use object::ExportSnippet;
pub use object::FootnoteReference;
pub use object::InlineBabelCall;
pub use object::InlineSourceBlock;
pub use object::Italic;
pub use object::LatexFragment;
pub use object::LineBreak;
pub use object::Object;
pub use object::OrgMacro;
pub use object::PlainLink;
pub use object::PlainText;
pub use object::RadioLink;
pub use object::RadioTarget;
pub use object::RegularLink;
pub use object::StatisticsCookie;
pub use object::StrikeThrough;
pub use object::Subscript;
pub use object::Superscript;
pub use object::Target;
pub use object::Timestamp;
pub use object::Underline;
pub use object::Verbatim;
pub use source::SetSource;
pub use source::Source;
use document::Document;
use document::DocumentElement;
use document::Heading;
use document::PriorityCookie;
use document::Section;
use document::TodoKeywordType;
use element::Element;
use greater_element::Drawer;
use greater_element::DynamicBlock;
use greater_element::FootnoteDefinition;
use greater_element::GreaterBlock;
use greater_element::NodeProperty;
use greater_element::PlainList;
use greater_element::PlainListItem;
use greater_element::PropertyDrawer;
use greater_element::Table;
use greater_element::TableRow;
use lesser_element::Clock;
use lesser_element::Comment;
use lesser_element::CommentBlock;
use lesser_element::DiarySexp;
use lesser_element::ExampleBlock;
use lesser_element::ExportBlock;
use lesser_element::FixedWidthArea;
use lesser_element::HorizontalRule;
use lesser_element::Keyword;
use lesser_element::LatexEnvironment;
use lesser_element::Paragraph;
use lesser_element::Planning;
use lesser_element::SrcBlock;
use lesser_element::TableCell;
use lesser_element::VerseBlock;
use object::AngleLink;
use object::Bold;
use object::Citation;
use object::CitationReference;
use object::Code;
use object::Entity;
use object::ExportSnippet;
use object::FootnoteReference;
use object::InlineBabelCall;
use object::InlineSourceBlock;
use object::Italic;
use object::LatexFragment;
use object::LineBreak;
use object::Object;
use object::OrgMacro;
use object::PlainLink;
use object::PlainText;
use object::RadioLink;
use object::RadioTarget;
use object::RegularLink;
use object::StatisticsCookie;
use object::StrikeThrough;
use object::Subscript;
use object::Superscript;
use object::Target;
use object::Timestamp;
use object::Underline;
use object::Verbatim;
use source::SetSource;
use source::Source;

148
src/types/object.rs
View File

@ -1,7 +1,7 @@
use super::Source;
#[derive(Debug, PartialEq)]
pub enum Object<'s> {
enum Object<'s> {
Bold(Bold<'s>),
Italic(Italic<'s>),
Underline(Underline<'s>),
@ -32,157 +32,157 @@ pub enum Object<'s> {
}
#[derive(Debug, PartialEq)]
pub struct Bold<'s> {
pub source: &'s str,
pub children: Vec<Object<'s>>,
struct Bold<'s> {
source: &'s str,
children: Vec<Object<'s>>,
}
#[derive(Debug, PartialEq)]
pub struct Italic<'s> {
pub source: &'s str,
pub children: Vec<Object<'s>>,
struct Italic<'s> {
source: &'s str,
children: Vec<Object<'s>>,
}
#[derive(Debug, PartialEq)]
pub struct Underline<'s> {
pub source: &'s str,
pub children: Vec<Object<'s>>,
struct Underline<'s> {
source: &'s str,
children: Vec<Object<'s>>,
}
#[derive(Debug, PartialEq)]
pub struct StrikeThrough<'s> {
pub source: &'s str,
pub children: Vec<Object<'s>>,
struct StrikeThrough<'s> {
source: &'s str,
children: Vec<Object<'s>>,
}
#[derive(Debug, PartialEq)]
pub struct Code<'s> {
pub source: &'s str,
pub contents: &'s str,
struct Code<'s> {
source: &'s str,
contents: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct Verbatim<'s> {
pub source: &'s str,
pub contents: &'s str,
struct Verbatim<'s> {
source: &'s str,
contents: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct PlainText<'s> {
pub source: &'s str,
struct PlainText<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct RegularLink<'s> {
pub source: &'s str,
struct RegularLink<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct RadioTarget<'s> {
pub source: &'s str,
pub children: Vec<Object<'s>>,
struct RadioTarget<'s> {
source: &'s str,
children: Vec<Object<'s>>,
}
#[derive(Debug, PartialEq)]
pub struct RadioLink<'s> {
pub source: &'s str,
pub children: Vec<Object<'s>>,
struct RadioLink<'s> {
source: &'s str,
children: Vec<Object<'s>>,
}
#[derive(Debug, PartialEq)]
pub struct PlainLink<'s> {
pub source: &'s str,
pub link_type: &'s str,
pub path: &'s str,
struct PlainLink<'s> {
source: &'s str,
link_type: &'s str,
path: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct AngleLink<'s> {
pub source: &'s str,
pub link_type: &'s str,
pub path: &'s str,
struct AngleLink<'s> {
source: &'s str,
link_type: &'s str,
path: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct OrgMacro<'s> {
pub source: &'s str,
pub macro_name: &'s str,
pub macro_args: Vec<&'s str>,
struct OrgMacro<'s> {
source: &'s str,
macro_name: &'s str,
macro_args: Vec<&'s str>,
}
#[derive(Debug, PartialEq)]
pub struct Entity<'s> {
pub source: &'s str,
pub entity_name: &'s str,
struct Entity<'s> {
source: &'s str,
entity_name: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct LatexFragment<'s> {
pub source: &'s str,
struct LatexFragment<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct ExportSnippet<'s> {
pub source: &'s str,
pub backend: &'s str,
pub contents: Option<&'s str>,
struct ExportSnippet<'s> {
source: &'s str,
backend: &'s str,
contents: Option<&'s str>,
}
#[derive(Debug, PartialEq)]
pub struct FootnoteReference<'s> {
pub source: &'s str,
pub label: Option<&'s str>,
pub definition: Vec<Object<'s>>,
struct FootnoteReference<'s> {
source: &'s str,
label: Option<&'s str>,
definition: Vec<Object<'s>>,
}
#[derive(Debug, PartialEq)]
pub struct Citation<'s> {
pub source: &'s str,
struct Citation<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct CitationReference<'s> {
pub source: &'s str,
struct CitationReference<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct InlineBabelCall<'s> {
pub source: &'s str,
struct InlineBabelCall<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct InlineSourceBlock<'s> {
pub source: &'s str,
struct InlineSourceBlock<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct LineBreak<'s> {
pub source: &'s str,
struct LineBreak<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct Target<'s> {
pub source: &'s str,
struct Target<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct StatisticsCookie<'s> {
pub source: &'s str,
struct StatisticsCookie<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct Subscript<'s> {
pub source: &'s str,
struct Subscript<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct Superscript<'s> {
pub source: &'s str,
struct Superscript<'s> {
source: &'s str,
}
#[derive(Debug, PartialEq)]
pub struct Timestamp<'s> {
pub source: &'s str,
struct Timestamp<'s> {
source: &'s str,
}
impl<'s> Source<'s> for Object<'s> {

4
src/types/source.rs
View File

@ -1,6 +1,6 @@
pub trait Source<'s> {
trait Source<'s> {
fn get_source(&'s self) -> &'s str;
}
pub trait SetSource<'s> {
trait SetSource<'s> {
fn set_source(&mut self, source: &'s str);
}