chrono = { version = "0.4.9", features = ["serde"] }
git2 = "0.10.1"

chrono = { version = "0.4.10", features = ["serde"] }
git2 = "0.10.2"

serde_json = "1.0.41"
serde = { version = "1.0.102", features = ["derive"] }
structopt = "0.3.4"

serde = { version = "1.0.103", features = ["derive"] }
serde_yaml = "0.8.11"
structopt = "0.3.5"

- [ ] automatic notes for breaking changes

- [x] automatic notes for breaking changes

- [ ] use a `.versionrc` file
- [ ] limit to a range of versions

- [x] use a `.versionrc` file
- [x] limit to a range of versions
- [ ] sort sections in changelog
- [ ] issue references

    conventional::changelog::{
        ChangelogWriter, CommitContext, CommitGroup, Config, ContextBuilder,

    conventional::{
        changelog::{ChangelogWriter, CommitContext, CommitGroup, Config, ContextBuilder},
        Footer,

use crate::conventional::changelog::Context;

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

    fn make_notes(&self, footers: &'a [Footer], scope: Option<String>) -> Vec<(String, Note)> {
        footers
            .iter()
            .filter(|footer| footer.key.starts_with("BREAKING"))
            .map(|footer| {
                (
                    footer.key.clone(),
                    Note {
                        scope: scope.clone(),
                        text: footer.value.clone(),
                    },
                )
            })
            .collect()
    }

        let mut notes: HashMap<String, Vec<Note>> = HashMap::new();

                self.make_notes(&conv_commit.footers, conv_commit.scope.clone())
                    .into_iter()
                    .for_each(|(key, note)| {
                        notes.entry(key).or_default().push(note);
                    });

                let scope = conv_commit.scope;

                    scope,

            .previous_tag(to_rev.0)
            .current_tag(from_rev.0)

            )
            .note_groups(
                notes
                    .into_iter()
                    .map(|(title, notes)| NoteGroup { title, notes })
                    .collect(),

    Config::default()

    std::fs::read(".versionrc")
        .ok()
        .and_then(|versionrc| serde_yaml::from_reader(versionrc.as_slice()).ok())
        .unwrap_or_default()

        let (rev, rev_stop) = if rev.contains("..") {
            let mut split = rev.split("..");
            let low = split.next().unwrap_or("");
            let hi = split
                .next()
                .map(|s| if s == "" { "HEAD" } else { s })
                .unwrap_or("HEAD");
            // FIXME hi and low are supposed to be a version tag.
            (hi, low)
        } else {
            (rev, "")
        };

            Some(v) => {

            Some(last_version) => {

                    if helper.same_commit(rev, v.tag.as_str()) {
                        Rev(v.tag.as_str(), Some(semver))

                    if helper.same_commit(rev, last_version.tag.as_str()) {
                        Rev(last_version.tag.as_str(), Some(semver))

                } else if helper.same_commit(rev, v.tag.as_str()) {
                    Rev(v.tag.as_str(), Some(&v.version))

                } else if helper.same_commit(rev, last_version.tag.as_str()) {
                    Rev(last_version.tag.as_str(), Some(&last_version.version))

                let iter: Vec<Rev<'_>> = Some(from_rev)
                    .into_iter()
                    .chain(helper.versions_from(&v).into_iter().rev().map(|v| v.into()))
                    .chain(Some(Rev("", None)))
                    .collect();

                // TODO refactor this logic a bit to be less complicated.
                //  if we have HEAD!=version tag - version tag - ...
                //  or HEAD==version tag - version tag - ...
                //  we have to use different logic here, or in the `GitHelper::versions_from` method.
                let is_head = from_rev.0 == "HEAD";
                let iter = Some(from_rev).into_iter();
                let iter = if is_head {
                    iter.chain(
                        Some(Rev(last_version.tag.as_str(), Some(&last_version.version)))
                            .into_iter(),
                    )
                } else {
                    iter.chain(None)
                };
                let iter = iter
                    .chain(
                        helper
                            .versions_from(&last_version)
                            .into_iter()
                            .rev()
                            .take_while(|v| v.tag != rev_stop)
                            .map(|v| v.into()),
                    )
                    .chain(Some(Rev("", None)));
                let iter: Vec<Rev<'_>> = iter.collect();

    #[serde(default)]

    #[serde(default)]

pub(crate) struct Note<'a> {
    title: &'a str,
    text: &'a str,

#[derive(Serialize)]
pub(crate) struct Note {
    pub(crate) scope: Option<String>,
    pub(crate) text: String,

pub(crate) struct NoteGroup {
    pub(crate) title: String,
    pub(crate) notes: Vec<Note>,
}
#[derive(Serialize)]

    pub(crate) scope: Option<String>,

    pub(crate) commit_url_format: String,
    pub(crate) issue_url_format: String,
    pub(crate) release_commit_message_format: String,
    pub(crate) user_url_format: String,
    /// `true` if `previousTag` and `currentTag` are truthy.
    pub(crate) link_compare: bool,

    pub(crate) note_groups: Vec<NoteGroup>,
    pub(crate) previous_tag: &'a str,
    pub(crate) current_tag: &'a str,

        handlebars
            .register_template_string("commit_url_format", config.commit_url_format.as_str())?;
        handlebars
            .register_template_string("issue_url_format", config.issue_url_format.as_str())?;
        handlebars.register_template_string(
            "release_commit_message_format",
            config.release_commit_message_format.as_str(),
        )?;
        handlebars.register_template_string("user_url_format", config.user_url_format.as_str())?;

                note_groups: Default::default(),
                previous_tag: "",
                current_tag: "",

        self
    }
    pub fn note_groups(mut self, note_groups: Vec<NoteGroup>) -> Self {
        self.context.note_groups = note_groups;
        self
    }
    pub fn previous_tag(mut self, previous_tag: &'a str) -> Self {
        self.context.previous_tag = previous_tag;

    pub fn current_tag(mut self, current_tag: &'a str) -> Self {
        self.context.current_tag = current_tag;
        self
    }

        let commit_url_format = self.handlebars.render("commit_url_format", &self.context)?;
        let issue_url_format = self.handlebars.render("issue_url_format", &self.context)?;
        let release_commit_message_format = self
            .handlebars
            .render("release_commit_message_format", &self.context)?;
        let user_url_format = self.handlebars.render("user_url_format", &self.context)?;
        let link_compare = self.context.current_tag != "" && self.context.previous_tag != "";

            commit_url_format,
            issue_url_format,
            release_commit_message_format,
            user_url_format,
            link_compare,

        handlebars.set_strict_mode(true);

        handlebars.set_strict_mode(true);

    use serde_json;

    use serde_yaml;

        let value: Config = serde_json::from_str(json).unwrap();

        let value: Config = serde_yaml::from_str(json).unwrap();

{{#if noteGroups}}
{{#each noteGroups}}

{{#if noteGroups~}}
{{~#each noteGroups~}}

{{#each notes}}

{{#each notes~}}

{{/each}}

{{~/each}}

    key: String,
    value: String,

    pub(crate) key: String,
    pub(crate) value: String,

pub(crate) use commits::{Commit, Type};

pub(crate) use commits::{Commit, Footer, Type};

use std::io;

use std::{fmt, io};

}
impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            Self::Git(ref e) => write!(f, "{}", e),
            Self::Io(ref e) => write!(f, "{}", e),
            Self::Template(ref e) => write!(f, "{}", e),
            Self::Render(ref e) => write!(f, "{}", e),
            Self::Check => write!(f, "check error"),
        }
    }

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match *self {
            Self::Git(ref e) => Some(e),
            Self::Io(ref e) => Some(e),
            Self::Template(ref e) => Some(e),
            Self::Render(ref e) => Some(e),
            Self::Check => None,
        }
    }
}

                _ => eprintln!("{:?}", e),

                _ => {
                    eprintln!("{}", e);
                }