cryptix/caberl - Change NBMKIBO6UJKXCOXXVPPENLEBYI4YOU2VCHH5KIOUGH7WJG47N4PQC

erlfmt

Created by Henry on September 10, 2025

NBMKIBO6UJKXCOXXVPPENLEBYI4YOU2VCHH5KIOUGH7WJG47N4PQC

Dependencies

In channels

main

Change contents

Deletion in test/cable_posts_SUITE.erl at line 8 [7.2]
B:BD[7.165] → [8.2:3]
Replacement in test/cable_posts_SUITE.erl at line 14 [7.2]
B:BD[8.79] → [9.26:50]
```
    Chan =  <<"#foo">>,
```
[8.79]
[8.134]
```
    Chan = <<"#foo">>,
```

Replacement in test/cable_posts_SUITE.erl at line 16 [7.2]

B:BD[8.170] → [8.170:226]

    Post = posts:encode(TestKp, [], {text,Chan, Text}),

[8.170]

[8.226]

    Post = posts:encode(TestKp, [], {text, Chan, Text}),

Replacement in test/cable_posts_SUITE.erl at line 19 [7.2]

B:BD[8.266] → [10.26:55]

∅:D[10.80] → [8.290:313]

B:BD[8.290] → [8.290:313]

B:BD[8.313] → [10.81:98]

∅:D[10.98] → [8.334:365]

B:BD[8.334] → [8.334:365]

B:BD[8.365] → [10.99:120]

∅:D[10.120] → [8.365:429]

B:BD[8.365] → [8.365:429]

     [ {public_key, _Public}
     , {links, _Links}
     , {type, 0}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ],
     [ {channel, GotChan}
     , {text, GotText}
     ]

[8.266]

[8.429]

        [
            {public_key, _Public},
            {links, _Links},
            {type, 0},
            {timestamp, _TimeStamp},
            {hash, _Hash}
        ],
        [
            {channel, GotChan},
            {text, GotText}
        ]

Replacement in test/cable_posts_SUITE.erl at line 36 [7.2]
B:BD[11.83] → [11.83:111]
```
    Name =  "元気な子",
```
[11.83]
[11.111]
```
    Name = "元気な子",
```

Replacement in test/cable_posts_SUITE.erl at line 40 [7.2]

B:BD[11.210] → [11.210:387]

     [ {public_key, _Public}
     , {links, _Links}
     , {type, 2}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ],
     [ {infos, #{<<"name">> := BinName}}
     ]

[11.210]

[11.387]

        [
            {public_key, _Public},
            {links, _Links},
            {type, 2},
            {timestamp, _TimeStamp},
            {hash, _Hash}
        ],
        [{infos, #{<<"name">> := BinName}}]

Replacement in test/cable_posts_SUITE.erl at line 59 [7.2]

B:BD[12.41] → [10.191:220]

∅:D[10.245] → [12.66:89]

B:BD[12.66] → [12.66:89]

B:BD[12.89] → [10.246:263]

∅:D[10.263] → [12.118:149]

∅:D[8.558] → [12.118:149]

B:BD[12.118] → [12.118:149]

B:BD[12.149] → [10.264:285]

∅:D[10.285] → [12.149:210]

B:BD[12.149] → [12.149:210]

     [ {public_key, _PubKey}
     , {links, _Links}
     , {type, 0}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ],
     [ {channel, Channel}
     , {text, Text}
     ]

[12.41]

[7.474]

        [
            {public_key, _PubKey},
            {links, _Links},
            {type, 0},
            {timestamp, _TimeStamp},
            {hash, _Hash}
        ],
        [
            {channel, Channel},
            {text, Text}
        ]

Replacement in test/cable_posts_SUITE.erl at line 79 [7.2]

B:BD[12.250] → [10.286:315]

∅:D[10.340] → [12.275:298]

B:BD[12.275] → [12.275:298]

B:BD[12.298] → [10.341:358]

∅:D[10.358] → [12.327:358]

∅:D[8.580] → [12.327:358]

B:BD[12.327] → [12.327:358]

B:BD[12.358] → [10.359:380]

∅:D[10.380] → [12.358:392]

B:BD[12.358] → [12.358:392]

     [ {public_key, _PubKey}
     , {links, _Links}
     , {type, 1}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ],
     [ {hashes, Hashes} ]

[12.250]

[7.871]

        [
            {public_key, _PubKey},
            {links, _Links},
            {type, 1},
            {timestamp, _TimeStamp},
            {hash, _Hash}
        ],
        [{hashes, Hashes}]

Replacement in test/cable_posts_SUITE.erl at line 96 [7.2]

B:BD[12.432] → [10.457:486]

B:BD[10.511] → [10.511:635]

     [ {public_key, _PubKey}
     , {links, _Links}
     , {type, 2}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ],
     [ {infos, Infos} ]

[12.432]

[7.1278]

        [
            {public_key, _PubKey},
            {links, _Links},
            {type, 2},
            {timestamp, _TimeStamp},
            {hash, _Hash}
        ],
        [{infos, Infos}]

Replacement in test/cable_posts_SUITE.erl at line 112 [7.2]

B:BD[12.618] → [10.693:722]

∅:D[10.747] → [12.643:666]

B:BD[12.643] → [12.643:666]

B:BD[12.666] → [10.748:765]

∅:D[8.625] → [12.695:726]

∅:D[10.765] → [12.695:726]

B:BD[12.695] → [12.695:726]

B:BD[12.726] → [10.766:787]

∅:D[10.787] → [12.726:789]

B:BD[12.726] → [12.726:789]

     [ {public_key, _PubKey}
     , {links, _Links}
     , {type, 3}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ],
     [ {channel, Channel}
     , {topic, Topic}
     ]

[12.618]

[7.1655]

        [
            {public_key, _PubKey},
            {links, _Links},
            {type, 3},
            {timestamp, _TimeStamp},
            {hash, _Hash}
        ],
        [
            {channel, Channel},
            {topic, Topic}
        ]

Replacement in test/cable_posts_SUITE.erl at line 132 [7.2]

B:BD[12.829] → [10.788:817]

B:BD[10.842] → [10.842:970]

∅:D[10.970] → [12.979:995]

B:BD[12.979] → [12.979:995]

     [ {public_key, _PubKey}
     , {links, _Links}
     , {type, 4}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ],
     [ {channel, Channel} ]
    ]= Decoded,

[12.829]

[7.2095]

        [
            {public_key, _PubKey},
            {links, _Links},
            {type, 4},
            {timestamp, _TimeStamp},
            {hash, _Hash}
        ],
        [{channel, Channel}]
    ] = Decoded,

Replacement in test/cable_posts_SUITE.erl at line 148 [7.2]

B:BD[12.1035] → [10.971:1000]

B:BD[10.1025] → [10.1025:1148]

     [ {public_key, _PubKey}
     , {links, _Links}
     , {type, 5}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ], [ {channel, Channel} ]

[12.1035]

[7.2447]

        [
            {public_key, _PubKey},
            {links, _Links},
            {type, 5},
            {timestamp, _TimeStamp},
            {hash, _Hash}
        ],
        [{channel, Channel}]

Replacement in test/cable_posts_SUITE.erl at line 164 [7.2]

B:BD[12.1217] → [10.1208:1297]

    ?assertEqual(maps:get(<<"postType">>, TestObj),  proplists:get_value(type, Header)),

[12.1217]

[12.1310]

    ?assertEqual(maps:get(<<"postType">>, TestObj), proplists:get_value(type, Header)),

Replacement in test/cable_posts_SUITE.erl at line 166 [7.2]

B:BD[12.1404] → [12.1404:1506]

    ?assertEqual(length(maps:get(<<"links">>, TestObj)), length(proplists:get_value(links, Header))),

[12.1404]

[7.2895]

    ?assertEqual(
        length(maps:get(<<"links">>, TestObj)), length(proplists:get_value(links, Header))
    ),

Replacement in test/cable_peer_suite.erl at line 32 [15.3]
∅:D[13.31] → [14.195:251]
∅:D[11.696] → [14.195:251]
B:BD[14.195] → [14.195:251]
```
    [A, B] = [make_test_args() || _ <- lists:seq(1,2)],
```
[13.31]
[14.251]
```
    [A, B] = [make_test_args() || _ <- lists:seq(1, 2)],
```

Replacement in test/cable_peer_suite.erl at line 56 [15.3]

B:BD[11.736] → [11.736:792]

    [A, B] = [make_test_args() || _ <- lists:seq(1,2)],

[11.736]

[11.792]

    [A, B] = [make_test_args() || _ <- lists:seq(1, 2)],

Replacement in test/cable_peer_suite.erl at line 70 [15.3]
B:BD[11.1112] → [11.1112:1149]
```
    T =  "the mega testing channel",
```
[11.1112]
[11.1149]
```
    T = "the mega testing channel",
```

Replacement in test/cable_peer_suite.erl at line 80 [15.3]

B:BD[11.1403] → [3.3:74]

∅:D[3.74] → [11.1473:1551]

B:BD[11.1473] → [11.1473:1551]

B:BD[11.1552] → [11.1552:1687]

B:BD[11.1687] → [13.32:115]

∅:D[13.115] → [11.1763:1868]

B:BD[11.1763] → [11.1763:1868]

B:BD[11.1868] → [13.116:199]

∅:D[13.199] → [11.1944:2076]

B:BD[11.1944] → [11.1944:2076]

                         {ok, CState} = peer:channel_members(Peer, C),
                         ?assertEqual(T, proplists:get_value(topic, CState)),
                         Members = proplists:get_value(members, CState),
                         ?assertEqual(2, maps:size(Members)),
                         {AlfiName, AlfiWhen, false} = maps:get(PubAlfi, Members),
                         ?assertEqual("Alfi", AlfiName),
                         ?assert(AlfiWhen > 0),
                         {BertName, BertWhen, false} = maps:get(PubBert, Members),
                         ?assertEqual("Not Ernie!", BertName),
                         ?assert(BertWhen > 0)
                 end,

[11.1403]

[11.2076]

        {ok, CState} = peer:channel_members(Peer, C),
        ?assertEqual(T, proplists:get_value(topic, CState)),
        Members = proplists:get_value(members, CState),
        ?assertEqual(2, maps:size(Members)),
        {AlfiName, AlfiWhen, false} = maps:get(PubAlfi, Members),
        ?assertEqual("Alfi", AlfiName),
        ?assert(AlfiWhen > 0),
        {BertName, BertWhen, false} = maps:get(PubBert, Members),
        ?assertEqual("Not Ernie!", BertName),
        ?assert(BertWhen > 0)
    end,

Deletion in test/cable_peer_suite.erl at line 96 [15.3]
B:BD[13.254] → [13.254:255]

Replacement in test/cable_peer_suite.erl at line 97 [15.3]

B:BD[13.270] → [13.270:326]

    [A, B] = [make_test_args() || _ <- lists:seq(1,2)],

[13.270]

[13.326]

    [A, B] = [make_test_args() || _ <- lists:seq(1, 2)],

Replacement in test/cable_peer_suite.erl at line 104 [15.3]
B:BD[13.498] → [13.498:522]
```
    NickAlfi =  "Alfi",
```
[13.498]
[13.522]
```
    NickAlfi = "Alfi",
```
Replacement in test/cable_peer_suite.erl at line 116 [15.3]
B:BD[13.788] → [13.788:830]
```
    timer:sleep(500), %% enforce ordering
```
[13.788]
[13.830]
```
    %% enforce ordering
    timer:sleep(500),
```

Replacement in test/cable_peer_suite.erl at line 125 [15.3]

B:BD[13.993] → [13.993:1429]

                    {ok, {Texts, Users}} = peer:read(Peer, C),
                    [{UserIdAlfi, _, T1}, {UserIdBert, _, T2}] =  Texts,
                    {AlfiInfo, UsersSansAlfi} = maps:take(UserIdAlfi, Users),
                    ?assertEqual({NickAlfi, PubAlfi}, AlfiInfo),
                    {BertInfo, #{}} = maps:take(UserIdBert, UsersSansAlfi),
                    ?assertEqual({NickBert, PubBert}, BertInfo)
            end,

[13.993]

[13.1429]

        {ok, {Texts, Users}} = peer:read(Peer, C),
        [{UserIdAlfi, _, T1}, {UserIdBert, _, T2}] = Texts,
        {AlfiInfo, UsersSansAlfi} = maps:take(UserIdAlfi, Users),
        ?assertEqual({NickAlfi, PubAlfi}, AlfiInfo),
        {BertInfo, #{}} = maps:take(UserIdBert, UsersSansAlfi),
        ?assertEqual({NickBert, PubBert}, BertInfo)
    end,

Replacement in test/cable_peer_suite.erl at line 153 [15.3]

B:BD[16.45] → [16.45:680]

B:BD[16.742] → [16.742:801]

B:BD[16.855] → [16.855:1016]

    Table = [ { "Two hands clap and there is a sound. What is the sound of one hand?"
              , "fcd7c41883c3564c5a6abec78e214159efe62d50f124b4afafc184ea3b764cd4"}
            , { "茶色"
              , "46b321c236880cd861dafae3040cf8cc52990516d1a69ab2c170b1e615a7ebd5"}
            , { "elf"
              , "ffe809405a3e1eaf77938bde2138832b177a51e47df02935edc12aacf8279f61"}
            , { "love collapses spacetime"
              , "fea16c09f8aa581500fcf6ee2f6aabc59ccaa271d2a3568843930b7ff929ad86"}
            ],
    lists:foreach(fun({InStr, Want}) ->
                          In = unicode:characters_to_binary(InStr),
                          Got = enacl:generichash(32, In),
                          GotHex = hex:bin_to_hexstr(Got),
                          ?assertEqual(Want, string:lowercase(GotHex))
                  end, Table).

[16.45]

[11.2196]

    Table = [
        {"Two hands clap and there is a sound. What is the sound of one hand?",
            "fcd7c41883c3564c5a6abec78e214159efe62d50f124b4afafc184ea3b764cd4"},
        {"茶色", "46b321c236880cd861dafae3040cf8cc52990516d1a69ab2c170b1e615a7ebd5"},
        {"elf", "ffe809405a3e1eaf77938bde2138832b177a51e47df02935edc12aacf8279f61"},
        {"love collapses spacetime",
            "fea16c09f8aa581500fcf6ee2f6aabc59ccaa271d2a3568843930b7ff929ad86"}
    ],
    lists:foreach(
        fun({InStr, Want}) ->
            In = unicode:characters_to_binary(InStr),
            Got = enacl:generichash(32, In),
            GotHex = hex:bin_to_hexstr(Got),
            ?assertEqual(Want, string:lowercase(GotHex))
        end,
        Table
    ).

Replacement in test/cable_peer_suite.erl at line 178 [15.3]

B:BD[11.2356] → [11.2356:2412]

    [ {listener, ["localhost", 0]}
    , {storage, S}].

[11.2356]

    [
        {listener, ["localhost", 0]},
        {storage, S}
    ].

Replacement in test/cable_database_suite.erl at line 10 [10.1367]

B:BD[10.1567] → [10.1567:1658]

            atom_to_list(element(2, element(2, process_info(self(), current_function))))).

[10.1567]

[10.1658]

    atom_to_list(element(2, element(2, process_info(self(), current_function))))
).

Replacement in test/cable_database_suite.erl at line 35 [10.1367]

B:BD[9.398] → [9.398:648]

    Examples = [ examples:post_text()
               , examples:post_delete()
               , examples:post_info()
               , examples:post_topic()
               , examples:post_join()
               , examples:post_leave()
               ],

[9.398]

[9.648]

    Examples = [
        examples:post_text(),
        examples:post_delete(),
        examples:post_info(),
        examples:post_topic(),
        examples:post_join(),
        examples:post_leave()
    ],

Replacement in test/cable_database_suite.erl at line 45 [10.1367]

B:BD[9.714] → [17.491:538]

∅:D[17.538] → [9.758:806]

B:BD[9.758] → [9.758:806]

B:BD[9.806] → [18.212:257]

                   [_, {binary, Bin}, _] = Ex,
                   Decoded = posts:decode(Bin),
                   [Header, Body] = Decoded,

[9.714]

[9.848]

        [_, {binary, Bin}, _] = Ex,
        Decoded = posts:decode(Bin),
        [Header, Body] = Decoded,

Replacement in test/cable_database_suite.erl at line 49 [10.1367]

B:BD[9.849] → [19.265:333]

∅:D[20.123] → [9.905:949]

∅:D[18.319] → [9.905:949]

∅:D[19.333] → [9.905:949]

B:BD[9.905] → [9.905:949]

                   {ok, Id, Hash} = db:save_post(Db, Decoded, Bin),
                   ?assert(is_integer(Id)),

[9.849]

[9.949]

        {ok, Id, Hash} = db:save_post(Db, Decoded, Bin),
        ?assert(is_integer(Id)),

Replacement in test/cable_database_suite.erl at line 52 [10.1367]

B:BD[9.950] → [19.334:421]

∅:D[19.421] → [18.406:561]

B:BD[18.406] → [18.406:561]

                   {ok, [LoadedHeader, LoadedBody, LoadedBin]} = db:load_post(Db, Id),
                   ?assertEqual(Header, LoadedHeader),
                   ?assertEqual(Body, LoadedBody),
                   ?assertEqual(Bin, LoadedBin),

[9.950]

[9.1063]

        {ok, [LoadedHeader, LoadedBody, LoadedBin]} = db:load_post(Db, Id),
        ?assertEqual(Header, LoadedHeader),
        ?assertEqual(Body, LoadedBody),
        ?assertEqual(Bin, LoadedBin),

Replacement in test/cable_database_suite.erl at line 57 [10.1367]

B:BD[9.1064] → [9.1064:1125]

B:BD[9.1125] → [19.422:511]

                   Hash = proplists:get_value(hash, Header),
                   {ok, [LoadedHeader, LoadedBody, LoadedBin]} = db:load_post(Db, Hash),

[9.1064]

[16.1241]

        Hash = proplists:get_value(hash, Header),
        {ok, [LoadedHeader, LoadedBody, LoadedBin]} = db:load_post(Db, Hash),

Replacement in test/cable_database_suite.erl at line 60 [10.1367]
B:BD[16.1242] → [19.512:562]
∅:D[19.562] → [9.1243:1259]
∅:D[18.649] → [9.1243:1259]
∅:D[16.1291] → [9.1243:1259]
B:BD[9.1243] → [9.1243:1259]
```
                   ?assert(db:has_post(Db, Hash))
           end,
```
[16.1242]
[9.1259]
```
        ?assert(db:has_post(Db, Hash))
    end,
```

Replacement in test/cable_database_suite.erl at line 74 [10.1367]

B:BD[19.856] → [19.856:944]

    {ok, [GotHash]} = db:get_text_hashes_by_time_range(Db, "default", Ts-10, Ts+10, 1),

[19.856]

[19.944]

    {ok, [GotHash]} = db:get_text_hashes_by_time_range(Db, "default", Ts - 10, Ts + 10, 1),

Replacement in test/cable_basic_SUITE.erl at line 13 [22.22]

B:BD[21.84] → [21.84:139]

    [Header,  [{ttl, 1}, {hashes, Hashes}]] = Decoded,

[21.84]

[23.88]

    [Header, [{ttl, 1}, {hashes, Hashes}]] = Decoded,

Replacement in test/cable_basic_SUITE.erl at line 18 [22.22]
B:BD[24.106] → [24.106:137]
```
    % TODO: assert hash values
```
[24.106]
[22.783]
```
% TODO: assert hash values
```

Replacement in test/cable_basic_SUITE.erl at line 24 [22.22]

B:BD[21.222] → [25.3:62]

    [Header, [ {ttl, 1}, {cancelId, CancelId}]] = Decoded,

[21.222]

[23.235]

    [Header, [{ttl, 1}, {cancelId, CancelId}]] = Decoded,

Replacement in test/cable_basic_SUITE.erl at line 33 [22.22]

∅:D[21.364] → [26.186:211]

B:BD[26.186] → [26.186:211]

∅:D[26.211] → [27.1268:1379]

∅:D[23.390] → [27.1268:1379]

B:BD[27.1268] → [27.1268:1379]

B:BD[27.1379] → [26.212:230]

    [Header, [ {ttl, 1},
        {channel, Channel},
        {timestart, TimeStart},
        {timeend, TimeEnd},
        {limit, Limit}
    ]] = Decoded,

[21.364]

[23.391]

    [
        Header,
        [
            {ttl, 1},
            {channel, Channel},
            {timestart, TimeStart},
            {timeend, TimeEnd},
            {limit, Limit}
        ]
    ] = Decoded,

Replacement in test/cable_basic_SUITE.erl at line 55 [22.22]

∅:D[21.447] → [26.269:294]

B:BD[26.269] → [26.269:294]

∅:D[26.294] → [23.855:908]

B:BD[23.855] → [23.855:908]

B:BD[23.908] → [26.295:313]

    [Header, [ {ttl, 1},
        {channel, Channel},
        {future, Future}
    ]] = Decoded,

[21.447]

[23.925]

    [
        Header,
        [
            {ttl, 1},
            {channel, Channel},
            {future, Future}
        ]
    ] = Decoded,

Replacement in test/cable_basic_SUITE.erl at line 70 [22.22]

B:BD[23.1109] → [17.898:979]

    [{name, _},{binary, Bin}, {obj, TestObj}] = examples:channel_list_request(),

[23.1109]

[21.448]

    [{name, _}, {binary, Bin}, {obj, TestObj}] = examples:channel_list_request(),

Replacement in test/cable_basic_SUITE.erl at line 73 [22.22]

∅:D[21.530] → [26.352:377]

B:BD[26.352] → [26.352:377]

∅:D[26.377] → [23.1266:1307]

B:BD[23.1266] → [23.1266:1307]

B:BD[23.1307] → [26.378:396]

    [Header, [ {ttl, 1},
        {offset, 0},
        {limit, 20}
    ]] = Decoded,

[21.530]

[28.414]

    [
        Header,
        [
            {ttl, 1},
            {offset, 0},
            {limit, 20}
        ]
    ] = Decoded,

Replacement in test/cable_basic_SUITE.erl at line 88 [22.22]
∅:D[21.613] → [26.435:482]
B:BD[26.435] → [26.435:482]
```
    [ Header, [ {hashes, Hashes} ]] = Decoded,
```
[21.613]
[28.671]
```
    [Header, [{hashes, Hashes}]] = Decoded,
```
Replacement in test/cable_basic_SUITE.erl at line 98 [22.22]
∅:D[21.696] → [26.1403:1448]
B:BD[26.1403] → [26.1403:1448]
```
    [ Header, [ {posts, Posts} ]] = Decoded,
```
[21.696]
[28.873]
```
    [Header, [{posts, Posts}]] = Decoded,
```

Replacement in test/cable_basic_SUITE.erl at line 108 [22.22]

∅:D[21.779] → [26.1487:1564]

B:BD[26.1487] → [26.1487:1564]

    [ Header, [ {channels, ["default", "dev", "introduction"]} ]] = Decoded,

[21.779]

[28.933]

    [Header, [{channels, ["default", "dev", "introduction"]}]] = Decoded,

Deletion in test/cable_basic_SUITE.erl at line 111 [22.22]
B:BD[29.887] → [26.1565:1566]
Deletion in test/cable_basic_SUITE.erl at line 135 [22.22]
∅:D[21.1735] → [29.2889:2890]
B:BD[29.2889] → [29.2889:2890]

Replacement in test/cable_basic_SUITE.erl at line 140 [22.22]

B:BD[21.1758] → [21.1758:1883]

    [{requestId, crypto:strong_rand_bytes(4)},
     {circuitId, crypto:strong_rand_bytes(4)},
     {ttl, rand:uniform(20)}].

[21.1758]

[23.1381]

    [
        {requestId, crypto:strong_rand_bytes(4)},
        {circuitId, crypto:strong_rand_bytes(4)},
        {ttl, rand:uniform(20)}
    ].

Replacement in shell.nix at line 5 [4.6]

B:BD[4.57] → [4.57:172]

  nativeBuildInputs = with pkgs.buildPackages; [ erlang_27 rebar3 libsodium sqlite] ++ [erlang-language-platform];

[4.57]

[4.172]

  nativeBuildInputs = with pkgs.buildPackages; [ erlang_27 rebar3 libsodium sqlite] ++ [erlang-language-platform erlfmt];

Replacement in rebar.config at line 12 [22.2882]

B:BD[22.3048] → [30.192:281]

∅:D[31.279] → [22.3048:3119]

∅:D[30.281] → [22.3048:3119]

B:BD[22.3048] → [22.3048:3119]

B:BD[22.3119] → [32.136:198]

∅:D[32.198] → [30.282:364]

B:BD[22.3119] → [30.282:364]

B:BD[30.364] → [32.199:287]

       {sqlite, {git, "https://github.com/processone/erlang-sqlite3", {tag, "1.1.15"}}},
       {b, {git, "https://github.com/b/hex.git", {branch, "master"}}},
       {jsone, "~> 1.8.1"},
       %% rebar/erlang v25 compat
       {enacl, {git, "https://github.com/helium/enacl.git", {branch, "master"}}},
       {enoise, {git, "https://github.com/cryptix/enoise.git", {branch, "enacl-fork"}}}

[22.3048]

[22.3174]

    {sqlite, {git, "https://github.com/processone/erlang-sqlite3", {tag, "1.1.15"}}},
    {b, {git, "https://github.com/b/hex.git", {branch, "master"}}},
    {jsone, "~> 1.8.1"},
    %% rebar/erlang v25 compat
    {enacl, {git, "https://github.com/helium/enacl.git", {branch, "master"}}},
    {enoise, {git, "https://github.com/cryptix/enoise.git", {branch, "enacl-fork"}}}

Replacement in rebar.config at line 20 [22.2882]

B:BD[22.3205] → [22.3205:3323]

{relx, [{release, { cable, {git, short} },
         [cable,
          debugger,
          runtime_tools]}
       ]
}.

[22.3205]

[22.3323]

{relx, [
    {release, {cable, {git, short}}, [
        cable,
        debugger,
        runtime_tools
    ]}
]}.

Replacement in rebar.config at line 28 [22.2882]

B:BD[22.3324] → [22.3324:3668]

{profiles, [{dev, [{erl_opts, [debug_info]},
                   {relx, [{dev_mode, true},
                            {include_erts, false}]}]
            },
            {prod, [{erl_opts, [no_debug_info, warnings_as_errors]},
                    {relx, [{dev_mode, false},
                            {include_erts, true}]}]
            }]
}.

[22.3324]

{profiles, [
    {dev, [
        {erl_opts, [debug_info]},
        {relx, [
            {dev_mode, true},
            {include_erts, false}
        ]}
    ]},
    {prod, [
        {erl_opts, [no_debug_info, warnings_as_errors]},
        {relx, [
            {dev_mode, false},
            {include_erts, true}
        ]}
    ]}
]}.

Replacement in flake.lock at line 23 [33.501]

B:BD[33.1028] → [4.901:1011]

        "lastModified": 1739482815,
        "narHash": "sha256-/5Lwtmp/8j+ro32gXzitucSdyjJ6QehfJCL58WNA7N0=",

[33.1028]

[33.1138]

        "lastModified": 1757034884,
        "narHash": "sha256-PgLSZDBEWUHpfTRfFyklmiiLBE1i1aGCtz4eRA3POao=",

Replacement in flake.lock at line 27 [33.501]

B:BD[33.1191] → [4.1012:1071]

        "rev": "ba0939c506a03c60a765cd7f7c43794816540eec",

[33.1191]

[33.1250]

        "rev": "ca77296380960cd497a765102eeb1356eb80fed0",

Replacement in apps/cable/src/wire.erl at line 8 [22.5336]

B:BD[26.1668] → [20.463:520]

B:BD[20.520] → [16.1623:1669]

∅:D[16.1669] → [20.567:739]

B:BD[20.567] → [20.567:739]

-export([encode_post_request/2, encode_cancel_request/2,
         encode_channel_time_range_request/5,
         encode_channel_state_request/3,
         encode_channel_list_request/3, encode_hash_response/2,
         encode_post_response/2, encode_channel_list_response/2]).

[26.1668]

[22.5390]

-export([
    encode_post_request/2,
    encode_cancel_request/2,
    encode_channel_time_range_request/5,
    encode_channel_state_request/3,
    encode_channel_list_request/3,
    encode_hash_response/2,
    encode_post_response/2,
    encode_channel_list_response/2
]).

Replacement in apps/cable/src/wire.erl at line 29 [22.5336]

B:BD[20.801] → [20.801:1019]

    [ {requestId, RequestId}
    , {circuitId, CircuitId}] = Header,
    length_encode_fields([ <<0>>, CircuitId, RequestId
                         , encode_varint(length(Hashes))
                         , Hashes]).

[20.801]

[20.1019]

    [
        {requestId, RequestId},
        {circuitId, CircuitId}
    ] = Header,
    length_encode_fields([
        <<0>>,
        CircuitId,
        RequestId,
        encode_varint(length(Hashes)),
        Hashes
    ]).

Replacement in apps/cable/src/wire.erl at line 42 [22.5336]

B:BD[20.1079] → [20.1079:1148]

    [ {requestId, RequestId}
    , {circuitId, CircuitId}] = Header,

[20.1079]

[20.1148]

    [
        {requestId, RequestId},
        {circuitId, CircuitId}
    ] = Header,

Replacement in apps/cable/src/wire.erl at line 47 [22.5336]

B:BD[20.1179] → [20.1179:1312]

                          PostLen = encode_varint(byte_size(Post)),
                          [PostLen, Post]
                  end,

[20.1179]

[20.1312]

        PostLen = encode_varint(byte_size(Post)),
        [PostLen, Post]
    end,

Replacement in apps/cable/src/wire.erl at line 51 [22.5336]

B:BD[20.1358] → [20.1358:1429]

    length_encode_fields([ <<1>>, CircuitId, RequestId, PostsBin, 0]).

[20.1358]

[20.1429]

    length_encode_fields([<<1>>, CircuitId, RequestId, PostsBin, 0]).

Replacement in apps/cable/src/wire.erl at line 54 [22.5336]

B:BD[34.164] → [20.1431:1506]

    [ {requestId, RequestId}
    , {circuitId, CircuitId}
    , {ttl, TTL}

[34.164]

[20.1506]

    [
        {requestId, RequestId},
        {circuitId, CircuitId},
        {ttl, TTL}

Replacement in apps/cable/src/wire.erl at line 59 [22.5336]

B:BD[20.1522] → [20.1522:1717]

    length_encode_fields([ <<2>>, CircuitId, RequestId
                         , encode_varint(TTL)
                         , encode_varint(length(Hashes))
                         , Hashes]).

[20.1522]

[34.420]

    length_encode_fields([
        <<2>>,
        CircuitId,
        RequestId,
        encode_varint(TTL),
        encode_varint(length(Hashes)),
        Hashes
    ]).

Replacement in apps/cable/src/wire.erl at line 69 [22.5336]

B:BD[34.489] → [20.1718:1944]

    [ {requestId, RequestId}
    , {circuitId, CircuitId}
    , {ttl, TTL}] = Header,
    length_encode_fields([ <<3>>, CircuitId, RequestId
                         , encode_varint(TTL)
                         , CancelId]).

[34.489]

[34.698]

    [
        {requestId, RequestId},
        {circuitId, CircuitId},
        {ttl, TTL}
    ] = Header,
    length_encode_fields([
        <<3>>,
        CircuitId,
        RequestId,
        encode_varint(TTL),
        CancelId
    ]).

Replacement in apps/cable/src/wire.erl at line 83 [22.5336]

∅:D[16.1743] → [20.2019:2470]

B:BD[20.2019] → [20.2019:2470]

    [ {requestId, RequestId}
    , {circuitId, CircuitId}
    , {ttl, TTL}] = Header,
    length_encode_fields([ <<4>>, CircuitId, RequestId
                         , encode_varint(TTL)
                         , encode_varint(length(Channel))
                         , Channel
                         , encode_varint(Start)
                         , encode_varint(End)
                         , encode_varint(Limit)
                         ]).

[16.1743]

[20.2470]

    [
        {requestId, RequestId},
        {circuitId, CircuitId},
        {ttl, TTL}
    ] = Header,
    length_encode_fields([
        <<4>>,
        CircuitId,
        RequestId,
        encode_varint(TTL),
        encode_varint(length(Channel)),
        Channel,
        encode_varint(Start),
        encode_varint(End),
        encode_varint(Limit)
    ]).

Replacement in apps/cable/src/wire.erl at line 101 [22.5336]

B:BD[20.2528] → [20.2528:2614]

    [ {requestId, RequestId}
    , {circuitId, CircuitId}
    , {ttl, TTL}] = Header,

[20.2528]

[26.2178]

    [
        {requestId, RequestId},
        {circuitId, CircuitId},
        {ttl, TTL}
    ] = Header,

Replacement in apps/cable/src/wire.erl at line 107 [22.5336]

B:BD[26.2220] → [20.2615:2868]

    length_encode_fields([ <<5>>, CircuitId, RequestId
                         , encode_varint(TTL)
                         , encode_varint(byte_size(ChannelBin))
                         , ChannelBin
                         , encode_bool(Future)]).

[26.2220]

[35.136]

    length_encode_fields([
        <<5>>,
        CircuitId,
        RequestId,
        encode_varint(TTL),
        encode_varint(byte_size(ChannelBin)),
        ChannelBin,
        encode_bool(Future)
    ]).

Replacement in apps/cable/src/wire.erl at line 118 [22.5336]

B:BD[20.2923] → [20.2923:3210]

    [ {requestId, RequestId}
    , {circuitId, CircuitId}
    , {ttl, TTL}] = Header,
    length_encode_fields([ <<6>>, CircuitId, RequestId
                         , encode_varint(TTL)
                         , encode_varint(Offset)
                         , encode_varint(Limit)]).

[20.2923]

[20.3210]

    [
        {requestId, RequestId},
        {circuitId, CircuitId},
        {ttl, TTL}
    ] = Header,
    length_encode_fields([
        <<6>>,
        CircuitId,
        RequestId,
        encode_varint(TTL),
        encode_varint(Offset),
        encode_varint(Limit)
    ]).

Replacement in apps/cable/src/wire.erl at line 133 [22.5336]

B:BD[35.210] → [20.3212:3281]

    [ {requestId, RequestId}
    , {circuitId, CircuitId}] = Header,

[35.210]

[20.3281]

    [
        {requestId, RequestId},
        {circuitId, CircuitId}
    ] = Header,

Replacement in apps/cable/src/wire.erl at line 138 [22.5336]

B:BD[20.3308] → [20.3308:3503]

                      BinChan = unicode:characters_to_binary(Chan),
                      ChanLen = encode_varint(byte_size(BinChan)),
                      [ChanLen, BinChan]
              end,

[20.3308]

[20.3503]

        BinChan = unicode:characters_to_binary(Chan),
        ChanLen = encode_varint(byte_size(BinChan)),
        [ChanLen, BinChan]
    end,

Replacement in apps/cable/src/wire.erl at line 143 [22.5336]

B:BD[20.3551] → [20.3551:3625]

    length_encode_fields([ <<7>>, CircuitId, RequestId, ChannelsBin, 0]).

[20.3551]

[26.2602]

    length_encode_fields([<<7>>, CircuitId, RequestId, ChannelsBin, 0]).

Replacement in apps/cable/src/wire.erl at line 151 [22.5336]

B:BD[26.2670] → [26.2670:3062]

B:BD[26.3062] → [35.696:834]

∅:D[35.834] → [26.3113:3122]

B:BD[26.3113] → [26.3113:3122]

    Body = case proplists:get_value(msgType, Header) of
        0 -> decode_hash_response(Payload);
        1 -> decode_post_response(Payload);
        2 -> decode_post_request(Payload);
        3 -> decode_cancel_request(Payload);
        4 -> decode_channel_time_range_request(Payload);
        5 -> decode_channel_state_request(Payload);
        6 -> decode_channel_list_request(Payload);
        7 -> decode_channel_list_response(Payload);
        Unknown -> erlang:error(io_lib:format("Unknown message type: ~p", [Unknown]))
    end,

[26.2670]

[26.3122]

    Body =
        case proplists:get_value(msgType, Header) of
            0 -> decode_hash_response(Payload);
            1 -> decode_post_response(Payload);
            2 -> decode_post_request(Payload);
            3 -> decode_cancel_request(Payload);
            4 -> decode_channel_time_range_request(Payload);
            5 -> decode_channel_state_request(Payload);
            6 -> decode_channel_list_request(Payload);
            7 -> decode_channel_list_response(Payload);
            Unknown -> erlang:error(io_lib:format("Unknown message type: ~p", [Unknown]))
        end,

Replacement in apps/cable/src/wire.erl at line 167 [22.5336]

B:BD[21.1937] → [21.1937:2113]

    << CircuitId:4/binary, ReqId:4/binary, Rest3/binary >> = Rest2,
    Header = [ {msgType, MsgType}
             , {circuitId, CircuitId}
             , {requestId, ReqId}],

[21.1937]

[21.2113]

    <<CircuitId:4/binary, ReqId:4/binary, Rest3/binary>> = Rest2,
    Header = [
        {msgType, MsgType},
        {circuitId, CircuitId},
        {requestId, ReqId}
    ],

Replacement in apps/cable/src/wire.erl at line 180 [22.5336]

∅:D[26.3826] → [28.1617:1727]

B:BD[28.1617] → [28.1617:1727]

            ErrMsg = io_lib:format("invalid hash_count - stated ~p but got ~p", [HashCount, length(Hashes)]),

[26.3826]

[28.1727]

            ErrMsg = io_lib:format("invalid hash_count - stated ~p but got ~p", [
                HashCount, length(Hashes)
            ]),

Replacement in apps/cable/src/wire.erl at line 185 [22.5336]
B:BD[28.1792] → [26.3827:3856]
```
        [ {hashes, Hashes} ]
```
[28.1792]
[28.1883]
```
            [{hashes, Hashes}]
```

Replacement in apps/cable/src/wire.erl at line 193 [22.5336]

∅:D[26.3907] → [28.1923:2033]

B:BD[29.4398] → [28.1923:2033]

            ErrMsg = io_lib:format("invalid hash_count - stated ~p but got ~p", [HashCount, length(Hashes)]),

[26.3907]

[29.4510]

            ErrMsg = io_lib:format("invalid hash_count - stated ~p but got ~p", [
                HashCount, length(Hashes)
            ]),

Replacement in apps/cable/src/wire.erl at line 198 [22.5336]
B:BD[36.152] → [26.3908:3929]
∅:D[26.3929] → [36.227:254]
B:BD[36.227] → [36.227:254]
∅:D[36.254] → [27.2616:2626]
B:BD[27.2616] → [27.2616:2626]
```
        [ {ttl, Ttl}
        , {hashes, Hashes}
        ]
```
[36.152]
[27.2626]
```
            [
                {ttl, Ttl},
                {hashes, Hashes}
            ]
```
Replacement in apps/cable/src/wire.erl at line 206 [22.5336]
B:BD[27.2821] → [26.3965:3982]
B:BD[26.3982] → [25.72:99]
```
    [ {ttl, Ttl}
    , {cancelId, CancelId}
```
[27.2821]
[27.2921]
```
    [
        {ttl, Ttl},
        {cancelId, CancelId}
```

Replacement in apps/cable/src/wire.erl at line 215 [22.5336]

B:BD[23.1886] → [26.4030:4047]

B:BD[26.4047] → [16.1744:1785]

∅:D[16.1785] → [27.3439:3514]

B:BD[27.3439] → [27.3439:3514]

    [ {ttl, Ttl}
    , {channel, binary_to_list(Channel)}
    , {timestart, TimeStart}
    , {timeend, TimeEnd}
    , {limit, Limit}

[23.1886]

[27.3514]

    [
        {ttl, Ttl},
        {channel, binary_to_list(Channel)},
        {timestart, TimeStart},
        {timeend, TimeEnd},
        {limit, Limit}

Replacement in apps/cable/src/wire.erl at line 227 [22.5336]

B:BD[23.2177] → [26.4090:4107]

B:BD[26.4107] → [16.1786:1827]

∅:D[16.1827] → [23.2269:2292]

B:BD[23.2269] → [23.2269:2292]

    [ {ttl, Ttl}
    , {channel, binary_to_list(Channel)}
    , {future, Future}

[23.2177]

[23.2292]

    [
        {ttl, Ttl},
        {channel, binary_to_list(Channel)},
        {future, Future}

Replacement in apps/cable/src/wire.erl at line 235 [22.5336]
B:BD[23.2493] → [26.4149:4166]
∅:D[26.4166] → [23.2560:2604]
B:BD[23.2560] → [23.2560:2604]
```
    [ {ttl, Ttl}
    , {offset, Offset}
    , {limit, Limit}
```
[23.2493]
[29.4560]
```
    [
        {ttl, Ttl},
        {offset, Offset},
        {limit, Limit}
```
Replacement in apps/cable/src/wire.erl at line 242 [22.5336]
B:BD[26.4200] → [12.1664:1712]
∅:D[12.1712] → [29.4790:4797]
∅:D[26.4247] → [29.4790:4797]
B:BD[29.4790] → [29.4790:4797]
```
    [ {posts, decode_list_of_binaries(Payload)}
    ].
```
[26.4200]
[29.4797]
```
    [{posts, decode_list_of_binaries(Payload)}].
```
Replacement in apps/cable/src/wire.erl at line 245 [22.5336]
B:BD[26.4289] → [26.4289:4339]
∅:D[26.4339] → [23.2604:2611]
∅:D[29.5031] → [23.2604:2611]
B:BD[23.2604] → [23.2604:2611]
```
    [ {channels, decode_list_of_strings(Payload)}
    ].
```
[26.4289]
[23.2611]
```
    [{channels, decode_list_of_strings(Payload)}].
```
Deletion in apps/cable/src/wire.erl at line 253 [22.5336]
B:BD[34.969] → [34.969:970]
Deletion in apps/cable/src/wire.erl at line 259 [22.5336]
∅:D[34.1077] → [37.682:683]
B:BD[23.2622] → [37.682:683]

Replacement in apps/cable/src/wire.erl at line 266 [22.5336]

B:BD[37.841] → [37.841:984]

        Len > RestSize -> erlang:error("Not enough Data for the complete message");
        Len =:= RestSize -> {ok, Acc++[Rest]}; % last call

[37.841]

[37.984]

        Len > RestSize ->
            erlang:error("Not enough Data for the complete message");
        % last call
        Len =:= RestSize ->
            {ok, Acc ++ [Rest]};

Replacement in apps/cable/src/wire.erl at line 273 [22.5336]

B:BD[37.1055] → [37.1055:1164]

            Next = binary:part(Rest, Len, byte_size(Rest)-Len),
            split_messages(Next, Acc++[Msg])

[37.1055]

[37.1164]

            Next = binary:part(Rest, Len, byte_size(Rest) - Len),
            split_messages(Next, Acc ++ [Msg])

Deletion in apps/cable/src/wire.erl at line 277 [22.5336]
B:BD[29.5033] → [37.1174:1175]
Replacement in apps/cable/src/wire.erl at line 286 [22.5336]
B:BD[29.5202] → [29.5202:5223]
```
        true -> Acc;
```
[29.5202]
[29.5223]
```
        true ->
            Acc;
```

Replacement in apps/cable/src/wire.erl at line 289 [22.5336]

B:BD[29.5240] → [29.5240:5296]

B:BD[29.5296] → [12.1860:2051]

            <<Field:Len/binary, Rest2/binary >> = Rest,
            NewAcc = Acc ++ case Kind of
                                string -> [binary_to_list(Field)];
                                binary -> [Field]
                            end,

[29.5240]

[12.2051]

            <<Field:Len/binary, Rest2/binary>> = Rest,
            NewAcc =
                Acc ++
                    case Kind of
                        string -> [binary_to_list(Field)];
                        binary -> [Field]
                    end,

Replacement in apps/cable/src/wire.erl at line 306 [22.5336]
B:BD[23.2842] → [23.2842:2887]
```
    decode_varints(Rest, N-1, Acc ++ [Int]).
```
[23.2842]
[23.2887]
```
    decode_varints(Rest, N - 1, Acc ++ [Int]).
```

Replacement in apps/cable/src/wire.erl at line 311 [22.5336]

B:BD[22.5929] → [22.5929:5999]

-spec decode_varint(binary()) -> {non_neg_integer(), Rest::binary()}.

[22.5929]

[22.5999]

-spec decode_varint(binary()) -> {non_neg_integer(), Rest :: binary()}.

Replacement in apps/cable/src/wire.erl at line 320 [22.5336]

B:BD[22.6414] → [22.6414:6535]

de_vi(<<1:1, X:7, Rest/binary>>, N, Acc, MaxNumBits) when N < (64-7) ->
    de_vi(Rest, N+7, X bsl N + Acc, MaxNumBits);

[22.6414]

[22.6535]

de_vi(<<1:1, X:7, Rest/binary>>, N, Acc, MaxNumBits) when N < (64 - 7) ->
    de_vi(Rest, N + 7, X bsl N + Acc, MaxNumBits);

Deletion in apps/cable/src/posts.erl at line 7 [29.5381]
B:BD[8.796] → [8.796:797]
Deletion in apps/cable/src/posts.erl at line 27 [29.5381]
B:BD[8.1615] → [11.2517:2518]
Deletion in apps/cable/src/posts.erl at line 31 [29.5381]
B:BD[11.2711] → [11.2711:2712]
Deletion in apps/cable/src/posts.erl at line 35 [29.5381]
B:BD[11.2918] → [11.2918:2919]

Replacement in apps/cable/src/posts.erl at line 38 [29.5381]

B:BD[20.3682] → [11.2957:3264]

    TopicData = case length(Topic) of
                    0 -> [0];
                    _ ->
                        TopicBin = unicode:characters_to_binary(Topic),
                        TopicLen = wire:encode_varint(byte_size(TopicBin)),
                        [TopicLen, TopicBin]
                end,

[20.3682]

[11.3264]

    TopicData =
        case length(Topic) of
            0 ->
                [0];
            _ ->
                TopicBin = unicode:characters_to_binary(Topic),
                TopicLen = wire:encode_varint(byte_size(TopicBin)),
                [TopicLen, TopicBin]
        end,

Deletion in apps/cable/src/posts.erl at line 48 [29.5381]
B:BD[11.3324] → [11.3324:3325]

Replacement in apps/cable/src/posts.erl at line 49 [29.5381]

B:BD[11.3383] → [11.3383:3489]

    TypeCode = case JL of
                   join -> 4;
                   leave -> 5
               end,

[11.3383]

[8.1822]

    TypeCode =
        case JL of
            join -> 4;
            leave -> 5
        end,

Replacement in apps/cable/src/posts.erl at line 64 [29.5381]

B:BD[12.2322] → [10.4535:4591]

∅:D[10.4591] → [12.2382:2686]

B:BD[12.2382] → [12.2382:2686]

    Decoded = case proplists:get_value(type, Header) of
                  0 -> decode_post_text(Body);
                  1 -> decode_post_delete(Body);
                  2 -> decode_post_info(Body);
                  3 -> decode_post_topic(Body);
                  4 -> decode_post_join(Body);
                  5 -> decode_post_leave(Body)
              end,

[12.2322]

[12.2686]

    Decoded =
        case proplists:get_value(type, Header) of
            0 -> decode_post_text(Body);
            1 -> decode_post_delete(Body);
            2 -> decode_post_info(Body);
            3 -> decode_post_topic(Body);
            4 -> decode_post_join(Body);
            5 -> decode_post_leave(Body)
        end,

Replacement in apps/cable/src/posts.erl at line 76 [29.5381]

B:BD[33.2017] → [33.2017:2091]

    << PubKey:32/binary, Signature:64/binary, SignedData/binary>> = Data,

[33.2017]

[33.2091]

    <<PubKey:32/binary, Signature:64/binary, SignedData/binary>> = Data,

Replacement in apps/cable/src/posts.erl at line 79 [29.5381]

B:BD[33.2216] → [33.2216:2276]

    <<LinkData:(32*NumLinks)/binary, Rest2/binary>> = Rest,

[33.2216]

[33.2276]

    <<LinkData:(32 * NumLinks)/binary, Rest2/binary>> = Rest,

Replacement in apps/cable/src/posts.erl at line 83 [29.5381]

B:BD[33.2386] → [33.2386:2495]

            ErrMsg = io_lib:format("invalid num_links - expected ~p but got ~p", [NumLinks, length(Links)]),

[33.2386]

[33.2495]

            ErrMsg = io_lib:format("invalid num_links - expected ~p but got ~p", [
                NumLinks, length(Links)
            ]),

Replacement in apps/cable/src/posts.erl at line 91 [29.5381]

B:BD[33.2703] → [33.2703:2910]

             [ {public_key, PubKey}
             , {links, Links}
             , {type, PostType}
             , {timestamp, Timestamp}
             , {hash, PostHash}
             ]
            , PostBody]

[33.2703]

[33.2910]

                [
                    {public_key, PubKey},
                    {links, Links},
                    {type, PostType},
                    {timestamp, Timestamp},
                    {hash, PostHash}
                ],
                PostBody
            ]

Replacement in apps/cable/src/posts.erl at line 103 [29.5381]

∅:D[12.2736] → [29.5645:5835]

B:BD[29.5645] → [29.5645:5835]

B:BD[29.5835] → [9.1472:1541]

  {ChannelLen, Rest} = wire:decode_varint(Body),
  <<Channel:(ChannelLen)/binary, Rest2/binary>> = Rest,
  {TextLen, Rest3} = wire:decode_varint(Rest2),
  <<Text:(TextLen)/binary>> = Rest3,
  [ {channel, Channel}, {text, unicode:characters_to_binary(Text)}].

[12.2736]

[29.5959]

    {ChannelLen, Rest} = wire:decode_varint(Body),
    <<Channel:(ChannelLen)/binary, Rest2/binary>> = Rest,
    {TextLen, Rest3} = wire:decode_varint(Rest2),
    <<Text:(TextLen)/binary>> = Rest3,
    [{channel, Channel}, {text, unicode:characters_to_binary(Text)}].

Replacement in apps/cable/src/posts.erl at line 110 [29.5381]

∅:D[12.2852] → [29.6073:6220]

B:BD[29.6073] → [29.6073:6220]

B:BD[29.6220] → [12.2853:2877]

  {NumHashes, Rest} = wire:decode_varint(Body),
  <<HashData:(32*NumHashes)/binary >> = Rest,
  Hashes = [Hash || <<Hash:32/binary>> <= HashData],
  [ {hashes, Hashes} ].

[12.2852]

[29.6282]

    {NumHashes, Rest} = wire:decode_varint(Body),
    <<HashData:(32 * NumHashes)/binary>> = Rest,
    Hashes = [Hash || <<Hash:32/binary>> <= HashData],
    [{hashes, Hashes}].

Replacement in apps/cable/src/posts.erl at line 116 [29.5381]
B:BD[12.2904] → [10.4592:4636]
∅:D[10.4636] → [12.2905:2937]
B:BD[29.6438] → [12.2905:2937]
```
  KVs = wire:decode_list_of_binaries(Body),
  [ {infos, list_to_map(KVs)}].
```
[12.2904]
[29.6840]
```
    KVs = wire:decode_list_of_binaries(Body),
    [{infos, list_to_map(KVs)}].
```

Replacement in apps/cable/src/posts.erl at line 120 [29.5381]

∅:D[12.2965] → [29.6954:7147]

B:BD[29.6954] → [29.6954:7147]

B:BD[29.7147] → [12.2966:3007]

  {ChannelLen, Rest} = wire:decode_varint(Body),
  <<Channel:(ChannelLen)/binary, Rest2/binary>> = Rest,
  {TopicLen, Rest3} = wire:decode_varint(Rest2),
  <<Topic:(TopicLen)/binary>> = Rest3,
  [ {channel, Channel}, {topic, Topic}].

[12.2965]

[29.7226]

    {ChannelLen, Rest} = wire:decode_varint(Body),
    <<Channel:(ChannelLen)/binary, Rest2/binary>> = Rest,
    {TopicLen, Rest3} = wire:decode_varint(Rest2),
    <<Topic:(TopicLen)/binary>> = Rest3,
    [{channel, Channel}, {topic, Topic}].

Replacement in apps/cable/src/posts.erl at line 127 [29.5381]

∅:D[12.3034] → [29.7339:7430]

B:BD[29.7339] → [29.7339:7430]

B:BD[29.7430] → [12.3035:3060]

  {ChannelLen, Rest} = wire:decode_varint(Body),
  <<Channel:(ChannelLen)/binary>> = Rest,
  [ {channel, Channel}].

[12.3034]

[12.3060]

    {ChannelLen, Rest} = wire:decode_varint(Body),
    <<Channel:(ChannelLen)/binary>> = Rest,
    [{channel, Channel}].

Replacement in apps/cable/src/posts.erl at line 132 [29.5381]

∅:D[12.3088] → [29.7609:7700]

B:BD[29.7609] → [29.7609:7700]

B:BD[29.7700] → [12.3089:3114]

∅:D[12.3114] → [29.7763:7764]

B:BD[29.7763] → [29.7763:7764]

  {ChannelLen, Rest} = wire:decode_varint(Body),
  <<Channel:(ChannelLen)/binary>> = Rest,
  [ {channel, Channel}].

[12.3088]

[38.82]

    {ChannelLen, Rest} = wire:decode_varint(Body),
    <<Channel:(ChannelLen)/binary>> = Rest,
    [{channel, Channel}].

Replacement in apps/cable/src/posts.erl at line 142 [29.5381]

B:BD[38.298] → [38.298:333]

B:BD[38.333] → [12.3760:3789]

  list_to_map(Rest, Acc#{K => V});
list_to_map([], Acc) -> Acc.

[38.298]

    list_to_map(Rest, Acc#{K => V});
list_to_map([], Acc) ->
    Acc.

Replacement in apps/cable/src/peer.erl at line 48 [31.854]

B:BD[35.1281] → [20.3739:3824]

-record(state, {db, keyPair, peers=#{}, channels=#{}, activeOut=#{}, activeIn=#{}}).

[35.1281]

[26.4501]

-record(state, {db, keyPair, peers = #{}, channels = #{}, activeOut = #{}, activeIn = #{}}).

Replacement in apps/cable/src/peer.erl at line 78 [31.854]
B:BD[11.3873] → [11.3873:3924]
```
    %% gen_server:call(Pid, {channelsQueryKnown}).
```
[11.3873]
[11.3924]
```
%% gen_server:call(Pid, {channelsQueryKnown}).
```

Replacement in apps/cable/src/peer.erl at line 105 [31.854]

B:BD[34.1207] → [20.4008:4161]

    LisOpts = [ binary
              , {packet, 0}
              , {active, false}
              , {reuseaddr, true}
              , {ifaddr, LisAddr}],

[34.1207]

[14.1181]

    LisOpts = [
        binary,
        {packet, 0},
        {active, false},
        {reuseaddr, true},
        {ifaddr, LisAddr}
    ],

Replacement in apps/cable/src/peer.erl at line 125 [31.854]

B:BD[20.4448] → [20.4448:4564]

    State = #state{ db=Db
                  , keyPair=Kp
                  , channels = maps:from_keys(Chans, [])},

[20.4448]

[20.4564]

    State = #state{
        db = Db,
        keyPair = Kp,
        channels = maps:from_keys(Chans, [])
    },

Replacement in apps/cable/src/peer.erl at line 136 [31.854]

B:BD[25.515] → [14.1266:1439]

    GenSrvState = [ {listenProc, ListenProc}
                  , {listenAddr, {LisAddr, Port}}
                  , {eventLoop, Handler}
                  , {database, Db}],

[25.515]

[14.1439]

    GenSrvState = [
        {listenProc, ListenProc},
        {listenAddr, {LisAddr, Port}},
        {eventLoop, Handler},
        {database, Db}
    ],

Replacement in apps/cable/src/peer.erl at line 146 [31.854]

B:BD[13.2397] → [13.2397:2465]

    EL ! {readTextsFromChannel, From, Chan}, % reply via event loop

[13.2397]

[13.2465]

    % reply via event loop
    EL ! {readTextsFromChannel, From, Chan},

Deletion in apps/cable/src/peer.erl at line 149 [31.854]
∅:D[13.2487] → [19.1253:1254]
B:BD[14.1462] → [19.1253:1254]

Replacement in apps/cable/src/peer.erl at line 151 [31.854]

B:BD[19.1364] → [19.1364:1436]

    EL ! {writeTextToChannel, From, Chan, Text}, % reply via event loop

[19.1364]

[19.1436]

    % reply via event loop
    EL ! {writeTextToChannel, From, Chan, Text},

Deletion in apps/cable/src/peer.erl at line 154 [31.854]
∅:D[19.1458] → [14.1462:1463]
B:BD[14.1462] → [14.1462:1463]
Deletion in apps/cable/src/peer.erl at line 157 [31.854]
B:BD[14.1593] → [11.4164:4165]

Replacement in apps/cable/src/peer.erl at line 159 [31.854]

B:BD[11.4255] → [11.4255:4307]

    EL ! {nodePubKey, From}, % reply via event loop

[11.4255]

[11.4307]

    % reply via event loop
    EL ! {nodePubKey, From},

Deletion in apps/cable/src/peer.erl at line 162 [31.854]
∅:D[39.1421] → [31.1876:1877]
∅:D[34.1584] → [31.1876:1877]
∅:D[14.1593] → [31.1876:1877]
∅:D[15.1878] → [31.1876:1877]
∅:D[11.4329] → [31.1876:1877]
B:BD[31.1876] → [31.1876:1877]

Replacement in apps/cable/src/peer.erl at line 164 [31.854]

B:BD[11.4426] → [11.4426:4484]

    EL ! {setOwnNick, From, Nick}, % reply via event loop

[11.4426]

[11.4484]

    % reply via event loop
    EL ! {setOwnNick, From, Nick},

Deletion in apps/cable/src/peer.erl at line 167 [31.854]
B:BD[11.4506] → [11.4506:4507]

Replacement in apps/cable/src/peer.erl at line 169 [31.854]

B:BD[11.4606] → [13.2542:2605]

    EL ! {channelsMembers, From, Chan}, % reply via event loop

[11.4606]

[11.4667]

    % reply via event loop
    EL ! {channelsMembers, From, Chan},

Deletion in apps/cable/src/peer.erl at line 172 [31.854]
B:BD[11.4689] → [11.4689:4690]

Replacement in apps/cable/src/peer.erl at line 174 [31.854]

B:BD[11.4799] → [11.4799:4870]

    EL ! {channelsSetTopic, From, Chan, Topic}, % reply via event loop

[11.4799]

[11.4870]

    % reply via event loop
    EL ! {channelsSetTopic, From, Chan, Topic},

Deletion in apps/cable/src/peer.erl at line 177 [31.854]
B:BD[11.4892] → [11.4892:4893]

Replacement in apps/cable/src/peer.erl at line 179 [31.854]

B:BD[39.1513] → [15.1924:1978]

    EL ! {channelsList, From}, % reply via event loop

[39.1513]

[25.516]

    % reply via event loop
    EL ! {channelsList, From},

Deletion in apps/cable/src/peer.erl at line 182 [31.854]
B:BD[25.538] → [15.1979:1980]

Replacement in apps/cable/src/peer.erl at line 184 [31.854]

B:BD[25.626] → [25.626:676]

    EL ! {peerList, From}, % reply via event loop

[25.626]

[39.1566]

    % reply via event loop
    EL ! {peerList, From},

Deletion in apps/cable/src/peer.erl at line 198 [31.854]
B:BD[39.1867] → [15.1981:1982]
Deletion in apps/cable/src/peer.erl at line 203 [31.854]
B:BD[39.2049] → [15.2059:2060]
Deletion in apps/cable/src/peer.erl at line 208 [31.854]
B:BD[39.2231] → [15.2139:2140]
Deletion in apps/cable/src/peer.erl at line 218 [31.854]
B:BD[15.2499] → [15.2499:2500]
Deletion in apps/cable/src/peer.erl at line 234 [31.854]
B:BD[39.2852] → [6.207:208]

Replacement in apps/cable/src/peer.erl at line 257 [31.854]

B:BD[39.3202] → [39.3202:3264]

B:BD[39.3264] → [16.1952:2095]

∅:D[14.1700] → [35.2348:2422]

∅:D[16.2095] → [35.2348:2422]

B:BD[39.3264] → [35.2348:2422]

∅:D[35.2422] → [39.3329:3356]

B:BD[39.3329] → [39.3329:3356]

                              {ok, Msg} = wire:decode(Chunk),
                              %% TODO: this ommits the byte(s) for the length prefix
                              MsgSize = byte_size(Chunk),
                              Handler ! {incomingMsg, Conn, Msg, MsgSize}
                      end,

[39.3202]

[39.3356]

                {ok, Msg} = wire:decode(Chunk),
                %% TODO: this ommits the byte(s) for the length prefix
                MsgSize = byte_size(Chunk),
                Handler ! {incomingMsg, Conn, Msg, MsgSize}
            end,

Deletion in apps/cable/src/peer.erl at line 273 [31.854]
B:BD[6.330] → [6.330:331]
Deletion in apps/cable/src/peer.erl at line 286 [31.854]
∅:D[6.883] → [11.5053:5054]
B:BD[11.5053] → [11.5053:5054]
Deletion in apps/cable/src/peer.erl at line 293 [31.854]
∅:D[6.1129] → [16.3018:3019]
B:BD[16.3018] → [16.3018:3019]
Deletion in apps/cable/src/peer.erl at line 309 [31.854]
∅:D[6.1935] → [16.3125:3126]
B:BD[16.3125] → [16.3125:3126]
Deletion in apps/cable/src/peer.erl at line 316 [31.854]
B:BD[39.4190] → [25.2205:2206]
Deletion in apps/cable/src/peer.erl at line 320 [31.854]
∅:D[6.2481] → [11.5055:5056]
B:BD[25.2506] → [11.5055:5056]
Deletion in apps/cable/src/peer.erl at line 335 [31.854]
B:BD[6.2996] → [6.2996:2997]

Replacement in apps/cable/src/peer.erl at line 337 [31.854]

B:BD[6.3117] → [6.3117:3188]

                       Acc ++ [{PeerId, PeerMeta}]
               end,

[6.3117]

[6.3188]

        Acc ++ [{PeerId, PeerMeta}]
    end,

Deletion in apps/cable/src/peer.erl at line 342 [31.854]
B:BD[6.3284] → [6.3284:3285]
Deletion in apps/cable/src/peer.erl at line 345 [31.854]
B:BD[6.3430] → [6.3430:3431]
Deletion in apps/cable/src/peer.erl at line 348 [31.854]
B:BD[6.3551] → [6.3551:3552]

Replacement in apps/cable/src/peer.erl at line 353 [31.854]

B:BD[6.3723] → [6.3723:3858]

handle_peer_messages(peerLost, {Peer}, State = #state{peers = Peers, channels = Chans, activeIn = ActiveIn, activeOut = ActiveOut}) ->

[6.3723]

[6.3858]

handle_peer_messages(
    peerLost,
    {Peer},
    State = #state{peers = Peers, channels = Chans, activeIn = ActiveIn, activeOut = ActiveOut}
) ->

Replacement in apps/cable/src/peer.erl at line 359 [31.854]

B:BD[6.3912] → [6.3912:4016]

    { #{ lastSeenAt := LastSeen,
         bytesTransmitted := {Sent, Received}
       },
      NewPeers

[6.3912]

[6.4016]

    {
        #{
            lastSeenAt := LastSeen,
            bytesTransmitted := {Sent, Received}
        },
        NewPeers

Replacement in apps/cable/src/peer.erl at line 366 [31.854]

B:BD[6.4048] → [6.4048:4204]

    io:format("[Peer:~p] lost | LastSeen: ~p | Sent: ~p | Received: ~p~n",
              [Peer, LastSeen, human_bytesize(Sent), human_bytesize(Received)]),

[6.4048]

[6.4204]

    io:format(
        "[Peer:~p] lost | LastSeen: ~p | Sent: ~p | Received: ~p~n",
        [Peer, LastSeen, human_bytesize(Sent), human_bytesize(Received)]
    ),

Replacement in apps/cable/src/peer.erl at line 372 [31.854]

B:BD[6.4301] → [6.4301:4977]

                         MatchRequests = fun(Req, Matched) ->
                                                 case Req of
                                                     {_, ReqId, Peer} ->
                                                         maps:put(ReqId, true, Matched);
                                                     _Other -> % other requests
                                                         Matched
                                                 end
                                         end,
                         NewMatched = lists:foldl(MatchRequests, MatchedReqs, ChanReqs),
                         NewMatched
                 end,

[6.4301]

[6.4977]

        MatchRequests = fun(Req, Matched) ->
            case Req of
                {_, ReqId, Peer} ->
                    maps:put(ReqId, true, Matched);
                % other requests
                _Other ->
                    Matched
            end
        end,
        NewMatched = lists:foldl(MatchRequests, MatchedReqs, ChanReqs),
        NewMatched
    end,

Replacement in apps/cable/src/peer.erl at line 391 [31.854]

B:BD[6.5343] → [6.5343:6129]

∅:D[6.6129] → [11.7228:7229]

B:BD[11.7228] → [11.7228:7229]

B:BD[11.7229] → [6.6130:6343]

                         {ChanReqs, NewChanAcc} = maps:take(ChanName, AccChans),
                         FilterReqsOfPeer = fun(Req) ->
                                                    case Req of
                                                        {Direction, ReqId, Peer} ->
                                                            io:format("[DEBUG Peer:~p] dropping ~p request ~p~n",
                                                                      [Peer, Direction, hex:bin_to_hexstr(ReqId)]),
                                                            false;
                                                        _Other -> % other requests
                                                            true
                                                    end
                                            end,
                         NewReqs = lists:filter(FilterReqsOfPeer, ChanReqs),
                         maps:put(ChanName, NewReqs, NewChanAcc)
                 end,

[6.5343]

[6.6343]

        {ChanReqs, NewChanAcc} = maps:take(ChanName, AccChans),
        FilterReqsOfPeer = fun(Req) ->
            case Req of
                {Direction, ReqId, Peer} ->
                    io:format(
                        "[DEBUG Peer:~p] dropping ~p request ~p~n",
                        [Peer, Direction, hex:bin_to_hexstr(ReqId)]
                    ),
                    false;
                % other requests
                _Other ->
                    true
            end
        end,
        NewReqs = lists:filter(FilterReqsOfPeer, ChanReqs),
        maps:put(ChanName, NewReqs, NewChanAcc)
    end,

Replacement in apps/cable/src/peer.erl at line 410 [31.854]

B:BD[6.6425] → [6.6425:6675]

      peers = NewPeers,
      channels = NewChans,
      activeOut = NewOut,
      activeIn = NewIn
     };
handle_peer_messages(peerNew, {Peer}, State = #state{channels = Chans, peers = Peers, activeOut = ActiveOut, db = Db, keyPair = KeyPair}) ->

[6.6425]

[6.6675]

        peers = NewPeers,
        channels = NewChans,
        activeOut = NewOut,
        activeIn = NewIn
    };
handle_peer_messages(
    peerNew,
    {Peer},
    State = #state{
        channels = Chans, peers = Peers, activeOut = ActiveOut, db = Db, keyPair = KeyPair
    }
) ->

Replacement in apps/cable/src/peer.erl at line 424 [31.854]

B:BD[6.6825] → [6.6825:7653]

                       {ok, {StateReqId, StateMsg, StateSize}} = send_channel_state_request(Peer, Chan, true),
                       End = 0,
                       Start = os:system_time(1000) - (12*60*60 * 1000),
                       {ok, {TimeReqId, TimeMsg, TimeSize}
                       } = send_channel_time_range_request(Peer, Chan, Start, End, 200),
                       ReqsForChan = maps:get(Chan, AccChannels, [])
                           ++ [{sent, StateReqId, Peer}]
                           ++ [{sent, TimeReqId, Peer}],
                       {
                        AccNewReqs ++ [{StateReqId, StateMsg}, {TimeReqId, TimeMsg}],
                        maps:update(Chan, ReqsForChan, AccChannels),
                        PeerSent + StateSize + TimeSize
                       }
               end,

[6.6825]

[6.7653]

        {ok, {StateReqId, StateMsg, StateSize}} = send_channel_state_request(Peer, Chan, true),
        End = 0,
        Start = os:system_time(1000) - (12 * 60 * 60 * 1000),
        {ok, {TimeReqId, TimeMsg, TimeSize}} = send_channel_time_range_request(
            Peer, Chan, Start, End, 200
        ),
        ReqsForChan =
            maps:get(Chan, AccChannels, []) ++
                [{sent, StateReqId, Peer}] ++
                [{sent, TimeReqId, Peer}],
        {
            AccNewReqs ++ [{StateReqId, StateMsg}, {TimeReqId, TimeMsg}],
            maps:update(Chan, ReqsForChan, AccChannels),
            PeerSent + StateSize + TimeSize
        }
    end,

Replacement in apps/cable/src/peer.erl at line 443 [31.854]

B:BD[6.7805] → [6.7805:7996]

    NewOut = lists:foldl(fun({ReqId, Msg}, AccActiveOut) ->
                                 maps:put(ReqId, {Peer, Msg}, AccActiveOut)
                         end, ActiveOut, NewRequests),

[6.7805]

[6.7996]

    NewOut = lists:foldl(
        fun({ReqId, Msg}, AccActiveOut) ->
            maps:put(ReqId, {Peer, Msg}, AccActiveOut)
        end,
        ActiveOut,
        NewRequests
    ),

Replacement in apps/cable/src/peer.erl at line 452 [31.854]

B:BD[6.8064] → [6.8064:8245]

                     address => {Addr, Port},
                     lastSeenAt => os:system_time(1000),
                     bytesTransmitted => {PeerSent, 0}
                    },

[6.8064]

[6.8245]

        address => {Addr, Port},
        lastSeenAt => os:system_time(1000),
        bytesTransmitted => {PeerSent, 0}
    },

Replacement in apps/cable/src/peer.erl at line 457 [31.854]

B:BD[6.8273] → [6.8273:8428]

                 peers = maps:put(Peer, PeerMetadata, Peers),
                 channels = NewChans,
                 activeOut = NewOut
                },

[6.8273]

[6.8428]

        peers = maps:put(Peer, PeerMetadata, Peers),
        channels = NewChans,
        activeOut = NewOut
    },

Deletion in apps/cable/src/peer.erl at line 466 [31.854]
B:BD[6.8633] → [6.8633:8634]

Replacement in apps/cable/src/peer.erl at line 471 [31.854]

B:BD[6.8804] → [6.8804:8937]

handle_channel_messages(setOwnNick, {From, Nick}, State = #state{db = Db, keyPair = KeyPair, activeIn = ActiveIn, peers = Peers}) ->

[6.8804]

[6.8937]

handle_channel_messages(
    setOwnNick,
    {From, Nick},
    State = #state{db = Db, keyPair = KeyPair, activeIn = ActiveIn, peers = Peers}
) ->

Replacement in apps/cable/src/peer.erl at line 482 [31.854]

B:BD[6.9235] → [6.9235:9539]

                case proplists:get_value(type, Header) of
                    5 ->
                        {ok, {_, _, Size}} = send_hash_response(Peer, ReqId, [PostHash]),
                        update_peer_sent(AccPeers, Peer, Size);
                    _ -> AccPeers
                end
        end,

[6.9235]

[6.9539]

        case proplists:get_value(type, Header) of
            5 ->
                {ok, {_, _, Size}} = send_hash_response(Peer, ReqId, [PostHash]),
                update_peer_sent(AccPeers, Peer, Size);
            _ ->
                AccPeers
        end
    end,

Replacement in apps/cable/src/peer.erl at line 492 [31.854]

B:BD[6.9622] → [6.9622:9772]


handle_channel_messages(channelsJoin, {Chan}, State = #state{channels = Chans, db = Db, keyPair = KeyPair, peers = Peers, activeOut = ActiveOut}) ->

[6.9622]

[6.9772]

handle_channel_messages(
    channelsJoin,
    {Chan},
    State = #state{
        channels = Chans, db = Db, keyPair = KeyPair, peers = Peers, activeOut = ActiveOut
    }
) ->

Replacement in apps/cable/src/peer.erl at line 500 [31.854]
B:BD[6.9809] → [6.9809:9842]
```
        true -> % already joined
```
[6.9809]
[6.9842]
```
        % already joined
        true ->
```

Replacement in apps/cable/src/peer.erl at line 511 [31.854]

B:BD[6.10252] → [6.10252:10889]

                               %% TODO: handle send fail
                               {ok, {ReqId, Msg, Size}} = send_channel_state_request(Peer, Chan, true),
                               {
                                {sent, ReqId, Peer},
                                {
                                 maps:put(ReqId, {Peer, Msg}, AccActiveOuts),
                                 update_peer_sent(AccPeers, Peer, Size)
                                }
                               }
                       end,
            {Reqs, {NewPeers, NewActiveOut}} = lists:mapfoldl(EachPeer, {Peers, ActiveOut}, maps:keys(Peers)),

[6.10252]

[6.10889]

                %% TODO: handle send fail
                {ok, {ReqId, Msg, Size}} = send_channel_state_request(Peer, Chan, true),
                {
                    {sent, ReqId, Peer},
                    {
                        maps:put(ReqId, {Peer, Msg}, AccActiveOuts),
                        update_peer_sent(AccPeers, Peer, Size)
                    }
                }
            end,
            {Reqs, {NewPeers, NewActiveOut}} = lists:mapfoldl(
                EachPeer, {Peers, ActiveOut}, maps:keys(Peers)
            ),

Replacement in apps/cable/src/peer.erl at line 525 [31.854]

B:BD[6.10914] → [6.10914:11054]

              channels = maps:put(Chan, Reqs, Chans),
              peers = NewPeers,
              activeOut = NewActiveOut
             }

[6.10914]

[6.11054]

                channels = maps:put(Chan, Reqs, Chans),
                peers = NewPeers,
                activeOut = NewActiveOut
            }

Replacement in apps/cable/src/peer.erl at line 530 [31.854]

B:BD[6.11063] → [6.11063:11214]


handle_channel_messages(channelsLeave, {Chan}, State = #state{channels = Chans, db = Db, keyPair = KeyPair, peers = Peers, activeOut = ActiveOut}) ->

[6.11063]

[6.11214]

handle_channel_messages(
    channelsLeave,
    {Chan},
    State = #state{
        channels = Chans, db = Db, keyPair = KeyPair, peers = Peers, activeOut = ActiveOut
    }
) ->

Replacement in apps/cable/src/peer.erl at line 538 [31.854]
B:BD[6.11251] → [6.11251:11286]
```
        false -> % not even joined
```
[6.11251]
[6.11286]
```
        % not even joined
        false ->
```

Replacement in apps/cable/src/peer.erl at line 550 [31.854]

B:BD[6.11793] → [6.11793:12233]

                              {{Peer, _}, NewActiveOuts} = maps:take(ReqId, AccActiveOuts),
                              %% TODO: handle send fail
                              {ok, {_, _, Size}} = send_cancel_request(Peer, ReqId),
                              {
                               NewActiveOuts,
                               update_peer_sent(AccPeers, Peer, Size)
                              }
                      end,

[6.11793]

[6.12233]

                {{Peer, _}, NewActiveOuts} = maps:take(ReqId, AccActiveOuts),
                %% TODO: handle send fail
                {ok, {_, _, Size}} = send_cancel_request(Peer, ReqId),
                {
                    NewActiveOuts,
                    update_peer_sent(AccPeers, Peer, Size)
                }
            end,

Replacement in apps/cable/src/peer.erl at line 560 [31.854]

B:BD[6.12353] → [6.12353:12460]

              channels = NewChans,
              activeOut = NewActiveOut,
              peers = NewPeers}

[6.12353]

[6.12460]

                channels = NewChans,
                activeOut = NewActiveOut,
                peers = NewPeers
            }

Replacement in apps/cable/src/peer.erl at line 565 [31.854]

B:BD[6.12469] → [6.12469:12634]


handle_channel_messages(channelsSetTopic, {From, Chan, Topic}, State = #state{channels = Chans, db = Db, keyPair = KeyPair, peers = Peers, activeIn = ActiveIn}) ->

[6.12469]

[6.12634]

handle_channel_messages(
    channelsSetTopic,
    {From, Chan, Topic},
    State = #state{channels = Chans, db = Db, keyPair = KeyPair, peers = Peers, activeIn = ActiveIn}
) ->

Replacement in apps/cable/src/peer.erl at line 571 [31.854]
B:BD[6.12671] → [6.12671:12706]
```
        false -> % not even joined
```
[6.12671]
[6.12706]
```
        % not even joined
        false ->
```

Replacement in apps/cable/src/peer.erl at line 579 [31.854]

B:BD[6.12983] → [6.12983:13062]

∅:D[11.7825] → [19.2052:2227]

∅:D[6.13062] → [19.2052:2227]

B:BD[19.2052] → [19.2052:2227]

B:BD[19.2298] → [19.2298:2465]

B:BD[19.2465] → [11.7826:7992]

∅:D[11.7992] → [19.2554:2670]

B:BD[19.2554] → [19.2554:2670]

             SentPeers = lists:foldl(fun({received, ReqId, Peer}, AccPeers) ->
                                          {Peer, [Header, _]} = maps:get(ReqId, ActiveIn),
                                          case proplists:get_value(type, Header) of
                                              4 ->
                                                  {ok, {_, _, Size}} = send_hash_response(Peer, ReqId, [PostHash]),
                                                        update_peer_sent(AccPeers, Peer, Size);
                                              _ -> AccPeers % ignored
                                          end
                                  end, Peers, maps:get(Chan, Chans)),

[6.12983]

[6.13063]

            SentPeers = lists:foldl(
                fun({received, ReqId, Peer}, AccPeers) ->
                    {Peer, [Header, _]} = maps:get(ReqId, ActiveIn),
                    case proplists:get_value(type, Header) of
                        4 ->
                            {ok, {_, _, Size}} = send_hash_response(Peer, ReqId, [PostHash]),
                            update_peer_sent(AccPeers, Peer, Size);
                        % ignored
                        _ ->
                            AccPeers
                    end
                end,
                Peers,
                maps:get(Chan, Chans)
            ),

Deletion in apps/cable/src/peer.erl at line 597 [31.854]
∅:D[6.13155] → [19.2802:2803]
B:BD[19.2802] → [19.2802:2803]
Replacement in apps/cable/src/peer.erl at line 599 [31.854]
B:BD[6.13294] → [6.13294:13328]
```
        false -> % already joined
```
[6.13294]
[6.13328]
```
        % already joined
        false ->
```
Deletion in apps/cable/src/peer.erl at line 607 [31.854]
∅:D[6.13521] → [11.8370:8371]
B:BD[11.8370] → [11.8370:8371]

Replacement in apps/cable/src/peer.erl at line 616 [31.854]

B:BD[6.13894] → [6.13894:14061]


handle_database_messages(writeTextToChannel, {From, Chan, Text}, State = #state{channels = Chans, db = Db, keyPair = KeyPair, peers = Peers, activeIn = ActiveIn}) ->

[6.13894]

[6.14061]

handle_database_messages(
    writeTextToChannel,
    {From, Chan, Text},
    State = #state{channels = Chans, db = Db, keyPair = KeyPair, peers = Peers, activeIn = ActiveIn}
) ->

Replacement in apps/cable/src/peer.erl at line 631 [31.854]

B:BD[6.14536] → [6.14536:15228]

                        case Direction of
                            received ->
                                {Peer, [Header, _]} = maps:get(ReqId, ActiveIn),
                                case proplists:get_value(msgType, Header) of
                                    4 ->
                                        {ok, {_, _, Size}}
                                            = send_hash_response(Peer, ReqId, [PostHash]),
                                        update_peer_sent(AccPeers, Peer, Size);
                                    _ -> AccPeers
                                end;
                            sent -> AccPeers
                        end
                end,

[6.14536]

[6.15228]

                case Direction of
                    received ->
                        {Peer, [Header, _]} = maps:get(ReqId, ActiveIn),
                        case proplists:get_value(msgType, Header) of
                            4 ->
                                {ok, {_, _, Size}} =
                                    send_hash_response(Peer, ReqId, [PostHash]),
                                update_peer_sent(AccPeers, Peer, Size);
                            _ ->
                                AccPeers
                        end;
                    sent ->
                        AccPeers
                end
            end,

Deletion in apps/cable/src/peer.erl at line 651 [31.854]
∅:D[6.15448] → [39.5106:5107]
B:BD[39.5106] → [39.5106:5107]
Deletion in apps/cable/src/peer.erl at line 658 [31.854]
∅:D[6.15783] → [16.3827:3828]
B:BD[16.3827] → [16.3827:3828]

Replacement in apps/cable/src/peer.erl at line 664 [31.854]

B:BD[20.6012] → [20.6012:6114]

    #state{activeOut = ActiveOut, activeIn = ActiveIn, peers = Peers, channels = Chans, db = Db} = S,

[20.6012]

[16.3923]

    #state{activeOut = ActiveOut, activeIn = ActiveIn, peers = Peers, channels = Chans, db = Db} =
        S,

Replacement in apps/cable/src/peer.erl at line 671 [31.854]

B:BD[20.6288] → [13.4399:4545]

    io:format("[DEBUG] incoming message  ReqId:~p  Type:~p  Size:~p\tIsActiveOut:~p~n",
              [ReqIdStr, MsgType, MsgSize, IsActiveOut]),

[20.6288]

[19.3039]

    io:format(
        "[DEBUG] incoming message  ReqId:~p  Type:~p  Size:~p\tIsActiveOut:~p~n",
        [ReqIdStr, MsgType, MsgSize, IsActiveOut]
    ),

Deletion in apps/cable/src/peer.erl at line 677 [31.854]
∅:D[20.6418] → [25.4142:4143]
B:BD[25.4142] → [25.4142:4143]
Replacement in apps/cable/src/peer.erl at line 680 [31.854]
B:BD[20.6541] → [19.3086:3087]
∅:D[19.3087] → [20.6541:6579]
B:BD[20.6541] → [20.6541:6579]
```
                0 -> %% hash response
```
[20.6541]
[19.3088]
```
                %% hash response
                0 ->
```

Replacement in apps/cable/src/peer.erl at line 685 [31.854]

B:BD[16.4199] → [16.4199:4249]

                        0 -> % nothing to request

[16.4199]

[16.4249]

                        % nothing to request
                        0 ->

Replacement in apps/cable/src/peer.erl at line 692 [31.854]

B:BD[16.4410] → [16.4410:4517]

                            {ok, {PostReqId, _PostReqMsg, SentSize}} = send_post_request(Peer, NewHashes),

[16.4410]

[16.4517]

                            {ok, {PostReqId, _PostReqMsg, SentSize}} = send_post_request(
                                Peer, NewHashes
                            ),

Replacement in apps/cable/src/peer.erl at line 698 [31.854]

B:BD[16.4682] → [16.4682:4848]

                              peers = update_peer_sent(NewPeers, Peer, SentSize),
                              activeOut = UpdatedOut
                             }

[16.4682]

[40.727]

                                peers = update_peer_sent(NewPeers, Peer, SentSize),
                                activeOut = UpdatedOut
                            }

Replacement in apps/cable/src/peer.erl at line 702 [31.854]
B:BD[40.752] → [19.3168:3169]
∅:D[40.752] → [20.7727:7765]
∅:D[19.3169] → [20.7727:7765]
∅:D[16.4877] → [20.7727:7765]
B:BD[20.7727] → [20.7727:7765]
```
                1 -> %% post response
```
[40.752]
[20.7765]
```
                %% post response
                1 ->
```

Replacement in apps/cable/src/peer.erl at line 707 [31.854]

B:BD[11.8425] → [11.8425:8796]

B:BD[11.8796] → [2.21:144]

∅:D[2.144] → [11.8917:9019]

B:BD[11.8917] → [11.8917:9019]

                                                 %% TODO: avoid double decode by pushing this into the db module
                                                 [NewHeader, _] = posts:decode(Bin),
                                                 H = proplists:get_value(hash, NewHeader),
                                                 HasNot = not db:has_post(Db, H),
                                                 %%io:format("[TEMP] got new(~p) post reply:~n~p~n", [HasNot, NewHeader]),
                                                 HasNot
                                         end,

[11.8425]

[11.9019]

                        %% TODO: avoid double decode by pushing this into the db module
                        [NewHeader, _] = posts:decode(Bin),
                        H = proplists:get_value(hash, NewHeader),
                        HasNot = not db:has_post(Db, H),
                        %%io:format("[TEMP] got new(~p) post reply:~n~p~n", [HasNot, NewHeader]),
                        HasNot
                    end,

Replacement in apps/cable/src/peer.erl at line 718 [31.854]
∅:D[20.8095] → [25.5137:5138]
B:BD[25.5137] → [25.5137:5138]
B:BD[25.5138] → [20.8096:8133]
```
        false -> %% incoming request
```
[20.8095]
[20.8133]
```
        %% incoming request
        false ->
```
Deletion in apps/cable/src/peer.erl at line 721 [31.854]
B:BD[20.8161] → [19.3241:3242]

Replacement in apps/cable/src/peer.erl at line 723 [31.854]

B:BD[20.8233] → [20.8233:8265]

                2 -> % post req

[20.8233]

[20.8265]

                % post req
                2 ->

Replacement in apps/cable/src/peer.erl at line 727 [31.854]

B:BD[20.8376] → [19.3243:3316]

B:BD[19.3316] → [2.145:295]

∅:D[2.295] → [20.8712:8803]

B:BD[20.8712] → [20.8712:8803]

                                             case db:load_post(Db, H) of
                                                 notFound -> false;
                                                 {ok, [_, _, Bin]} -> {true, Bin}
                                             end
                                     end,

[20.8376]

[20.8803]

                        case db:load_post(Db, H) of
                            notFound -> false;
                            {ok, [_, _, Bin]} -> {true, Bin}
                        end
                    end,

Replacement in apps/cable/src/peer.erl at line 735 [31.854]
∅:D[20.9045] → [25.5209:5210]
B:BD[35.11736] → [25.5209:5210]
B:BD[25.5210] → [20.9046:9080]
```
                3 -> % cancel req
```
[20.9045]
[20.9080]
```
                % cancel req
                3 ->
```

Replacement in apps/cable/src/peer.erl at line 739 [31.854]

B:BD[20.9212] → [16.4925:4968]

                        error ->  % ignore

[20.9212]

[16.4968]

                        % ignore
                        error ->

Replacement in apps/cable/src/peer.erl at line 744 [31.854]

B:BD[20.9367] → [40.823:1054]

∅:D[40.1054] → [20.9483:9691]

B:BD[20.9483] → [20.9483:9691]

                                                  F = fun({received, ChanReqId, _}) ->
                                                              CancelId =/= ChanReqId
                                                      end,
                                                  UpdatedReqs = lists:filter(F, ChanReqs),
                                                  {true, UpdatedReqs}
                                          end,

[20.9367]

[20.9691]

                                F = fun({received, ChanReqId, _}) ->
                                    CancelId =/= ChanReqId
                                end,
                                UpdatedReqs = lists:filter(F, ChanReqs),
                                {true, UpdatedReqs}
                            end,

Replacement in apps/cable/src/peer.erl at line 751 [31.854]

B:BD[20.9728] → [16.5024:5072]

∅:D[16.5072] → [20.9810:9971]

B:BD[20.9810] → [20.9810:9971]

                              peers = NewPeers,
                              channels = maps:filtermap(UpdateChans, Chans),
                              activeIn = NewActiveIn
                             }

[20.9728]

[20.9971]

                                peers = NewPeers,
                                channels = maps:filtermap(UpdateChans, Chans),
                                activeIn = NewActiveIn
                            }

Replacement in apps/cable/src/peer.erl at line 756 [31.854]

B:BD[20.9996] → [20.9996:10037]


                4 -> % channel time req

[20.9996]

[20.10037]

                % channel time req
                4 ->

Replacement in apps/cable/src/peer.erl at line 760 [31.854]

B:BD[20.10169] → [16.5073:5115]

                        error -> % ignore

[20.10169]

[16.5115]

                        % ignore
                        error ->

Replacement in apps/cable/src/peer.erl at line 766 [31.854]

∅:D[2.474] → [13.4628:4698]

B:BD[19.3768] → [13.4628:4698]

∅:D[13.4698] → [19.3851:3940]

B:BD[19.3851] → [19.3851:3940]

                            Params = [proplists:get_value(F, Body) ||
                                                      F <- [timestart, timeend, limit]],

[2.474]

[2.475]

                            Params = [
                                proplists:get_value(F, Body)
                             || F <- [timestart, timeend, limit]
                            ],

Replacement in apps/cable/src/peer.erl at line 772 [31.854]

∅:D[13.4849] → [19.3940:4055]

B:BD[19.3940] → [19.3940:4055]

                            {ok, Hashes} = db:get_text_hashes_by_time_range(Db, RequestedChan, Start, End, Limit),

[13.4849]

[19.4055]

                            {ok, Hashes} = db:get_text_hashes_by_time_range(
                                Db, RequestedChan, Start, End, Limit
                            ),

Replacement in apps/cable/src/peer.erl at line 779 [31.854]

B:BD[20.10557] → [19.4224:4306]

∅:D[19.4306] → [20.10639:10839]

∅:D[16.5390] → [20.10639:10839]

B:BD[20.10639] → [20.10639:10839]

                              peers = update_peer_sent(NewPeers, Peer, RespSize),
                              channels = maps:put(RequestedChan, NewChanReqs, TmpChans),
                              activeIn = maps:put(ReqId, {Peer, Msg}, ActiveIn)
                             }

[20.10557]

[20.10839]

                                peers = update_peer_sent(NewPeers, Peer, RespSize),
                                channels = maps:put(RequestedChan, NewChanReqs, TmpChans),
                                activeIn = maps:put(ReqId, {Peer, Msg}, ActiveIn)
                            }

Replacement in apps/cable/src/peer.erl at line 784 [31.854]
∅:D[20.10864] → [25.5641:5642]
B:BD[25.5641] → [25.5641:5642]
B:BD[25.5642] → [20.10865:10906]
```
                5 -> % channel state req
```
[20.10864]
[20.10906]
```
                % channel state req
                5 ->
```

Replacement in apps/cable/src/peer.erl at line 788 [31.854]

B:BD[20.11038] → [16.5391:5433]

                        error -> % ignore

[20.11038]

[16.5433]

                        % ignore
                        error ->

Replacement in apps/cable/src/peer.erl at line 792 [31.854]

B:BD[20.11131] → [13.4850:5010]

                          %%  io:format("[DEBUG] Received incoming state req for ~p from ~p~n",
                          %%            [RequestedChan, Peer]),

[20.11131]

[13.5010]

                            %%  io:format("[DEBUG] Received incoming state req for ~p from ~p~n",
                            %%            [RequestedChan, Peer]),

Replacement in apps/cable/src/peer.erl at line 799 [31.854]

B:BD[20.11436] → [19.4712:4794]

∅:D[19.4794] → [20.11518:11718]

∅:D[16.5656] → [20.11518:11718]

B:BD[20.11518] → [20.11518:11718]

                              peers = update_peer_sent(NewPeers, Peer, RespSize),
                              channels = maps:put(RequestedChan, NewChanReqs, TmpChans),
                              activeIn = maps:put(ReqId, {Peer, Msg}, ActiveIn)
                             }

[20.11436]

[20.11718]

                                peers = update_peer_sent(NewPeers, Peer, RespSize),
                                channels = maps:put(RequestedChan, NewChanReqs, TmpChans),
                                activeIn = maps:put(ReqId, {Peer, Msg}, ActiveIn)
                            }

Replacement in apps/cable/src/peer.erl at line 804 [31.854]

B:BD[20.11743] → [20.11743:11788]


                6 -> % channel list request

[20.11743]

[20.11788]

                % channel list request
                6 ->

Deletion in apps/cable/src/peer.erl at line 810 [31.854]
B:BD[20.12136] → [20.12136:12137]

Replacement in apps/cable/src/peer.erl at line 811 [31.854]

B:BD[20.12166] → [19.4795:4961]

                    io:format("[Warning] unhandled incoming message (Type:~p|ReqId:~p) with activeOut:false~n",
                              [Unhandled, ReqIdStr]),

[20.12166]

[16.5737]

                    io:format(
                        "[Warning] unhandled incoming message (Type:~p|ReqId:~p) with activeOut:false~n",
                        [Unhandled, ReqIdStr]
                    ),

Deletion in apps/cable/src/peer.erl at line 819 [31.854]
B:BD[6.15990] → [6.15990:15991]

Replacement in apps/cable/src/peer.erl at line 825 [31.854]

B:BD[2.634] → [2.634:689]

     %%        , [hex:bin_to_hexstr(CancelId), Peer]),

[2.634]

[19.4962]

    %%        , [hex:bin_to_hexstr(CancelId), Peer]),

Replacement in apps/cable/src/peer.erl at line 827 [31.854]

∅:D[19.5003] → [34.4194:4228]

B:BD[34.4194] → [34.4194:4228]

B:BD[34.4228] → [20.12467:12507]

∅:D[20.12507] → [34.4269:4294]

B:BD[34.4269] → [34.4269:4294]

    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>},
              {ttl, 0}],

[19.5003]

[35.12050]

    Header = [
        {requestId, ReqId},
        {circuitId, <<0, 0, 0, 0>>},
        {ttl, 0}
    ],

Replacement in apps/cable/src/peer.erl at line 839 [31.854]
∅:D[2.827] → [34.4548:4582]
∅:D[35.12267] → [34.4548:4582]
∅:D[20.12640] → [34.4548:4582]
B:BD[34.4548] → [34.4548:4582]
B:BD[34.4582] → [20.12641:12681]
∅:D[20.12681] → [34.4583:4608]
B:BD[26.5711] → [34.4583:4608]
```
    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>},
              {ttl, 3}],
```
[2.827]
[35.12268]
```
    Header = [
        {requestId, ReqId},
        {circuitId, <<0, 0, 0, 0>>},
        {ttl, 3}
    ],
```

Replacement in apps/cable/src/peer.erl at line 851 [31.854]

∅:D[2.969] → [16.6032:6131]

B:BD[16.6032] → [16.6032:6131]

    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>},
              {ttl, 3}],

[2.969]

[16.6131]

    Header = [
        {requestId, ReqId},
        {circuitId, <<0, 0, 0, 0>>},
        {ttl, 3}
    ],

Replacement in apps/cable/src/peer.erl at line 861 [31.854]

∅:D[19.5129] → [20.12682:12819]

B:BD[34.4853] → [20.12682:12819]

∅:D[35.12504] → [34.4853:4887]

∅:D[20.12819] → [34.4853:4887]

B:BD[34.4853] → [34.4853:4887]

B:BD[34.4887] → [20.12820:12860]

∅:D[20.12860] → [35.12505:12530]

B:BD[34.4928] → [35.12505:12530]

    io:format("[DEBUG] sending post request(~p) for ~p hashes to ~p~n"
             , [hex:bin_to_hexstr(ReqId), length(Hashes), Peer]),
    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>},
              {ttl, 3}],

[19.5129]

[35.12530]

    io:format(
        "[DEBUG] sending post request(~p) for ~p hashes to ~p~n",
        [hex:bin_to_hexstr(ReqId), length(Hashes), Peer]
    ),
    Header = [
        {requestId, ReqId},
        {circuitId, <<0, 0, 0, 0>>},
        {ttl, 3}
    ],

Replacement in apps/cable/src/peer.erl at line 874 [31.854]

B:BD[35.12678] → [35.12678:12712]

B:BD[35.12712] → [20.12861:12900]

∅:D[20.12900] → [35.12752:12768]

B:BD[35.12752] → [35.12752:12768]

    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>}
             ],

[35.12678]

[35.12768]

    Header = [
        {requestId, ReqId},
        {circuitId, <<0, 0, 0, 0>>}
    ],

Replacement in apps/cable/src/peer.erl at line 882 [31.854]

B:BD[20.12943] → [19.5130:5266]

∅:D[19.5266] → [20.12943:13032]

B:BD[20.12943] → [20.12943:13032]

    io:format("[DEBUG] sending post response(~p) for ~p posts to ~p~n"
             , [hex:bin_to_hexstr(ReqId), length(Posts), Peer]),
    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>}
             ],

[20.12943]

[20.13032]

    io:format(
        "[DEBUG] sending post response(~p) for ~p posts to ~p~n",
        [hex:bin_to_hexstr(ReqId), length(Posts), Peer]
    ),
    Header = [
        {requestId, ReqId},
        {circuitId, <<0, 0, 0, 0>>}
    ],

Replacement in apps/cable/src/peer.erl at line 894 [31.854]

B:BD[19.5310] → [19.5310:5537]

    io:format("[DEBUG] sending hash response(~p) for ~p hashes to ~p~n"
             , [hex:bin_to_hexstr(ReqId), length(Hashes), Peer]),
    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>}
             ],

[19.5310]

[19.5537]

    io:format(
        "[DEBUG] sending hash response(~p) for ~p hashes to ~p~n",
        [hex:bin_to_hexstr(ReqId), length(Hashes), Peer]
    ),
    Header = [
        {requestId, ReqId},
        {circuitId, <<0, 0, 0, 0>>}
    ],

Replacement in apps/cable/src/peer.erl at line 931 [31.854]

B:BD[25.6132] → [25.6132:6219]

    NewPeers = Peers#{Peer => maps:update(bytesTransmitted, {Tx+Size, Rx}, PeerMeta)},

[25.6132]

[35.13866]

    NewPeers = Peers#{Peer => maps:update(bytesTransmitted, {Tx + Size, Rx}, PeerMeta)},

Replacement in apps/cable/src/peer.erl at line 936 [31.854]

B:BD[25.6255] → [25.6255:6302]

        error -> throw({peerNotActive, Peer});

[25.6255]

[25.6302]

        error ->
            throw({peerNotActive, Peer});

Replacement in apps/cable/src/peer.erl at line 940 [31.854]

B:BD[25.6400] → [20.13129:13274]

            UpdatedMeta = PeerMeta#{ bytesTransmitted => {Tx, Rx+Size}
                                   , lastSeenAt => os:system_time(1000)},

[25.6400]

[25.6508]

            UpdatedMeta = PeerMeta#{
                bytesTransmitted => {Tx, Rx + Size},
                lastSeenAt => os:system_time(1000)
            },

Deletion in apps/cable/src/peer.erl at line 947 [31.854]
B:BD[35.14257] → [20.13275:13276]

Replacement in apps/cable/src/peer.erl at line 952 [31.854]

B:BD[20.13409] → [20.13409:13502]

    ok = case file:make_dir(Loc) of
        ok -> ok;
        {error, eexist} -> ok
    end,

[20.13409]

[20.13502]

    ok =
        case file:make_dir(Loc) of
            ok -> ok;
            {error, eexist} -> ok
        end,

Replacement in apps/cable/src/peer.erl at line 961 [31.854]

B:BD[20.13595] → [20.13595:14095]

    Seed = case file:read_file(Fname) of
               %% load existing
               {ok, Content} when byte_size(Content) =:= 32 ->
                   Content;
               %% generate new keypair
               {error, enoent} ->
                   S = crypto:strong_rand_bytes(32),
                   ok = file:write_file(Fname, S),
                   ok = file:change_mode(Fname, 8#0400),
                   io:format("[Cable] Created fresh keypair~n"),
                   S
           end,

[20.13595]

[20.14095]

    Seed =
        case file:read_file(Fname) of
            %% load existing
            {ok, Content} when byte_size(Content) =:= 32 ->
                Content;
            %% generate new keypair
            {error, enoent} ->
                S = crypto:strong_rand_bytes(32),
                ok = file:write_file(Fname, S),
                ok = file:change_mode(Fname, 8#0400),
                io:format("[Cable] Created fresh keypair~n"),
                S
        end,

Deletion in apps/cable/src/peer.erl at line 979 [31.854]
B:BD[20.14257] → [20.14257:14258]

Replacement in apps/cable/src/peer.erl at line 982 [31.854]

B:BD[20.14302] → [20.14302:14432]

∅:D[20.14432] → [35.14419:14447]

B:BD[35.14419] → [35.14419:14447]

    human_bytesize(Size, ["b","kb","mb","gb"]).
human_bytesize(S, [_|[_|_] = L]) when S >= 1024 ->
    human_bytesize(S/1024, L);
human_bytesize(S, [M|_]) ->

[20.14302]

[25.6573]

    human_bytesize(Size, ["b", "kb", "mb", "gb"]).
human_bytesize(S, [_ | [_ | _] = L]) when S >= 1024 ->
    human_bytesize(S / 1024, L);
human_bytesize(S, [M | _]) ->

Deletion in apps/cable/src/peer.erl at line 995 [31.854]
B:BD[20.14434] → [20.14434:14435]

Replacement in apps/cable/src/peer.erl at line 997 [31.854]

B:BD[20.14500] → [20.14500:14564]

                os:cmd("mktemp --tmpdir -d cabal-test-XXXXX")),

[20.14500]

[20.14564]

        os:cmd("mktemp --tmpdir -d cabal-test-XXXXX")
    ),

Deletion in apps/cable/src/examples.erl at line 2 [42.11]
∅:D[5.44] → [41.752:753]
∅:D[43.53] → [41.752:753]
B:BD[41.752] → [41.752:753]

Replacement in apps/cable/src/examples.erl at line 4 [42.11]

B:BD[43.64] → [43.64:353]

         post_request/0, cancel_request/0, channel_time_range_request/0,
         channel_state_request/0, channel_list_request/0,
         hash_response/0, post_response/0, channel_list_response/0,
         post_text/0, post_delete/0, post_info/0, post_topic/0, post_join/0, post_leave/0

[43.64]

[29.8980]

    post_request/0,
    cancel_request/0,
    channel_time_range_request/0,
    channel_state_request/0,
    channel_list_request/0,
    hash_response/0,
    post_response/0,
    channel_list_response/0,
    post_text/0,
    post_delete/0,
    post_info/0,
    post_topic/0,
    post_join/0,
    post_leave/0

Deletion in apps/cable/src/examples.erl at line 99 [42.11]
B:BD[43.1866] → [43.1866:1867]

Replacement in apps/cable/src/examples.erl at line 113 [42.11]

B:BD[43.2238] → [43.2238:2281]

        {error, Reason} -> {error, Reason}

[43.2238]

[43.2281]

        {error, Reason} ->
            {error, Reason}

Replacement in apps/cable/src/examples.erl at line 119 [42.11]

B:BD[43.2353] → [43.2353:2482]

    {ok, J} = case persistent_term:get(json_data, undefined) of
        undefined -> load();
        Json -> {ok, Json}
    end,

[43.2353]

[43.2482]

    {ok, J} =
        case persistent_term:get(json_data, undefined) of
            undefined -> load();
            Json -> {ok, Json}
        end,

Replacement in apps/cable/src/examples.erl at line 127 [42.11]

B:BD[43.2536] → [43.2536:2568]

∅:D[43.2568] → [44.21236:21308]

B:BD[44.21236] → [44.21236:21308]

B:BD[44.21308] → [43.2569:2677]

    {ok, J } = get_data(Index),
    #{ <<"binary">> := Bin, <<"obj">> := Obj, <<"name">> := Name } = J,
    {ok, [{name, Name},
          {binary, hex:hexstr_to_bin(binary_to_list(Bin))},
          {obj, Obj}]}.

[43.2536]

    {ok, J} = get_data(Index),
    #{<<"binary">> := Bin, <<"obj">> := Obj, <<"name">> := Name} = J,
    {ok, [
        {name, Name},
        {binary, hex:hexstr_to_bin(binary_to_list(Bin))},
        {obj, Obj}
    ]}.

Deletion in apps/cable/src/db.erl at line 9 [45.84]
B:BD[45.258] → [45.258:259]

Replacement in apps/cable/src/db.erl at line 34 [45.84]

B:BD[19.6136] → [19.6136:6207]

B:BD[19.6207] → [13.5438:5478]

∅:D[13.5478] → [19.6245:6416]

B:BD[19.6245] → [19.6245:6416]

    ActualEnd = case End of
                    %% 00:00:00 01.01.2180
                    0 -> 6626966400000;
                    _ -> End
                end,
    ActualLimit = case Limit of
                      0 -> 9001;
                      _ -> Limit
                  end,

[19.6136]

[19.6416]

    ActualEnd =
        case End of
            %% 00:00:00 01.01.2180
            0 -> 6626966400000;
            _ -> End
        end,
    ActualLimit =
        case Limit of
            0 -> 9001;
            _ -> Limit
        end,

Replacement in apps/cable/src/db.erl at line 99 [45.84]

∅:D[11.9588] → [10.5944:5975]

B:BD[10.5944] → [10.5944:5975]

B:BD[10.5975] → [11.9589:9875]

∅:D[11.9875] → [10.6061:6249]

B:BD[10.6061] → [10.6061:6249]

    lists:foreach(fun(Link) ->
                          Row = [{source, {blob, PostHash}}, {parent, {blob, Link}}]
                              ++ case LinkChan of
                                     null -> [];
                                     _ -> [{channel, LinkChan}]
                                 end,
                          {rowid, _EdgeId} = sqlite3:write(Db, links, Row),
                          io:format("[DB/Debug] Inserted Edge: ~p~n", [_EdgeId])
                  end, Links),

[11.9588]

[20.15397]

    lists:foreach(
        fun(Link) ->
            Row =
                [{source, {blob, PostHash}}, {parent, {blob, Link}}] ++
                    case LinkChan of
                        null -> [];
                        _ -> [{channel, LinkChan}]
                    end,
            {rowid, _EdgeId} = sqlite3:write(Db, links, Row),
            io:format("[DB/Debug] Inserted Edge: ~p~n", [_EdgeId])
        end,
        Links
    ),

Replacement in apps/cable/src/db.erl at line 117 [45.84]

B:BD[18.1782] → [40.1058:1185]

B:BD[40.1323] → [40.1323:1631]

B:BD[40.1631] → [11.9925:10071]

∅:D[11.10071] → [40.1706:1722]

B:BD[40.1706] → [40.1706:1722]

    PostInsert = [{user_id, UserId}, {raw_post, Binary}] ++ HeaderTrimmed
        ++ case proplists:get_value(type, Header) of
               1 -> % delete
                   Concat = iolist_to_binary(proplists:get_value(hashes, Body)),
                   [{deletedHashes, Concat}];
               2 -> %% infos
                   Chan = proplists:get_value(channel, Body),
                   Infos = proplists:get_value(infos, Body),
                   [{channel, Chan}, {infos, {blob, jsone:encode(Infos)}}];
               %% text, topic, join or leave
               _ -> Body
           end,

[18.1782]

[20.16573]

    PostInsert =
        [{user_id, UserId}, {raw_post, Binary}] ++ HeaderTrimmed ++
            case proplists:get_value(type, Header) of
                % delete
                1 ->
                    Concat = iolist_to_binary(proplists:get_value(hashes, Body)),
                    [{deletedHashes, Concat}];
                %% infos
                2 ->
                    Chan = proplists:get_value(channel, Body),
                    Infos = proplists:get_value(infos, Body),
                    [{channel, Chan}, {infos, {blob, jsone:encode(Infos)}}];
                %% text, topic, join or leave
                _ ->
                    Body
            end,

Replacement in apps/cable/src/db.erl at line 135 [45.84]

∅:D[18.1949] → [10.6702:6746]

B:BD[10.6702] → [10.6702:6746]

B:BD[10.6746] → [16.6423:6685]

∅:D[16.6685] → [10.6974:7017]

B:BD[10.6974] → [10.6974:7017]

    Prepared = lists:map(fun({Col, Val}) ->
                                 X = case Val of
                                         _ when is_binary(Val) -> {blob, Val};
                                         _ -> Val
                                     end,
                                 {Col, X}
                         end, PostInsert),

[18.1949]

[10.7181]

    Prepared = lists:map(
        fun({Col, Val}) ->
            X =
                case Val of
                    _ when is_binary(Val) -> {blob, Val};
                    _ -> Val
                end,
            {Col, X}
        end,
        PostInsert
    ),

Deletion in apps/cable/src/db.erl at line 149 [45.84]
∅:D[26.6038] → [45.596:597]
∅:D[39.7165] → [45.596:597]
∅:D[10.7265] → [45.596:597]
∅:D[20.16615] → [45.596:597]
B:BD[45.596] → [45.596:597]

Replacement in apps/cable/src/db.erl at line 152 [45.84]

∅:D[9.2312] → [10.7489:7594]

∅:D[20.16749] → [10.7489:7594]

B:BD[10.7489] → [10.7489:7594]


handle_call({loadPostById, IntId}, _From, [{sql, Db}, _] = State) when is_integer(IntId), IntId >= 0 ->

[20.16749]

[9.2313]

handle_call({loadPostById, IntId}, _From, [{sql, Db}, _] = State) when
    is_integer(IntId), IntId >= 0
->

Deletion in apps/cable/src/db.erl at line 157 [45.84]
B:BD[20.16791] → [20.16791:16792]

Replacement in apps/cable/src/db.erl at line 159 [45.84]

B:BD[20.16946] → [20.16946:17202]

    [{columns, ["count"]},
     {rows, [{Count}]}] = sqlite3:sql_exec(Db, Qry, [{blob, Hash}]),
    Result = case Count of
                 0 -> false;
                 1 -> true;
                 Other -> throw({unexpectedCount, Other})
             end,

[20.16946]

[20.17202]

    [
        {columns, ["count"]},
        {rows, [{Count}]}
    ] = sqlite3:sql_exec(Db, Qry, [{blob, Hash}]),
    Result =
        case Count of
            0 -> false;
            1 -> true;
            Other -> throw({unexpectedCount, Other})
        end,

Deletion in apps/cable/src/db.erl at line 170 [45.84]
B:BD[20.17230] → [13.5678:5679]

Replacement in apps/cable/src/db.erl at line 171 [45.84]

B:BD[13.5750] → [13.5750:5860]

    Qry = "SELECT user_id, timestamp, text from posts where channel = ? and type = 0 order by timestamp asc",

[13.5750]

[13.5860]

    Qry =
        "SELECT user_id, timestamp, text from posts where channel = ? and type = 0 order by timestamp asc",

Replacement in apps/cable/src/db.erl at line 174 [45.84]

B:BD[13.5904] → [13.5904:6033]

    [{columns, ["user_id", "timestamp", "text"]}, {rows, Rows}] = sqlite3:sql_exec(Db, Qry, [QryChan]), %%, Start, End, Limit]),

[13.5904]

[13.6033]

    %%, Start, End, Limit]),
    [{columns, ["user_id", "timestamp", "text"]}, {rows, Rows}] = sqlite3:sql_exec(Db, Qry, [
        QryChan
    ]),

Replacement in apps/cable/src/db.erl at line 182 [45.84]

B:BD[13.6202] → [13.6202:6847]

                NewUsers = case maps:is_key(UserId, Users) of
                               true -> Users;
                               false ->
                                   [{columns, ["name", "public_key"]},
                                    {rows, [{NameBin, {blob, PubKey}}]}] = sqlite3:sql_exec(Db, QryUser, [UserId]),
                                   Name = unicode:characters_to_list(NameBin),
                                   Users#{UserId => {Name, PubKey}}
                           end,
                Text = unicode:characters_to_list(TextBin),
                {Texts ++ [{UserId, Ts, Text}], NewUsers}
        end,

[13.6202]

[13.6847]

        NewUsers =
            case maps:is_key(UserId, Users) of
                true ->
                    Users;
                false ->
                    [
                        {columns, ["name", "public_key"]},
                        {rows, [{NameBin, {blob, PubKey}}]}
                    ] = sqlite3:sql_exec(Db, QryUser, [UserId]),
                    Name = unicode:characters_to_list(NameBin),
                    Users#{UserId => {Name, PubKey}}
            end,
        Text = unicode:characters_to_list(TextBin),
        {Texts ++ [{UserId, Ts, Text}], NewUsers}
    end,

Deletion in apps/cable/src/db.erl at line 199 [45.84]
∅:D[18.2055] → [9.2425:2426]
∅:D[13.6927] → [9.2425:2426]
∅:D[20.17230] → [9.2425:2426]
B:BD[9.2425] → [9.2425:2426]

Replacement in apps/cable/src/db.erl at line 200 [45.84]

B:BD[19.6753] → [11.10106:10219]

    Qry = "SELECT hash from posts where channel = ? and timestamp >= ? and timestamp <= ? and type = 0 limit ?",

[19.6753]

[19.6853]

    Qry =
        "SELECT hash from posts where channel = ? and timestamp >= ? and timestamp <= ? and type = 0 limit ?",

Deletion in apps/cable/src/db.erl at line 206 [45.84]
B:BD[19.7077] → [19.7077:7078]

Replacement in apps/cable/src/db.erl at line 212 [45.84]

B:BD[11.10285] → [13.6948:7284]

    Qry = "SELECT DISTINCT source FROM links "
        ++ "WHERE source NOT IN ("
        ++ "  SELECT DISTINCT parent FROM links"
        ++ "    WHERE channel = ? or channel is null)",
    QryChan = case Chan of
                  null -> null;
                  _ when is_list(Chan) -> {blob, list_to_binary(Chan)}
              end,

[11.10285]

[13.7284]

    Qry =
        "SELECT DISTINCT source FROM links " ++
            "WHERE source NOT IN (" ++
            "  SELECT DISTINCT parent FROM links" ++
            "    WHERE channel = ? or channel is null)",
    QryChan =
        case Chan of
            null -> null;
            _ when is_list(Chan) -> {blob, list_to_binary(Chan)}
        end,

Deletion in apps/cable/src/db.erl at line 225 [45.84]
B:BD[13.7447] → [13.7447:7448]

Replacement in apps/cable/src/db.erl at line 232 [45.84]

B:BD[13.7654] → [13.7654:7761]

∅:D[13.7761] → [11.10655:10929]

B:BD[11.10655] → [11.10655:10929]

B:BD[11.10929] → [13.7762:7899]

∅:D[13.7899] → [11.11158:11254]

B:BD[11.11158] → [11.11158:11254]

    InfoPostQry = "SELECT hash from posts where user_id = ? and type = 2 order by timestamp desc limit 1",
    InfosHashes = lists:foldl(fun({_, UserId}, Acc) ->
                                      [{columns, ["hash"]},
                                       {rows, InfoRows}] = sqlite3:sql_exec(Db, InfoPostQry, [UserId]),
                                      case InfoRows of
                                          [{{blob, H}}] -> sets:add_element(H, Acc);
                                          [] -> Acc
                                      end
                              end, sets:new(), Rows),

[13.7654]

[11.11254]

    InfoPostQry =
        "SELECT hash from posts where user_id = ? and type = 2 order by timestamp desc limit 1",
    InfosHashes = lists:foldl(
        fun({_, UserId}, Acc) ->
            [
                {columns, ["hash"]},
                {rows, InfoRows}
            ] = sqlite3:sql_exec(Db, InfoPostQry, [UserId]),
            case InfoRows of
                [{{blob, H}}] -> sets:add_element(H, Acc);
                [] -> Acc
            end
        end,
        sets:new(),
        Rows
    ),

Deletion in apps/cable/src/db.erl at line 252 [45.84]
B:BD[11.11349] → [11.11349:11350]

Replacement in apps/cable/src/db.erl at line 259 [45.84]

B:BD[11.11598] → [13.8030:8308]

    MembersQry = "SELECT u.name as name, u.public_key as pub_key, p.timestamp as timestamp, p.type as type "
        ++ "FROM channel_members m "
        ++ "JOIN posts p ON m.last_hash = p.hash "
        ++ "JOIN users u ON m.user_id = u.id "
        ++ "WHERE m.channel = ?",

[11.11598]

[2.973]

    MembersQry =
        "SELECT u.name as name, u.public_key as pub_key, p.timestamp as timestamp, p.type as type " ++
            "FROM channel_members m " ++
            "JOIN posts p ON m.last_hash = p.hash " ++
            "JOIN users u ON m.user_id = u.id " ++
            "WHERE m.channel = ?",

Replacement in apps/cable/src/db.erl at line 266 [45.84]

∅:D[2.1035] → [13.8309:8367]

B:BD[11.11975] → [13.8309:8367]

∅:D[13.8367] → [11.12025:12089]

B:BD[11.12025] → [11.12025:12089]

    [ {columns, ["name", "pub_key", "timestamp", "type"]}
    , {rows, Rows}] = sqlite3:sql_exec(Db, MembersQry, [Chan]),

[2.1035]

[2.1036]

    [
        {columns, ["name", "pub_key", "timestamp", "type"]},
        {rows, Rows}
    ] = sqlite3:sql_exec(Db, MembersQry, [Chan]),

Replacement in apps/cable/src/db.erl at line 271 [45.84]

∅:D[2.1084] → [11.12134:12171]

B:BD[11.12134] → [11.12134:12171]

B:BD[11.12171] → [13.8368:8445]

∅:D[13.8445] → [11.12238:12310]

B:BD[11.12238] → [11.12238:12310]

B:BD[11.12310] → [13.8446:8716]

∅:D[13.8716] → [11.12367:12404]

B:BD[11.12367] → [11.12367:12404]

    M = lists:foldl(fun(Row, Acc) ->
                            {NameBin, {blob, PubKey}, When, PostType} = Row,
                            Name = unicode:characters_to_list(NameBin),
                            HasLeft = case PostType of
                                          4 -> false;
                                          5 -> true
                                      end,
                            Acc#{PubKey => {Name, When, HasLeft}}
                    end, #{}, Rows),

[2.1084]

[11.12404]

    M = lists:foldl(
        fun(Row, Acc) ->
            {NameBin, {blob, PubKey}, When, PostType} = Row,
            Name = unicode:characters_to_list(NameBin),
            HasLeft =
                case PostType of
                    4 -> false;
                    5 -> true
                end,
            Acc#{PubKey => {Name, When, HasLeft}}
        end,
        #{},
        Rows
    ),

Replacement in apps/cable/src/db.erl at line 286 [45.84]

B:BD[11.12405] → [11.12405:12464]

    Result = [{topic, Topic},
              {members, M}],

[11.12405]

[19.7436]

    Result = [
        {topic, Topic},
        {members, M}
    ],

Deletion in apps/cable/src/db.erl at line 291 [45.84]
∅:D[9.2426] → [10.8696:8697]
∅:D[19.7470] → [10.8696:8697]
∅:D[20.17276] → [10.8696:8697]
B:BD[10.8696] → [10.8696:8697]
Deletion in apps/cable/src/db.erl at line 294 [45.84]
B:BD[45.786] → [15.3365:3366]

Replacement in apps/cable/src/db.erl at line 295 [45.84]

B:BD[20.17470] → [20.17470:17677]

    Res = case sqlite3:write(Db, channels, [{name, Name}, {topic, ""}]) of
              {rowid, _RowId} -> ok;
              {error, 19, _Msg} -> ok %% constraint violation => already joined
          end,

[20.17470]

[20.17677]

    Res =
        case sqlite3:write(Db, channels, [{name, Name}, {topic, ""}]) of
            {rowid, _RowId} -> ok;
            %% constraint violation => already joined
            {error, 19, _Msg} -> ok
        end,

Deletion in apps/cable/src/db.erl at line 302 [45.84]
B:BD[20.17702] → [15.3367:3368]

Replacement in apps/cable/src/db.erl at line 304 [45.84]

B:BD[20.17847] → [20.17847:17892]

∅:D[20.17892] → [10.8880:8965]

B:BD[45.945] → [10.8880:8965]

    Chans = lists:map(fun({Name, _Topic}) ->
                              binary_to_list(Name)
                      end, Rows),

[20.17847]

[2.1085]

    Chans = lists:map(
        fun({Name, _Topic}) ->
            binary_to_list(Name)
        end,
        Rows
    ),

Deletion in apps/cable/src/db.erl at line 312 [45.84]
B:BD[45.1021] → [45.1021:1022]
B:BD[45.1022] → [11.12465:12466]
Replacement in apps/cable/src/db.erl at line 325 [45.84]
B:BD[45.1225] → [10.8966:9013]
```
terminate(normal,  [{sql, Db}, _] = _State) ->
```
[45.1225]
[26.6039]
```
terminate(normal, [{sql, Db}, _] = _State) ->
```
Replacement in apps/cable/src/db.erl at line 328 [45.84]
B:BD[26.6070] → [10.9014:9061]
```
terminate(killed,  [{sql, Db}, _] = _State) ->
```
[26.6070]
[26.6116]
```
terminate(killed, [{sql, Db}, _] = _State) ->
```
Deletion in apps/cable/src/db.erl at line 342 [45.84]
B:BD[9.2428] → [11.12468:12469]

Replacement in apps/cable/src/db.erl at line 344 [45.84]

B:BD[11.12506] → [11.12506:12646]

     [ {public_key, PubKey}
     , {links, _Links}
     , {type, Type}
     , {timestamp, _TimeStamp}
     , {hash, Hash}
     ],
     Body

[11.12506]

[11.12646]

        [
            {public_key, PubKey},
            {links, _Links},
            {type, Type},
            {timestamp, _TimeStamp},
            {hash, Hash}
        ],
        Body

Replacement in apps/cable/src/db.erl at line 355 [45.84]

B:BD[11.12725] → [11.12725:12989]

        0 -> ok; %% text: nothing to do
        1 -> %% delete
            [ {hashes, Hashes} ] = Body,
            lists:foreach(fun(H) ->
                                  ok = sqlite3:delete(Db, posts, {hash, {blob, H}})
                          end, Hashes),

[11.12725]

[11.12989]

        %% text: nothing to do
        0 ->
            ok;
        %% delete
        1 ->
            [{hashes, Hashes}] = Body,
            lists:foreach(
                fun(H) ->
                    ok = sqlite3:delete(Db, posts, {hash, {blob, H}})
                end,
                Hashes
            ),

Replacement in apps/cable/src/db.erl at line 368 [45.84]

B:BD[11.13005] → [11.13005:13068]

        2 -> %% infos
            [ {infos, InfoMap} ] = Body,

[11.13005]

[11.13068]

        %% infos
        2 ->
            [{infos, InfoMap}] = Body,

Replacement in apps/cable/src/db.erl at line 376 [45.84]

B:BD[11.13331] → [11.13331:13412]

        3 -> %% topic
            [ {channel, Chan}, {topic, TopicBin} ] = Body,

[11.13331]

[11.13412]

        %% topic
        3 ->
            [{channel, Chan}, {topic, TopicBin}] = Body,

Replacement in apps/cable/src/db.erl at line 383 [45.84]

B:BD[11.13578] → [11.13578:13618]

B:BD[11.13618] → [13.8717:8974]

            [ {channel, Chan} ] = Body,
            Qry = "INSERT INTO channel_members(channel, user_id, last_hash) VALUES (?, ?, ?) "
                ++ "ON CONFLICT(user_id) DO UPDATE SET last_hash=excluded.last_hash",
            Res = sqlite3:sql_exec(Db, Qry, [ Chan, UserId, {blob, Hash}]),

[11.13578]

[11.13846]

            [{channel, Chan}] = Body,
            Qry =
                "INSERT INTO channel_members(channel, user_id, last_hash) VALUES (?, ?, ?) " ++
                    "ON CONFLICT(user_id) DO UPDATE SET last_hash=excluded.last_hash",
            Res = sqlite3:sql_exec(Db, Qry, [Chan, UserId, {blob, Hash}]),

Replacement in apps/cable/src/db.erl at line 391 [45.84]
B:BD[11.13905] → [11.13905:13945]
```
            [ {channel, Chan} ] = Body,
```
[11.13905]
[13.8975]
```
            [{channel, Chan}] = Body,
```

Replacement in apps/cable/src/db.erl at line 400 [45.84]

B:BD[11.14306] → [11.14306:14455]

    [{columns, ["id","public_key","name"]},
     {rows, [{UserId, {blob, PubKey}, _Name}]}] = sqlite3:read(Db, users, {public_key, {blob, PubKey}}),

[11.14306]

[11.14455]

    [
        {columns, ["id", "public_key", "name"]},
        {rows, [{UserId, {blob, PubKey}, _Name}]}
    ] = sqlite3:read(Db, users, {public_key, {blob, PubKey}}),

Deletion in apps/cable/src/db.erl at line 406 [45.84]
B:BD[11.14468] → [11.14468:14469]

Replacement in apps/cable/src/db.erl at line 407 [45.84]

B:BD[9.2458] → [20.18042:18350]

    ExpectedCols = ["id", "hash", "type", "timestamp", "user_id", "raw_post",
                    "channel", "text", "topic", "deletedHashes", "infos"],
     case ReadResult of
         [{columns, ExpectedCols},
          {rows, [Row]}] -> {ok, unpackPostRow(Db, Row)};
         _Other -> notFound
     end.

[9.2458]

[20.18350]

    ExpectedCols = [
        "id",
        "hash",
        "type",
        "timestamp",
        "user_id",
        "raw_post",
        "channel",
        "text",
        "topic",
        "deletedHashes",
        "infos"
    ],
    case ReadResult of
        [
            {columns, ExpectedCols},
            {rows, [Row]}
        ] ->
            {ok, unpackPostRow(Db, Row)};
        _Other ->
            notFound
    end.

Replacement in apps/cable/src/db.erl at line 431 [45.84]

B:BD[20.18377] → [11.14470:14539]

∅:D[18.2259] → [9.2727:2794]

∅:D[11.14539] → [9.2727:2794]

∅:D[20.18442] → [9.2727:2794]

B:BD[9.2727] → [9.2727:2794]

    {_RowId, {blob, Hash}, Type, Timestamp, UserId, {blob, RawPost},
     ChannelBlob, TextBlob, TopicBlob, Deleteds, InfosBlob} = Row,

[20.18377]

[20.18443]

    {_RowId, {blob, Hash}, Type, Timestamp, UserId, {blob, RawPost}, ChannelBlob, TextBlob,
        TopicBlob, Deleteds, InfosBlob} = Row,

Replacement in apps/cable/src/db.erl at line 434 [45.84]

B:BD[20.18444] → [11.14540:14589]

∅:D[11.14589] → [20.18482:18556]

B:BD[20.18482] → [20.18482:18556]

B:BD[20.18556] → [11.14590:14663]

    [{columns, ["channel", "source", "parent"]},
     {rows, LinkRows}] = sqlite3:read(Db, links, {source, {blob, Hash}}),
    Links = [Parent || {_, {blob, _Source}, {blob, Parent}} <-LinkRows],

[20.18444]

[2.1143]

    [
        {columns, ["channel", "source", "parent"]},
        {rows, LinkRows}
    ] = sqlite3:read(Db, links, {source, {blob, Hash}}),
    Links = [Parent || {_, {blob, _Source}, {blob, Parent}} <- LinkRows],

Replacement in apps/cable/src/db.erl at line 441 [45.84]

B:BD[20.18558] → [20.18558:18718]

    Qry =  "SELECT public_key from users where id = ?",
    [{columns, ["public_key"]},
     {rows, [{{blob, PubKey}}]}] = sqlite3:sql_exec(Db, Qry, [UserId]),

[20.18558]

[18.2399]

    Qry = "SELECT public_key from users where id = ?",
    [
        {columns, ["public_key"]},
        {rows, [{{blob, PubKey}}]}
    ] = sqlite3:sql_exec(Db, Qry, [UserId]),

Replacement in apps/cable/src/db.erl at line 447 [45.84]

∅:D[18.2400] → [9.3029:3065]

B:BD[9.3029] → [9.3029:3065]

B:BD[9.3097] → [9.3097:3237]

    Header = [ {public_key, PubKey}
             , {links, Links}
             , {type, Type}
             , {timestamp, Timestamp}
             , {hash, Hash}
             ],

[18.2400]

[9.3237]

    Header = [
        {public_key, PubKey},
        {links, Links},
        {type, Type},
        {timestamp, Timestamp},
        {hash, Hash}
    ],

Replacement in apps/cable/src/db.erl at line 455 [45.84]

B:BD[9.3264] → [9.3264:4134]

    Body = case Type of
               0 ->
                   {blob, Text} = TextBlob,
                   {blob, Channel} = ChannelBlob,
                   [{channel, Channel}, {text, Text}];
               1 ->
                   {blob, DeletedConcat} = Deleteds,
                   [{hashes, split_concated_hashes(DeletedConcat)}];
               2 ->
                   {blob, InfosJson} = InfosBlob,
                   [{infos, jsone:decode(InfosJson)}];
               3 ->
                   {blob, Topic} = TopicBlob,
                   {blob, Channel} = ChannelBlob,
                   [{channel, Channel}, {topic, Topic}];
               4 ->
                   {blob, Channel} = ChannelBlob,
                   [{channel, Channel}];
               5 ->
                   {blob, Channel} = ChannelBlob,
                   [{channel, Channel}]
           end,

[9.3264]

[18.2401]

    Body =
        case Type of
            0 ->
                {blob, Text} = TextBlob,
                {blob, Channel} = ChannelBlob,
                [{channel, Channel}, {text, Text}];
            1 ->
                {blob, DeletedConcat} = Deleteds,
                [{hashes, split_concated_hashes(DeletedConcat)}];
            2 ->
                {blob, InfosJson} = InfosBlob,
                [{infos, jsone:decode(InfosJson)}];
            3 ->
                {blob, Topic} = TopicBlob,
                {blob, Channel} = ChannelBlob,
                [{channel, Channel}, {topic, Topic}];
            4 ->
                {blob, Channel} = ChannelBlob,
                [{channel, Channel}];
            5 ->
                {blob, Channel} = ChannelBlob,
                [{channel, Channel}]
        end,

Replacement in apps/cable/src/db.erl at line 489 [45.84]

B:BD[10.9475] → [18.2431:2514]

B:BD[18.2514] → [13.9146:9425]

∅:D[13.9425] → [11.14793:14889]

B:BD[11.14793] → [11.14793:14889]

∅:D[18.2600] → [10.9642:9659]

∅:D[11.14889] → [10.9642:9659]

B:BD[10.9642] → [10.9642:9659]

               channels => [{name, text, [primary_key]}, {topic, text, not_null}],
               channel_members => [ColId
                                  , {channel, text, not_null}
                                  , {user_id, integer, [unique, not_null]}
                                  , {last_hash, blob, not_null}
                                  ],
               users => [ColId, {public_key, blob, [unique, not_null]}, {name, text, not_null}]
              },

[10.9475]

[10.9659]

        channels => [{name, text, [primary_key]}, {topic, text, not_null}],
        channel_members => [
            ColId,
            {channel, text, not_null},
            {user_id, integer, [unique, not_null]},
            {last_hash, blob, not_null}
        ],
        users => [ColId, {public_key, blob, [unique, not_null]}, {name, text, not_null}]
    },

Replacement in apps/cable/src/db.erl at line 501 [45.84]

B:BD[10.9768] → [10.9768:9950]

                                  ok = sqlite3:create_table(Db, T, Cols),
                                  io:format("[DB] Created table: ~p~n", [T])
                          end,

[10.9768]

[10.9950]

                ok = sqlite3:create_table(Db, T, Cols),
                io:format("[DB] Created table: ~p~n", [T])
            end,

Deletion in apps/cable/src/db.erl at line 509 [45.84]
B:BD[10.10036] → [10.10036:10037]
Deletion in apps/cable/src/db.erl at line 517 [45.84]
B:BD[9.4156] → [9.4156:4157]
Replacement in apps/cable/src/db.erl at line 524 [45.84]
B:BD[9.4433] → [9.4433:4443]
```
     Acc.
```
[9.4433]
```
    Acc.
```