ASCIIdoctrine

Rule::title => Some(process_title(element, base)),
Rule::header | Rule::title_block => {
  Some(element.into_inner().fold(base, |base, subelement| {
    match subelement.as_rule() {
      Rule::title => process_title(subelement, base.clone()),
      Rule::anchor => process_anchor(subelement, base),
      // We just take the attributes at the beginning
      // of the element.
      _ => base,
    }
  }))
}

fn process_title<'a>(element: Pair<'a, asciidoc::Rule>, base: ElementSpan<'a>) -> ElementSpan<'a> {
  match element.as_rule() {
    Rule::title => {
      element.into_inner().fold(base, |base, subelement| {
        match subelement.as_rule() {
          Rule::atx_title_style => base.element(Element::Title {
            level: subelement.as_str().trim().len() as u32,
          }),
          Rule::setext_title_style => base.clone().element(Element::Title {
            level: match subelement.as_str().chars().next().unwrap() {
              '=' => 1,
              '-' => 2,
              '~' => 3,
              '^' => 4,
              _ => {
                return base.error("Unsupported title formatting");
              }
            },
          }),
          Rule::line => base.add_attribute(Attribute {
            key: "name".to_string(),
            value: AttributeValue::Ref(subelement.as_str()),
          }),
          // We just take the attributes at the beginning
          // of the element.
          _ => base.error("Unsupported title formatting"),
        }
      })
    }
    _ => base,
  }
}

Rule::paragraph => Some(process_paragraph(element)),

fn parse_paragraph<'a>(content: &'a str) -> Vec<ElementSpan<'a>> {
  let mut out = vec![];

  let ast = AsciidocParser::parse(Rule::inline_parser, content).unwrap();

  for element in ast {
    for subelement in element.into_inner() {
      if subelement.as_rule() != Rule::EOI {
        out.push(match subelement.as_rule() {
          Rule::other_inline | Rule::other_list_inline => from_element(&subelement, Element::Text),
          Rule::inline => process_inline(subelement.clone(), set_span(&subelement)),
          _ => set_span(&subelement),
        });
      }
    }
  }

  out
}

fn process_paragraph<'a>(element: Pair<'a, asciidoc::Rule>) -> ElementSpan<'a> {
  let mut base = from_element(&element, Element::Paragraph);

  base.children = parse_paragraph(element.as_str())
    .into_iter()
    .map(|child| child.add_offset(&base))
    .collect();

  base
}

fn process_inline<'a>(element: Pair<'a, asciidoc::Rule>, base: ElementSpan<'a>) -> ElementSpan<'a> {
  element
    .into_inner()
    .fold(base, |base, element| match element.as_rule() {
      Rule::link => process_link(element, base),
      Rule::xref => process_xref(element, base),
      Rule::monospaced | Rule::strong | Rule::emphasized => {
        let base = base.element(Element::Styled).add_attribute(Attribute {
          key: "style".to_string(),
          value: AttributeValue::Ref(match element.as_rule() {
            Rule::monospaced => "monospaced",
            Rule::strong => "strong",
            Rule::emphasized => "em",
            _ => "not_supported",
          }),
        });

        let base = match concat_elements(element.clone(), Rule::linechar, "") {
          Some(content) => base.add_attribute(Attribute {
            key: "content".to_string(),
            value: AttributeValue::String(content),
          }),
          None => base,
        };
        element
          .into_inner()
          .fold(base, |base, subelement| match subelement.as_rule() {
            Rule::inline_anchor => process_inline_anchor(subelement, base),
            _ => base,
          })
      }
      _ => base,
    })
}

Rule::list => extract_inner_rule(element, env),
Rule::list_paragraph => Some(process_paragraph(element)),
Rule::other_list_inline => Some(from_element(&element, Element::Text)),
Rule::continuation => None,

continuation = { NEWLINE ~ "+" ~ NEWLINE }

fn process_link<'a>(element: Pair<'a, asciidoc::Rule>, base: ElementSpan<'a>) -> ElementSpan<'a> {
  element
    .into_inner()
    .fold(base.element(Element::Link), |base, element| {
      match element.as_rule() {
        Rule::url => {
          let base = base.add_attribute(Attribute {
            key: "url".to_string(),
            value: AttributeValue::Ref(element.as_str()),
          });
          let element = element.into_inner().next().unwrap(); // TODO Fehler möglich?
          base.add_attribute(Attribute {
            key: "protocol".to_string(),
            value: AttributeValue::Ref(element.as_str()),
          })
        }
        Rule::inline_attribute_list => process_inline_attribute_list(element, base),
        _ => base.add_child(set_span(&element)),
      }
    })
}

fn process_xref<'a>(element: Pair<'a, asciidoc::Rule>, base: ElementSpan<'a>) -> ElementSpan<'a> {
  let base = element
    .clone()
    .into_inner()
    .fold(base.element(Element::XRef), |base, element| {
      match element.as_rule() {
        Rule::identifier => base.add_attribute(Attribute {
          key: "id".to_string(),
          value: AttributeValue::Ref(element.as_str()),
        }),
        Rule::word => base,
        _ => base,
      }
    });

  match concat_elements(element, Rule::word, " ") {
    Some(content) => base.add_attribute(Attribute {
      key: "content".to_string(),
      value: AttributeValue::String(content),
    }),
    None => base,
  }
}

Rule::image_block => Some(process_image(element, env)),

fn process_image<'a>(element: Pair<'a, asciidoc::Rule>, env: &mut Env) -> ElementSpan<'a> {
  let base = element.clone().into_inner().flatten().fold(
    set_span(&element).element(Element::Image),
    |base, element| match element.as_rule() {
      Rule::url => base.add_attribute(Attribute {
        key: "path".to_string(),
        value: AttributeValue::Ref(element.as_str()),
      }),
      Rule::path => base.add_attribute(Attribute {
        key: "path".to_string(),
        value: AttributeValue::Ref(element.as_str()),
      }),
      Rule::inline_attribute_list => process_inline_attribute_list(element, base),
      _ => base,
    },
  );

  match base.get_attribute("opts") {
    Some("inline") => match base.get_attribute("path") {
      Some(path) => match env.read_to_string(path) {
        Ok(content) => base.add_attribute(Attribute {
          key: "content".to_string(),
          value: AttributeValue::String(content),
        }),
        Err(e) => base.clone().error(&format!(
          "couldn't read content of image file {} ({})",
          path, e
        )),
      },
      None => base.error("There was no path of inline image defined"),
    },
    Some(_) | None => base,
  }
}

Rule::delimited_table => process_inner_table(sub, base.element(Element::Table), env),

#[derive(Debug, PartialEq)]
enum ColKind {
  Default,
  Asciidoc,
}

#[derive(Debug, PartialEq)]
struct ColumnFormat {
  length: usize,
  kind: ColKind,
}

fn parse_column_format(input: &str) -> ColumnFormat {
  ColumnFormat {
    length: 1,
    kind: match input {
      "a" => ColKind::Asciidoc,
      _ => ColKind::Default,
    },
  }
}

fn parse_columns_format(input: &str) -> Vec<ColumnFormat> {
  input
    .split(',')
    .map(|input| parse_column_format(input.trim()))
    .collect()
}

fn parse_columns_format_from_content(input: &str) -> Vec<ColumnFormat> {
  input
    .lines()
    .next()
    .unwrap_or("")
    .matches('|')
    .map(|_| ColumnFormat {
      length: 1,
      kind: ColKind::Default,
    })
    .collect()
}

fn process_inner_table<'a>(
  element: Pair<'a, asciidoc::Rule>,
  mut base: ElementSpan<'a>,
  env: &mut Env,
) -> ElementSpan<'a> {
  let content = element
    .into_inner()
    .find(|sub| sub.as_rule() == Rule::delimited_inner)
    .unwrap()
    .as_str();

  let col_format = match base.get_attribute("cols") {
    Some(fmt) => parse_columns_format(fmt),
    None => parse_columns_format_from_content(content),
  };

  base.attributes.push(Attribute {
    key: "content".to_string(),
    value: AttributeValue::Ref(content),
  });
  base.children = process_table_content(content, col_format, env);

  base
}

fn process_table_content<'a>(
  input: &'a str,
  col_format: Vec<ColumnFormat>,
  env: &mut Env,
) -> Vec<ElementSpan<'a>> {
  let ast = match AsciidocParser::parse(Rule::table_inner, input) {
    Ok(ast) => ast,
    Err(e) => {
      return vec![ElementSpan {
        element: Element::Error(format!("could not parse cell: {}", e)),
        source: None,
        content: input,
        start: 0,
        end: 0,
        start_line: 0,
        start_col: 0,
        end_line: 0,
        end_col: 0,
        children: vec![],
        positional_attributes: vec![],
        attributes: vec![],
      }];
    }
  };

  let mut cells = vec![];

  for element in ast {
    for (subelement, fmt) in element.into_inner().zip(col_format.iter().cycle()) {
      cells.push(process_table_cell(subelement, fmt, env))
    }
  }

  let mut rows = vec![];
  let len = col_format.len();
  for chunk in cells.chunks(len) {
    rows.push(ElementSpan {
      element: Element::TableRow,
      source: None,
      content: "",
      start: 0,
      end: 0,
      start_line: 0,
      start_col: 0,
      end_line: 0,
      end_col: 0,
      children: chunk.to_vec(),
      positional_attributes: vec![],
      attributes: vec![],
    })
  }

  rows
}

fn process_table_cell<'a>(
  element: Pair<'a, asciidoc::Rule>,
  fmt: &ColumnFormat,
  env: &mut Env,
) -> ElementSpan<'a> {
  let mut base = set_span(&element).element(Element::TableCell);

  let content = element
    .into_inner()
    .find(|sub| sub.as_rule() == Rule::table_cell_content)
    .unwrap()
    .as_str()
    .trim();

  base.content = content;
  base.children = match fmt.kind {
    ColKind::Asciidoc => {
      let ast = AsciidocParser::parse(Rule::asciidoc, content).unwrap();

      let mut elements = vec![];

      for element in ast {
        if let Some(element) = process_element(element, env) {
          elements.push(element);
        }
      }
      elements
    }
    ColKind::Default => {
      let mut base = base.clone();
      base.element = Element::Paragraph;
      base.children = parse_paragraph(content);

      vec![base]
    }
  };

  base
}

// TODO Damit werden keine Kommentare zu Beginn eines Paragraphen angezeigt
comment = { NEWLINE ~ "//" ~ (!NEWLINE ~ ANY)* ~ &NEWLINE }

<<delimited_block_template|
    blocktype := "comment",
    delimiter := "/" >>

Rule::delimited_comment => BlockType::Comment,

<<delimited_block_template|
    blocktype := "literal",
    delimiter := "." >>

<<delimited_block_template|
    blocktype := "source",
    delimiter := "-" >>

Rule::delimited_source | Rule::delimited_literal => BlockType::Listing,

<<delimited_block_template|
    blocktype := "example",
    delimiter := "=" >>

delimited_verse = { "verse" } // TODO

Rule::delimited_example => BlockType::Example,