- [ ] issue references

- [x] issue references

#[structopt(name = "example", about = "An example of StructOpt usage.")]

#[structopt(name = "convco", about = "Conventional commit tools")]

use crate::conventional::changelog::{Context, Note, NoteGroup};

use crate::conventional::changelog::{Context, Note, NoteGroup, Reference};
use regex::Regex;

    re_references: Regex,

        let re_references =
            Regex::new(format!("({})([0-9]+)", config.issue_prefixes.join("|")).as_str()).unwrap();

            re_references,

                let mut references = Vec::new();
                if let Some(body) = conv_commit.body {
                    references.extend(self.re_references.captures_iter(body.as_str()).map(
                        |refer| Reference {
                            // TODO action (the word before?)
                            action: None,
                            owner: "",
                            repository: "",
                            prefix: refer[1].to_owned(),
                            issue: refer[2].to_owned(),
                            raw: refer[0].to_owned(),
                        },
                    ));
                }
                references.extend(conv_commit.footers.iter().flat_map(|footer| {
                    self.re_references
                        .captures_iter(footer.value.as_str())
                        .map(move |refer| Reference {
                            action: Some(footer.key.clone()),
                            owner: "",
                            repository: "",
                            prefix: refer[1].to_owned(),
                            issue: refer[2].to_owned(),
                            raw: refer[0].to_owned(),
                        })
                }));

                    references,

    issue_prefixes: Vec<String>,

    pub(crate) issue_prefixes: Vec<String>,

#[derive(Debug, Serialize)]

    action: &'a str,
    owner: &'a str,
    repository: &'a str,
    issue: &'a str,
    raw: &'a str,

    pub(crate) action: Option<String>,
    pub(crate) owner: &'a str,
    pub(crate) repository: &'a str,
    pub(crate) prefix: String,
    pub(crate) issue: String,
    pub(crate) raw: String,

pub(crate) struct CommitContext {

pub(crate) struct CommitContext<'a> {

    pub(crate) references: Vec<Reference<'a>>,

    pub(crate) commits: Vec<CommitContext>,

    pub(crate) commits: Vec<CommitContext<'a>>,