korrat/beancount-importers - Change MSGK44CSJ4STDFALPHHJJKBQQCGEHPB7QGHZXOXHK6PMGCRQ5A5AC

Refactor ImporterProtocol to pass buffers

Created by korrat on November 14, 2023

MSGK44CSJ4STDFALPHHJJKBQQCGEHPB7QGHZXOXHK6PMGCRQ5A5AC

Dependencies

In channels

main

Change contents

Replacement in importers/vr-bank/src/lib.rs at line 92 [5.69]

B:BD[5.2329] → [5.2329:2411]

    fn account(&self, _file: &camino::Utf8Path) -> Result<Account, Self::Error> {

[5.2329]

[5.2411]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/vr-bank/src/lib.rs at line 96 [5.69]

B:BD[5.2468] → [5.2468:2551]

    fn date(&self, file: &camino::Utf8Path) -> Option<Result<Date, Self::Error>> {

[5.2468]

[5.2551]

    fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/vr-bank/src/lib.rs at line 98 [5.69]
B:BD[5.2573] → [5.2573:2603]
```
            .date(file, self)
```
[5.2573]
[5.2603]
```
            .date(buffer, self)
```
Replacement in importers/vr-bank/src/lib.rs at line 104 [5.69]
B:BD[5.2702] → [5.2702:2735]
```
        file: &camino::Utf8Path,
```
[5.2702]
[5.2735]
```
        buffer: &[u8],
```

Replacement in importers/vr-bank/src/lib.rs at line 108 [5.69]

B:BD[5.2836] → [5.2836:2879]

            .extract(file, existing, self)

[5.2836]

[5.2879]

            .extract(buffer, existing, self)

Replacement in importers/vr-bank/src/lib.rs at line 112 [5.69]

B:BD[5.2926] → [5.2926:3016]

    fn filename(&self, _file: &camino::Utf8Path) -> Option<Result<String, Self::Error>> {

[5.2926]

[5.3016]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/vr-bank/src/lib.rs at line 116 [5.69]

B:BD[5.3074] → [5.3074:3153]

    fn identify(&self, file: &camino::Utf8Path) -> Result<bool, Self::Error> {

[5.3074]

[5.3153]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/vr-bank/src/lib.rs at line 140 [5.69]

B:BD[5.3844] → [5.3844:3890]

            .identify(file, EXPECTED_HEADERS)

[5.3844]

[5.3890]

            .identify(buffer, EXPECTED_HEADERS)

Deletion in importers/vr-bank/Cargo.toml at line 17 [5.9466]
B:BD[5.9918] → [5.9918:9950]
```
camino.workspace         = true
```

Replacement in importers/uniondepot/src/lib.rs at line 115 [6.42]

B:BD[6.3113] → [6.3113:3195]

    fn account(&self, _file: &camino::Utf8Path) -> Result<Account, Self::Error> {

[6.3113]

[6.3195]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/uniondepot/src/lib.rs at line 119 [6.42]

B:BD[6.3257] → [6.3257:3340]

    fn date(&self, file: &camino::Utf8Path) -> Option<Result<Date, Self::Error>> {

[6.3257]

[6.3340]

    fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/uniondepot/src/lib.rs at line 121 [6.42]
B:BD[6.3362] → [6.3362:3392]
```
            .date(file, self)
```
[6.3362]
[6.3392]
```
            .date(buffer, self)
```
Replacement in importers/uniondepot/src/lib.rs at line 127 [6.42]
B:BD[6.3491] → [6.3491:3524]
```
        file: &camino::Utf8Path,
```
[6.3491]
[6.3524]
```
        buffer: &[u8],
```

Replacement in importers/uniondepot/src/lib.rs at line 131 [6.42]

B:BD[6.3625] → [6.3625:3668]

            .extract(file, existing, self)

[6.3625]

[6.3668]

            .extract(buffer, existing, self)

Replacement in importers/uniondepot/src/lib.rs at line 135 [6.42]

B:BD[6.3715] → [6.3715:3805]

    fn filename(&self, _file: &camino::Utf8Path) -> Option<Result<String, Self::Error>> {

[6.3715]

[6.3805]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/uniondepot/src/lib.rs at line 139 [6.42]

B:BD[6.3863] → [6.3863:3942]

    fn identify(&self, file: &camino::Utf8Path) -> Result<bool, Self::Error> {

[6.3863]

[6.3942]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/uniondepot/src/lib.rs at line 153 [6.42]

B:BD[6.4251] → [6.4251:4297]

            .identify(file, EXPECTED_HEADERS)

[6.4251]

[6.4297]

            .identify(buffer, EXPECTED_HEADERS)

Deletion in importers/uniondepot/Cargo.toml at line 17 [6.13870]
B:BD[6.14325] → [6.14325:14357]
```
camino.workspace         = true
```

Replacement in importers/paypal/src/lib.rs at line 201 [7.38]

B:BD[7.6643] → [7.6643:6717]

    fn account(&self, _file: &Utf8Path) -> Result<Account, Self::Error> {

[7.6643]

[7.6717]

    fn account(&self, _file: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/paypal/src/lib.rs at line 205 [7.38]

B:BD[7.6782] → [7.6782:6857]

    fn date(&self, file: &Utf8Path) -> Option<Result<Date, Self::Error>> {

[7.6782]

[7.6857]

    fn date(&self, file: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/paypal/src/lib.rs at line 211 [7.38]

B:BD[7.6977] → [7.6977:7008]

B:BD[7.7008] → [7.7008:7033]

B:BD[7.7033] → [7.7033:7112]

    fn extract(
        &self,
        file: &Utf8Path,
        existing: &[Directive],
    ) -> Result<Vec<Directive>, Self::Error> {

[7.6977]

[8.4721]

    fn extract(&self, file: &[u8], existing: &[Directive]) -> Result<Vec<Directive>, Self::Error> {

Replacement in importers/paypal/src/lib.rs at line 217 [7.38]

B:BD[7.8518] → [7.8518:8600]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[7.8518]

[7.8600]

    fn filename(&self, _file: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/paypal/src/lib.rs at line 221 [7.38]

B:BD[7.8658] → [7.8658:8729]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {

[7.8658]

[7.8729]

    fn identify(&self, file: &[u8]) -> Result<bool, Self::Error> {

Deletion in importers/paypal/src/lib.rs at line 514 [7.38]
B:BD[7.679] → [7.679:701]
```
use camino::Utf8Path;
```
Solving an order conflict in importers/paypal/src/lib.rs at line 514 [7.38]
[7.14811]
Deletion in importers/paypal/Cargo.toml at line 14 [7.14844]
B:BD[7.15212] → [7.15212:15244]
```
camino.workspace         = true
```

Replacement in importers/fidor/src/lib.rs at line 143 [9.37]

B:BD[9.3693] → [9.3693:3775]

    fn account(&self, _file: &camino::Utf8Path) -> Result<Account, Self::Error> {

[9.3693]

[9.3775]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/fidor/src/lib.rs at line 147 [9.37]

B:BD[9.3832] → [9.3832:3915]

    fn date(&self, file: &camino::Utf8Path) -> Option<Result<Date, Self::Error>> {

[9.3832]

[9.3915]

    fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/fidor/src/lib.rs at line 149 [9.37]
B:BD[9.3937] → [9.3937:3967]
```
            .date(file, self)
```
[9.3937]
[9.3967]
```
            .date(buffer, self)
```
Replacement in importers/fidor/src/lib.rs at line 155 [9.37]
B:BD[9.4066] → [9.4066:4099]
```
        file: &camino::Utf8Path,
```
[9.4066]
[9.4099]
```
        buffer: &[u8],
```

Replacement in importers/fidor/src/lib.rs at line 159 [9.37]

B:BD[9.4200] → [9.4200:4243]

            .extract(file, existing, self)

[9.4200]

[9.4243]

            .extract(buffer, existing, self)

Replacement in importers/fidor/src/lib.rs at line 163 [9.37]

B:BD[9.4290] → [9.4290:4380]

    fn filename(&self, _file: &camino::Utf8Path) -> Option<Result<String, Self::Error>> {

[9.4290]

[9.4380]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/fidor/src/lib.rs at line 167 [9.37]

B:BD[9.4438] → [9.4438:4517]

    fn identify(&self, file: &camino::Utf8Path) -> Result<bool, Self::Error> {

[9.4438]

[9.4517]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/fidor/src/lib.rs at line 171 [9.37]

B:BD[9.4635] → [9.4635:4681]

            .identify(file, EXPECTED_HEADERS)

[9.4635]

[9.4681]

            .identify(buffer, EXPECTED_HEADERS)

Deletion in importers/fidor/Cargo.toml at line 17 [9.15004]
B:BD[9.15473] → [9.15473:15505]
```
camino.workspace         = true
```
Deletion in importers/ecus/src/lib.rs at line 12 [10.36]
B:BD[10.420] → [10.420:442]
```
use camino::Utf8Path;
```
Deletion in importers/ecus/src/lib.rs at line 23 [10.36]
B:BD[10.755] → [10.755:774]
```
use tracing::warn;
```

Replacement in importers/ecus/src/lib.rs at line 63 [10.36]

B:BD[10.1723] → [10.1723:1797]

    fn account(&self, _file: &Utf8Path) -> Result<Account, Self::Error> {

[10.1723]

[2.49]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/ecus/src/lib.rs at line 67 [10.36]

B:BD[2.101] → [2.101:500]

    fn date(&self, file: &Utf8Path) -> Option<Result<Date, Self::Error>> {
        let ecus_transactions = {
            std::fs::read_to_string(file)
                .into_diagnostic()
                .and_then(|data| {
                    serde_json::from_str::<Vec<EcusTransaction>>(&data).into_diagnostic()
                })
        };
        let ecus_transactions = match ecus_transactions {

[2.101]

[2.500]

    fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>> {
        let ecus_transactions: Vec<EcusTransaction> = match serde_json::from_slice(buffer) {

Replacement in importers/ecus/src/lib.rs at line 70 [10.36]

B:BD[2.530] → [2.530:581]

            Err(error) => return Some(Err(error)),

[2.530]

[2.581]

            Err(error) => return Some(Err(error).into_diagnostic()),

Replacement in importers/ecus/src/lib.rs at line 82 [10.36]
B:BD[10.1851] → [10.1851:1876]
```
        file: &Utf8Path,
```
[10.1851]
[10.1876]
```
        buffer: &[u8],
```

Replacement in importers/ecus/src/lib.rs at line 85 [10.36]

B:BD[10.1956] → [10.1956:2155]

        let ecus_transactions: Vec<EcusTransaction> = {
            let data = std::fs::read_to_string(file).into_diagnostic()?;
            serde_json::from_str(&data).into_diagnostic()?
        };

[10.1956]

[10.2155]

        let ecus_transactions: Vec<EcusTransaction> =
            serde_json::from_slice(buffer).into_diagnostic()?;

Replacement in importers/ecus/src/lib.rs at line 114 [10.36]

B:BD[10.3186] → [10.3186:3276]

                            warn!(%location, "ignoring transaction at unknown location");

[10.3186]

[10.3276]

                            tracing::warn!(%location, "ignoring transaction at unknown location");

Replacement in importers/ecus/src/lib.rs at line 150 [10.36]

B:BD[2.753] → [2.753:835]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[2.753]

[2.835]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Deletion in importers/ecus/src/lib.rs at line 153 [10.36]

B:BD[10.4517] → [10.4517:4518]

B:BD[10.4518] → [2.893:1033]


    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {
        let data = std::fs::read_to_string(file).into_diagnostic()?;

Replacement in importers/ecus/src/lib.rs at line 154 [10.36]

B:BD[2.1034] → [2.1034:1102]

        match serde_json::from_str::<Vec<EcusTransaction>>(&data) {

[2.1034]

[2.1102]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {
        match serde_json::from_slice::<Vec<EcusTransaction>>(buffer) {

Replacement in importers/ecus/src/lib.rs at line 157 [10.36]

B:BD[2.1133] → [2.1133:1301]

            Err(error) => {
                tracing::debug!(?error, %file, data, "ignoring file due to deserialization error");
                Ok(false)
            }

[2.1133]

[2.1301]

            Err(_) => Ok(false),

Replacement in importers/ebase/src/transactions.rs at line 149 [11.37]

B:BD[11.3077] → [11.3077:3168]

    fn account(&self, _file: &Utf8Path) -> Result<beancount_types::Account, Self::Error> {

[11.3077]

[11.3168]

    fn account(&self, _file: &[u8]) -> Result<beancount_types::Account, Self::Error> {

Replacement in importers/ebase/src/transactions.rs at line 153 [11.37]

B:BD[11.3234] → [11.3234:3309]

    fn date(&self, file: &Utf8Path) -> Option<Result<Date, Self::Error>> {

[11.3234]

[11.3309]

    fn date(&self, file: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/ebase/src/transactions.rs at line 159 [11.37]

B:BD[11.3429] → [11.3429:3460]

B:BD[11.3460] → [11.3460:3485]

B:BD[11.3485] → [11.3485:3564]

    fn extract(
        &self,
        file: &Utf8Path,
        existing: &[Directive],
    ) -> Result<Vec<Directive>, Self::Error> {

[11.3429]

[11.3564]

    fn extract(&self, file: &[u8], existing: &[Directive]) -> Result<Vec<Directive>, Self::Error> {

Replacement in importers/ebase/src/transactions.rs at line 165 [11.37]

B:BD[11.3671] → [11.3671:3753]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[11.3671]

[11.3753]

    fn filename(&self, _file: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/ebase/src/transactions.rs at line 169 [11.37]

B:BD[11.3811] → [11.3811:3882]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {

[11.3811]

[11.3882]

    fn identify(&self, file: &[u8]) -> Result<bool, Self::Error> {

Deletion in importers/ebase/src/transactions.rs at line 784 [11.37]
B:BD[11.528] → [11.528:550]
```
use camino::Utf8Path;
```
Solving an order conflict in importers/ebase/src/transactions.rs at line 784 [11.37]
[11.24688]

Replacement in importers/ebase/src/balances.rs at line 118 [11.24804]

B:BD[11.27659] → [11.27659:27750]

    fn account(&self, _file: &Utf8Path) -> Result<beancount_types::Account, Self::Error> {

[11.27659]

[11.27750]

    fn account(&self, _file: &[u8]) -> Result<beancount_types::Account, Self::Error> {

Replacement in importers/ebase/src/balances.rs at line 122 [11.24804]

B:BD[11.27815] → [11.27815:27890]

    fn date(&self, file: &Utf8Path) -> Option<Result<Date, Self::Error>> {

[11.27815]

[11.27890]

    fn date(&self, file: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/ebase/src/balances.rs at line 128 [11.24804]

B:BD[11.28010] → [11.28010:28041]

B:BD[11.28041] → [11.28041:28066]

B:BD[11.28066] → [11.28066:28145]

    fn extract(
        &self,
        file: &Utf8Path,
        existing: &[Directive],
    ) -> Result<Vec<Directive>, Self::Error> {

[11.28010]

[11.28145]

    fn extract(&self, file: &[u8], existing: &[Directive]) -> Result<Vec<Directive>, Self::Error> {

Replacement in importers/ebase/src/balances.rs at line 134 [11.24804]

B:BD[11.28252] → [11.28252:28334]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[11.28252]

[11.28334]

    fn filename(&self, _file: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/ebase/src/balances.rs at line 138 [11.24804]

B:BD[11.28388] → [11.28388:28459]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {

[11.28388]

[11.28459]

    fn identify(&self, file: &[u8]) -> Result<bool, Self::Error> {

Deletion in importers/ebase/src/balances.rs at line 292 [11.24804]
B:BD[11.25198] → [11.25198:25220]
```
use camino::Utf8Path;
```
Solving an order conflict in importers/ebase/src/balances.rs at line 292 [11.24804]
[4.20799]
Deletion in importers/ebase/Cargo.toml at line 18 [11.33466]
B:BD[11.33946] → [11.33946:33978]
```
camino.workspace         = true
```
Replacement in importers/csv/src/lib.rs at line 6 [12.35]
B:BD[12.168] → [12.168:215]
```
use camino::Utf8Path;
use camino::Utf8PathBuf;
```
[12.168]
[12.215]
Replacement in importers/csv/src/lib.rs at line 29 [12.35]
B:BD[12.707] → [12.707:729]
```
        data: String,
```
[12.707]
[12.729]
```
        data: Vec<u8>,
```

Deletion in importers/csv/src/lib.rs at line 33 [12.35]

B:BD[12.828] → [12.828:970]

    #[snafu(display("error while reading CSV file {file}"))]
    Reading {
        file: Utf8PathBuf,
        source: std::io::Error,
    },

Replacement in importers/csv/src/lib.rs at line 55 [12.35]

B:BD[12.1364] → [12.1364:1458]

    pub fn date<R>(&self, file: &Utf8Path, inner: R) -> Option<Result<Date, Error<R::Error>>>

[12.1364]

[12.1458]

    pub fn date<R>(&self, buffer: &[u8], inner: R) -> Option<Result<Date, Error<R::Error>>>

Deletion in importers/csv/src/lib.rs at line 61 [12.35]

B:BD[4.21012] → [4.21012:21098]

            let data = std::fs::read_to_string(file).context(ReadingSnafu { file })?;

Replacement in importers/csv/src/lib.rs at line 62 [12.35]

B:BD[4.21099] → [4.21099:21171]

            let mut reader = self.builder.from_reader(data.as_bytes());

[4.21099]

[4.21171]

            let mut reader = self.builder.from_reader(buffer);

Replacement in importers/csv/src/lib.rs at line 94 [12.35]

B:BD[4.22374] → [4.22374:22430]

                ProcessingSnafu { errors, data }.fail()

[4.22374]

[4.22430]

                ProcessingSnafu {
                    errors,
                    data: buffer,
                }
                .fail()

Replacement in importers/csv/src/lib.rs at line 106 [12.35]
B:BD[12.1920] → [12.1920:1945]
```
        file: &Utf8Path,
```
[12.1920]
[12.1945]
```
        buffer: &[u8],
```

Replacement in importers/csv/src/lib.rs at line 114 [12.35]

∅:D[4.22499] → [12.3438:3589]

B:BD[12.3438] → [12.3438:3589]

        let data = std::fs::read_to_string(file).context(ReadingSnafu { file })?;
        let mut reader = self.builder.from_reader(data.as_bytes());

[4.22499]

[4.22500]

        let mut reader = self.builder.from_reader(buffer);

Replacement in importers/csv/src/lib.rs at line 152 [12.35]

B:BD[12.4488] → [4.23746:23798]

            ProcessingSnafu { errors, data }.fail()

[12.4488]

[4.23798]

            ProcessingSnafu {
                errors,
                data: buffer,
            }
            .fail()

Deletion in importers/csv/src/lib.rs at line 159 [12.35]

B:BD[4.23814] → [4.23814:24033]

∅:D[4.24033] → [12.4540:4550]

B:BD[12.4540] → [12.4540:4550]


    pub fn identify(&self, file: &Utf8Path, expected_headers: &[&str]) -> Result<bool, csv::Error> {
        if !matches!(file.extension(), Some(ext) if ext.eq_ignore_ascii_case("csv")) {
            return Ok(false);
        }

Replacement in importers/csv/src/lib.rs at line 160 [12.35]

B:BD[4.24035] → [4.24035:24091]

        let mut reader = self.builder.from_path(file)?;

[4.24035]

[4.24091]

    pub fn identify(&self, buffer: &[u8], expected_headers: &[&str]) -> Result<bool, csv::Error> {
        let mut reader = self.builder.from_reader(buffer);

Replacement in importers/csv/Cargo.toml at line 4 [12.5568]

B:BD[12.5593] → [12.5593:5668]

authors.workspace = true
edition.workspace = true
publish.workspace = true

[12.5593]

[12.5668]

authors.workspace      = true
edition.workspace      = true
publish.workspace      = true

Replacement in importers/csv/Cargo.toml at line 8 [12.5568]
B:BD[12.5698] → [12.5698:5723]
```
version.workspace = true
```
[12.5698]
[12.5723]
```
version.workspace      = true
```

Replacement in importers/csv/Cargo.toml at line 13 [12.5568]

B:BD[12.5819] → [12.5819:5925]

beancount-types.path = "../../common/beancount-types"
german-decimal.path = "../../common/german-decimal"

[12.5819]

[12.5925]

beancount-types.path               = "../../common/beancount-types"
german-decimal.path                = "../../common/german-decimal"

Replacement in importers/csv/Cargo.toml at line 17 [12.5568]

B:BD[12.5951] → [12.5951:6022]

camino.workspace = true
csv.workspace = true
delegate.workspace = true

[12.5951]

[12.6022]

csv.workspace       = true
delegate.workspace  = true

Replacement in importers/csv/Cargo.toml at line 20 [12.5568]

B:BD[12.6049] → [12.6049:6162]

miette.workspace = true
serde.workspace = true
snafu.workspace = true
tap.workspace = true
time.workspace = true

[12.6049]

miette.workspace    = true
serde.workspace     = true
snafu.workspace     = true
tap.workspace       = true
time.workspace      = true

Replacement in importers/bw-bank/src/portfolio.rs at line 74 [13.39]

B:BD[13.1888] → [13.1888:1970]

    fn account(&self, _file: &camino::Utf8Path) -> Result<Account, Self::Error> {

[13.1888]

[13.1970]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/bw-bank/src/portfolio.rs at line 78 [13.39]

B:BD[13.2036] → [13.2036:2119]

    fn date(&self, file: &camino::Utf8Path) -> Option<Result<Date, Self::Error>> {

[13.2036]

[13.2119]

    fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/bw-bank/src/portfolio.rs at line 80 [13.39]
B:BD[13.2141] → [13.2141:2171]
```
            .date(file, self)
```
[13.2141]
[13.2171]
```
            .date(buffer, self)
```
Replacement in importers/bw-bank/src/portfolio.rs at line 86 [13.39]
B:BD[13.2270] → [13.2270:2303]
```
        file: &camino::Utf8Path,
```
[13.2270]
[13.2303]
```
        buffer: &[u8],
```
Replacement in importers/bw-bank/src/portfolio.rs at line 90 [13.39]
B:BD[13.2404] → [13.2404:2447]
```
            .extract(file, existing, self)
```
[13.2404]
[13.2447]
```
            .extract(buffer, existing, self)
```

Replacement in importers/bw-bank/src/portfolio.rs at line 94 [13.39]

B:BD[13.2494] → [13.2494:2584]

    fn filename(&self, _file: &camino::Utf8Path) -> Option<Result<String, Self::Error>> {

[13.2494]

[13.2584]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/bw-bank/src/portfolio.rs at line 98 [13.39]

B:BD[13.2642] → [13.2642:2721]

    fn identify(&self, file: &camino::Utf8Path) -> Result<bool, Self::Error> {

[13.2642]

[13.2721]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/bw-bank/src/portfolio.rs at line 113 [13.39]
B:BD[13.3050] → [13.3050:3096]
```
            .identify(file, EXPECTED_HEADERS)
```
[13.3050]
[13.3096]
```
            .identify(buffer, EXPECTED_HEADERS)
```
Deletion in importers/bw-bank/Cargo.toml at line 18 [13.8885]
B:BD[13.9367] → [13.9367:9399]
```
camino.workspace         = true
```
Deletion in importers/apple/src/transaction_history.rs at line 16 [14.37]
B:BD[14.498] → [14.498:520]
```
use camino::Utf8Path;
```

Replacement in importers/apple/src/transaction_history.rs at line 73 [14.37]

B:BD[14.1832] → [14.1832:1906]

    fn account(&self, _file: &Utf8Path) -> Result<Account, Self::Error> {

[14.1832]

[14.1906]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/apple/src/transaction_history.rs at line 77 [14.37]

B:BD[14.1968] → [14.1968:2049]

    fn date(&self, file: &Utf8Path) -> Option<Result<time::Date, Self::Error>> {

[14.1968]

[14.2049]

    fn date(&self, buffer: &[u8]) -> Option<Result<time::Date, Self::Error>> {

Replacement in importers/apple/src/transaction_history.rs at line 79 [14.37]
B:BD[14.2071] → [14.2071:2101]
```
            .date(file, self)
```
[14.2071]
[14.2101]
```
            .date(buffer, self)
```
Replacement in importers/apple/src/transaction_history.rs at line 85 [14.37]
B:BD[14.2200] → [14.2200:2225]
```
        file: &Utf8Path,
```
[14.2200]
[14.2225]
```
        buffer: &[u8],
```
Replacement in importers/apple/src/transaction_history.rs at line 89 [14.37]
B:BD[14.2326] → [14.2326:2369]
```
            .extract(file, existing, self)
```
[14.2326]
[14.2369]
```
            .extract(buffer, existing, self)
```

Replacement in importers/apple/src/transaction_history.rs at line 93 [14.37]

B:BD[14.2416] → [14.2416:2498]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[14.2416]

[14.2498]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/apple/src/transaction_history.rs at line 97 [14.37]

B:BD[14.2556] → [14.2556:2627]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {

[14.2556]

[14.2627]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/apple/src/transaction_history.rs at line 129 [14.37]
B:BD[14.3588] → [14.3588:3634]
```
            .identify(file, EXPECTED_HEADERS)
```
[14.3588]
[14.3634]
```
            .identify(buffer, EXPECTED_HEADERS)
```
Deletion in importers/apple/src/store_balance.rs at line 15 [14.8496]
B:BD[14.8957] → [14.8957:8979]
```
use camino::Utf8Path;
```

Replacement in importers/apple/src/store_balance.rs at line 74 [14.8496]

B:BD[14.10424] → [14.10424:10498]

    fn account(&self, _file: &Utf8Path) -> Result<Account, Self::Error> {

[14.10424]

[14.10498]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/apple/src/store_balance.rs at line 78 [14.8496]

B:BD[14.10563] → [14.10563:10638]

    fn date(&self, file: &Utf8Path) -> Option<Result<Date, Self::Error>> {

[14.10563]

[14.10638]

    fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/apple/src/store_balance.rs at line 80 [14.8496]
B:BD[14.10660] → [14.10660:10690]
```
            .date(file, self)
```
[14.10660]
[14.10690]
```
            .date(buffer, self)
```
Replacement in importers/apple/src/store_balance.rs at line 86 [14.8496]
B:BD[14.10789] → [14.10789:10814]
```
        file: &Utf8Path,
```
[14.10789]
[14.10814]
```
        buffer: &[u8],
```
Replacement in importers/apple/src/store_balance.rs at line 90 [14.8496]
B:BD[14.10916] → [14.10916:10960]
```
            .extract(file, _existing, self)
```
[14.10916]
[14.10960]
```
            .extract(buffer, _existing, self)
```

Replacement in importers/apple/src/store_balance.rs at line 94 [14.8496]

B:BD[14.11010] → [14.11010:11092]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[14.11010]

[14.11092]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/apple/src/store_balance.rs at line 98 [14.8496]

B:BD[14.11151] → [14.11151:11222]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {

[14.11151]

[14.11222]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/apple/src/store_balance.rs at line 108 [14.8496]
B:BD[14.11438] → [14.11438:11484]
```
            .identify(file, EXPECTED_HEADERS)
```
[14.11438]
[14.11484]
```
            .identify(buffer, EXPECTED_HEADERS)
```
Deletion in importers/apple/Cargo.toml at line 18 [14.18151]
B:BD[14.18631] → [14.18631:18663]
```
camino.workspace         = true
```
Deletion in importers/amazon/src/order_history.rs at line 16 [15.61]
B:BD[15.556] → [15.556:578]
```
use camino::Utf8Path;
```

Replacement in importers/amazon/src/order_history.rs at line 70 [15.61]

B:BD[15.1923] → [15.1923:1997]

    fn account(&self, _file: &Utf8Path) -> Result<Account, Self::Error> {

[15.1923]

[15.1997]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/amazon/src/order_history.rs at line 74 [15.61]

B:BD[15.2059] → [15.2059:2140]

    fn date(&self, file: &Utf8Path) -> Option<Result<time::Date, Self::Error>> {

[15.2059]

[15.2140]

    fn date(&self, buffer: &[u8]) -> Option<Result<time::Date, Self::Error>> {

Replacement in importers/amazon/src/order_history.rs at line 76 [15.61]
B:BD[15.2162] → [15.2162:2192]
```
            .date(file, self)
```
[15.2162]
[15.2192]
```
            .date(buffer, self)
```
Replacement in importers/amazon/src/order_history.rs at line 82 [15.61]
B:BD[15.2291] → [15.2291:2316]
```
        file: &Utf8Path,
```
[15.2291]
[15.2316]
```
        buffer: &[u8],
```
Replacement in importers/amazon/src/order_history.rs at line 86 [15.61]
B:BD[15.2417] → [15.2417:2460]
```
            .extract(file, existing, self)
```
[15.2417]
[15.2460]
```
            .extract(buffer, existing, self)
```

Replacement in importers/amazon/src/order_history.rs at line 90 [15.61]

B:BD[15.2507] → [15.2507:2589]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[15.2507]

[15.2589]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/amazon/src/order_history.rs at line 94 [15.61]

B:BD[15.2641] → [15.2641:2712]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {

[15.2641]

[15.2712]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/amazon/src/order_history.rs at line 126 [15.61]
B:BD[15.3623] → [15.3623:3669]
```
            .identify(file, EXPECTED_HEADERS)
```
[15.3623]
[15.3669]
```
            .identify(buffer, EXPECTED_HEADERS)
```
Deletion in importers/amazon/src/order_history.rs at line 151 [15.61]
B:BD[15.4198] → [4.34187:34209]
∅:D[4.34209] → [15.4442:4443]
B:BD[15.4442] → [15.4442:4443]
```
        dbg!(record);
```
Deletion in importers/amazon/src/gift_card_balance.rs at line 16 [15.8553]
B:BD[15.9038] → [15.9038:9060]
```
use camino::Utf8Path;
```

Replacement in importers/amazon/src/gift_card_balance.rs at line 113 [15.8553]

B:BD[15.11970] → [15.11970:12044]

    fn account(&self, _file: &Utf8Path) -> Result<Account, Self::Error> {

[15.11970]

[15.12044]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/amazon/src/gift_card_balance.rs at line 117 [15.8553]

B:BD[15.12109] → [15.12109:12184]

    fn date(&self, file: &Utf8Path) -> Option<Result<Date, Self::Error>> {

[15.12109]

[15.12184]

    fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in importers/amazon/src/gift_card_balance.rs at line 119 [15.8553]
B:BD[15.12206] → [15.12206:12236]
```
            .date(file, self)
```
[15.12206]
[15.12236]
```
            .date(buffer, self)
```
Replacement in importers/amazon/src/gift_card_balance.rs at line 125 [15.8553]
B:BD[15.12335] → [15.12335:12360]
```
        file: &Utf8Path,
```
[15.12335]
[15.12360]
```
        buffer: &[u8],
```
Replacement in importers/amazon/src/gift_card_balance.rs at line 129 [15.8553]
B:BD[15.12462] → [15.12462:12506]
```
            .extract(file, _existing, self)
```
[15.12462]
[15.12506]
```
            .extract(buffer, _existing, self)
```

Replacement in importers/amazon/src/gift_card_balance.rs at line 133 [15.8553]

B:BD[15.12556] → [15.12556:12638]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[15.12556]

[15.12638]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/amazon/src/gift_card_balance.rs at line 137 [15.8553]

B:BD[15.12706] → [15.12706:12777]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {

[15.12706]

[15.12777]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/amazon/src/gift_card_balance.rs at line 141 [15.8553]
B:BD[15.12878] → [15.12878:12924]
```
            .identify(file, EXPECTED_HEADERS)
```
[15.12878]
[15.12924]
```
            .identify(buffer, EXPECTED_HEADERS)
```
Deletion in importers/amazon/src/digital_items.rs at line 15 [15.18529]
B:BD[15.18990] → [15.18990:19012]
```
use camino::Utf8Path;
```

Replacement in importers/amazon/src/digital_items.rs at line 67 [15.18529]

B:BD[15.20230] → [15.20230:20304]

    fn account(&self, _file: &Utf8Path) -> Result<Account, Self::Error> {

[15.20230]

[15.20304]

    fn account(&self, _buffer: &[u8]) -> Result<Account, Self::Error> {

Replacement in importers/amazon/src/digital_items.rs at line 71 [15.18529]

B:BD[15.20366] → [15.20366:20447]

    fn date(&self, file: &Utf8Path) -> Option<Result<time::Date, Self::Error>> {

[15.20366]

[15.20447]

    fn date(&self, buffer: &[u8]) -> Option<Result<time::Date, Self::Error>> {

Replacement in importers/amazon/src/digital_items.rs at line 73 [15.18529]
B:BD[15.20469] → [15.20469:20499]
```
            .date(file, self)
```
[15.20469]
[15.20499]
```
            .date(buffer, self)
```
Replacement in importers/amazon/src/digital_items.rs at line 79 [15.18529]
B:BD[15.20598] → [15.20598:20623]
```
        file: &Utf8Path,
```
[15.20598]
[15.20623]
```
        buffer: &[u8],
```
Replacement in importers/amazon/src/digital_items.rs at line 83 [15.18529]
B:BD[15.20724] → [15.20724:20767]
```
            .extract(file, existing, self)
```
[15.20724]
[15.20767]
```
            .extract(buffer, existing, self)
```

Replacement in importers/amazon/src/digital_items.rs at line 87 [15.18529]

B:BD[15.20814] → [15.20814:20896]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[15.20814]

[15.20896]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in importers/amazon/src/digital_items.rs at line 91 [15.18529]

B:BD[15.20955] → [15.20955:21026]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error> {

[15.20955]

[15.21026]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error> {

Replacement in importers/amazon/src/digital_items.rs at line 144 [15.18529]
B:BD[15.22706] → [15.22706:22752]
```
            .identify(file, EXPECTED_HEADERS)
```
[15.22706]
[15.22752]
```
            .identify(buffer, EXPECTED_HEADERS)
```
Deletion in importers/amazon/Cargo.toml at line 18 [15.27131]
B:BD[15.27612] → [15.27612:27644]
```
camino.workspace         = true
```
Deletion in framework/src/utilities.rs at line 13 [8.1]
∅:D[5.10226] → [8.272:294]
B:BD[8.272] → [8.272:294]
```
use camino::Utf8Path;
```

Replacement in framework/src/utilities.rs at line 51 [8.1]

B:BD[5.10819] → [5.10819:11147]

            fn account(&self, file: &Utf8Path) -> Result<Account, Self::Error>;
            fn date(&self, file: &Utf8Path) -> Option<Result<Date, Self::Error>>;
            fn filename(&self, file: &Utf8Path) -> Option<Result<String, Self::Error>>;
            fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error>;

[5.10819]

[5.11147]

            fn account(&self, buffer: &[u8]) -> Result<Account, Self::Error>;
            fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>>;
            fn filename(&self, buffer: &[u8]) -> Option<Result<String, Self::Error>>;
            fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error>;

Replacement in framework/src/utilities.rs at line 62 [8.1]
B:BD[5.11282] → [5.11282:11315]
```
        file: &camino::Utf8Path,
```
[5.11282]
[5.11315]
```
        buffer: &[u8],
```

Replacement in framework/src/utilities.rs at line 65 [8.1]

B:BD[5.11394] → [5.11394:11460]

        let mut directives = self.inner.extract(file, existing)?;

[5.11394]

[5.11460]

        let mut directives = self.inner.extract(buffer, existing)?;

Replacement in framework/src/utilities.rs at line 158 [8.1]

B:BD[8.2121] → [8.2121:2449]

            fn account(&self, file: &Utf8Path) -> Result<Account, Self::Error>;
            fn date(&self, file: &Utf8Path) -> Option<Result<Date, Self::Error>>;
            fn filename(&self, file: &Utf8Path) -> Option<Result<String, Self::Error>>;
            fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error>;

[8.2121]

[8.2449]

            fn account(&self, buffer: &[u8]) -> Result<Account, Self::Error>;
            fn date(&self, buffer: &[u8]) -> Option<Result<Date, Self::Error>>;
            fn filename(&self, buffer: &[u8]) -> Option<Result<String, Self::Error>>;
            fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error>;

Replacement in framework/src/utilities.rs at line 169 [8.1]
B:BD[8.2584] → [8.2584:2617]
```
        file: &camino::Utf8Path,
```
[8.2584]
[8.2617]
```
        buffer: &[u8],
```

Replacement in framework/src/utilities.rs at line 172 [8.1]

B:BD[8.2696] → [8.2696:2758]

        let directives = self.inner.extract(file, existing)?;

[8.2696]

[8.2758]

        let directives = self.inner.extract(buffer, existing)?;

Replacement in framework/src/runner.rs at line 173 [16.41]

B:BD[16.4153] → [16.4153:4293]

    #[tracing::instrument(skip(self))]
    fn identify_file(&self, file: &Utf8Path) -> Option<&dyn ImporterProtocol<Error = ErrorReport>> {

[16.4153]

[16.4293]

    #[tracing::instrument(skip(self, buffer))]
    fn identify_file(&self, buffer: &[u8]) -> Option<&dyn ImporterProtocol<Error = ErrorReport>> {

Replacement in framework/src/runner.rs at line 177 [16.41]

B:BD[16.4336] → [16.4336:4410]

            .find(|importer| importer.identify(file).unwrap_or_default())

[16.4336]

[16.4410]

            .find(|importer| importer.identify(buffer).unwrap_or_default())

Replacement in framework/src/runner.rs at line 199 [16.41]

B:BD[16.5044] → [16.5044:5105]

        let Some(importer) = self.identify_file(file) else {

[16.5044]

[16.5105]

        let buffer = std::fs::read(file).into_diagnostic()?;
        let Some(importer) = self.identify_file(&buffer) else {

Replacement in framework/src/runner.rs at line 206 [16.41]

B:BD[17.1140] → [3.260:323]

        let destination = archive::file_name(importer, file)?;

[17.1140]

[16.5437]

        let destination = archive::file_name(importer, file, &buffer)?;

Replacement in framework/src/runner.rs at line 209 [16.41]

B:BD[16.5486] → [3.324:391]

            .extract(file, &[]) // TODO load existing transactions

[16.5486]

[16.5554]

            .extract(&buffer, &[]) // TODO load existing transactions

Insertion in framework/src/runner/archive.rs at line 16 [16.6584]
[16.6975]
[17.1803]
```
    buffer: &[u8],
```
Replacement in framework/src/runner/archive.rs at line 18 [16.6584]
∅:D[17.1834] → [16.7028:7071]
B:BD[16.7028] → [16.7028:7071]
```
    let account = importer.account(file)?;
```
[17.1834]
[16.7071]
```
    let account = importer.account(buffer)?;
```

Replacement in framework/src/runner/archive.rs at line 20 [16.6584]

B:BD[16.7072] → [16.7072:7128]

    let binding = importer.filename(file).transpose()?;

[16.7072]

[16.7128]

    let binding = importer.filename(buffer).transpose()?;

Replacement in framework/src/runner/archive.rs at line 25 [16.6584]

B:BD[16.7227] → [16.7227:7282]

    let date = importer.date(file).unwrap_or_else(|| {

[16.7227]

[16.7282]

    let date = importer.date(buffer).unwrap_or_else(|| {

Deletion in framework/src/lib.rs at line 11 [16.8719]
B:BD[16.8902] → [16.8902:8924]
```
use camino::Utf8Path;
```

Replacement in framework/src/lib.rs at line 21 [16.8719]

B:BD[16.9028] → [16.9028:9100]

    fn account(&self, file: &Utf8Path) -> Result<Account, Self::Error>;

[16.9028]

[16.9100]

    fn account(&self, buffer: &[u8]) -> Result<Account, Self::Error>;

Replacement in framework/src/lib.rs at line 23 [16.8719]

B:BD[16.9101] → [16.9101:9177]

    fn date(&self, _file: &Utf8Path) -> Option<Result<Date, Self::Error>> {

[16.9101]

[16.9177]

    fn date(&self, _buffer: &[u8]) -> Option<Result<Date, Self::Error>> {

Replacement in framework/src/lib.rs at line 27 [16.8719]

B:BD[16.9197] → [16.9197:9331]

    fn extract(
        &self,
        file: &Utf8Path,
        existing: &[Directive],
    ) -> Result<Vec<Directive>, Self::Error>;

[16.9197]

[16.9331]

    fn extract(&self, buffer: &[u8], existing: &[Directive])
        -> Result<Vec<Directive>, Self::Error>;

Replacement in framework/src/lib.rs at line 30 [16.8719]

B:BD[16.9332] → [16.9332:9414]

    fn filename(&self, _file: &Utf8Path) -> Option<Result<String, Self::Error>> {

[16.9332]

[16.9414]

    fn filename(&self, _buffer: &[u8]) -> Option<Result<String, Self::Error>> {

Replacement in framework/src/lib.rs at line 34 [16.8719]

B:BD[16.9434] → [16.9434:9504]

    fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error>;

[16.9434]

[16.9504]

    fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error>;

Replacement in framework/src/lib.rs at line 50 [16.8719]

B:BD[16.9738] → [16.9738:10178]

            fn account(&self, file: &Utf8Path) -> Result<Account, Self::Error>;
            fn date(&self, _file: &Utf8Path) -> Option<Result<Date, Self::Error>>;
            fn extract(&self, file: &Utf8Path, existing: &[Directive]) -> Result<Vec<Directive>, Self::Error>;
            fn filename(&self, file: &Utf8Path) -> Option<Result<String, Self::Error>>;
            fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error>;

[16.9738]

[16.10178]

            fn account(&self, buffer: &[u8]) -> Result<Account, Self::Error>;
            fn date(&self, _buffer: &[u8]) -> Option<Result<Date, Self::Error>>;
            fn extract(&self, buffer: &[u8], existing: &[Directive]) -> Result<Vec<Directive>, Self::Error>;
            fn filename(&self, buffer: &[u8]) -> Option<Result<String, Self::Error>>;
            fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error>;

Replacement in framework/src/lib.rs at line 69 [16.8719]

B:BD[16.10428] → [16.10428:10868]

            fn account(&self, file: &Utf8Path) -> Result<Account, Self::Error>;
            fn date(&self, _file: &Utf8Path) -> Option<Result<Date, Self::Error>>;
            fn extract(&self, file: &Utf8Path, existing: &[Directive]) -> Result<Vec<Directive>, Self::Error>;
            fn filename(&self, file: &Utf8Path) -> Option<Result<String, Self::Error>>;
            fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error>;

[16.10428]

[16.10868]

            fn account(&self, buffer: &[u8]) -> Result<Account, Self::Error>;
            fn date(&self, _buffer: &[u8]) -> Option<Result<Date, Self::Error>>;
            fn extract(&self, buffer: &[u8], existing: &[Directive]) -> Result<Vec<Directive>, Self::Error>;
            fn filename(&self, buffer: &[u8]) -> Option<Result<String, Self::Error>>;
            fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error>;

Replacement in framework/src/lib.rs at line 88 [16.8719]

B:BD[16.11118] → [16.11118:11558]

            fn account(&self, file: &Utf8Path) -> Result<Account, Self::Error>;
            fn date(&self, _file: &Utf8Path) -> Option<Result<Date, Self::Error>>;
            fn extract(&self, file: &Utf8Path, existing: &[Directive]) -> Result<Vec<Directive>, Self::Error>;
            fn filename(&self, file: &Utf8Path) -> Option<Result<String, Self::Error>>;
            fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error>;

[16.11118]

[16.11558]

            fn account(&self, buffer: &[u8]) -> Result<Account, Self::Error>;
            fn date(&self, _buffer: &[u8]) -> Option<Result<Date, Self::Error>>;
            fn extract(&self, buffer: &[u8], existing: &[Directive]) -> Result<Vec<Directive>, Self::Error>;
            fn filename(&self, buffer: &[u8]) -> Option<Result<String, Self::Error>>;
            fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error>;

Replacement in framework/src/lib.rs at line 107 [16.8719]

B:BD[16.11807] → [16.11807:12247]

            fn account(&self, file: &Utf8Path) -> Result<Account, Self::Error>;
            fn date(&self, _file: &Utf8Path) -> Option<Result<Date, Self::Error>>;
            fn extract(&self, file: &Utf8Path, existing: &[Directive]) -> Result<Vec<Directive>, Self::Error>;
            fn filename(&self, file: &Utf8Path) -> Option<Result<String, Self::Error>>;
            fn identify(&self, file: &Utf8Path) -> Result<bool, Self::Error>;

[16.11807]

[16.12247]

            fn account(&self, buffer: &[u8]) -> Result<Account, Self::Error>;
            fn date(&self, _buffer: &[u8]) -> Option<Result<Date, Self::Error>>;
            fn extract(&self, buffer: &[u8], existing: &[Directive]) -> Result<Vec<Directive>, Self::Error>;
            fn filename(&self, buffer: &[u8]) -> Option<Result<String, Self::Error>>;
            fn identify(&self, buffer: &[u8]) -> Result<bool, Self::Error>;

Deletion in Cargo.toml at line 38 [19.9831]
B:BD[18.91793636] → [18.91793636:91793667]
```
iban_validate        = "4.0.1"
```

Insertion in Cargo.toml at line 97 [19.9831]

[8.5088]

[20.1583]


[workspace.dependencies.iban_validate]
features = ["serde"]
version  = "4.0.1"

Deletion in Cargo.lock at line 64 [19.9916]
B:BD[21.350] → [21.350:361]
```
 "camino",
```
Deletion in Cargo.lock at line 130 [19.9916]
B:BD[22.638] → [22.638:649]
```
 "camino",
```
Deletion in Cargo.lock at line 242 [19.9916]
B:BD[9.21339] → [9.21339:21350]
```
 "camino",
```
Deletion in Cargo.lock at line 474 [19.9916]
B:BD[13.10005] → [13.10005:10016]
```
 "camino",
```
Deletion in Cargo.lock at line 757 [19.9916]
B:BD[21.642] → [21.642:653]
```
 "camino",
```
Deletion in Cargo.lock at line 1012 [19.9916]
B:BD[22.1548] → [22.1548:1559]
```
 "camino",
```
Insertion in Cargo.lock at line 1559 [19.9916]
[18.91795939]
[23.17989]
```
 "serde",
```
Deletion in Cargo.lock at line 2640 [19.9916]
B:BD[7.15849] → [7.15849:15860]
```
 "camino",
```
Deletion in Cargo.lock at line 4117 [19.9916]
B:BD[6.15457] → [6.15457:15468]
```
 "camino",
```
Deletion in Cargo.lock at line 4211 [19.9916]
B:BD[5.12898] → [5.12898:12909]
```
 "camino",
```