New features and fixes:

* Added a new mechanism for truncating text using fractions
* Bugfixes
* Code improvements

Author: hyperimpose

src/irc_messages/irc_make.erl

@@ -130,19 +130,30 @@ notice_max_size(Id, Msgtarget) ->
 %% Command: NOTICE
 %% Parameters: <msgtarget> <text to be sent>
 
-notice(Id, Recv, Text) -> notice(Id, Recv, Text, {truncate, ?DEFAULT_TRUNC}).
+notice(Id, Recv, Text) -> notice(Id, Recv, Text, #{mode => truncate}).
 
 
-notice(Id, Recv, Text, {truncate, Ellipsis}) ->
-    MaxSize = notice_max_size(Id, Recv),
-    TruncText = irc_text:truncate(clean_up(Text), MaxSize, Ellipsis),
-    {message, #{command  => privmsg,
+notice(Id, Recv, Text, #{mode := truncate} = Opts) ->
+    Ellipsis = maps:get(ellipsis, Opts, ?DEFAULT_TRUNC),
+    Max = notice_max_size(Id, Recv),
+    Out = irc_text:truncate(clean_up(Text), Max, Ellipsis),
+    {message, #{command  => notice,
+                receiver => Recv,
+                message  => irc_command:notice(Recv, Out)}};
+
+notice(Id, Recv, Texts, #{mode := fractional} = Opts) ->
+    Ellipsis = maps:get(ellipsis, Opts, ?DEFAULT_TRUNC),
+    Max = notice_max_size(Id, Recv),
+    Ts = [{F, clean_up(T)} || {F, T} <- Texts],
+    Out = irc_text:fractional_truncate(Ts, Max, Ellipsis),
+    {message, #{command  => notice,
                 receiver => Recv,
-                message  => irc_command:notice(Recv, TruncText)}};
+                message  => irc_command:notice(Recv, Out)}};
+
 notice(Id, Recv, Text, divide) ->
     MaxSize = notice_max_size(Id, Recv),
     TextList = irc_text:divide(clean_up(Text), MaxSize),
-    F = fun (X) -> {message, #{command => privmsg,
+    F = fun (X) -> {message, #{command => notice,
                                receiver => Recv,
                                message => irc_command:notice(Recv, X)}}
         end,
@@ -178,18 +189,29 @@ privmsg_max_size(Id, Msgtarget) ->
 %% Command: PRIVMSG
 %% Parameters: <msgtarget> <text to be sent>
 
-privmsg(Id, Recv, Text) -> privmsg(Id, Recv, Text, {truncate, ?DEFAULT_TRUNC}).
+privmsg(Id, Recv, Text) -> privmsg(Id, Recv, Text, #{mode => truncate}).
 
 
-privmsg(Id, Recv, Text, {truncate, Ellipsis}) ->
-    MaxSize = privmsg_max_size(Id, Recv),
-    TruncText = irc_text:truncate(clean_up(Text), MaxSize, Ellipsis),
+privmsg(Id, Recv, Text, #{mode := truncate} = Opts) ->
+    Ellipsis = maps:get(ellipsis, Opts, ?DEFAULT_TRUNC),
+    Max = privmsg_max_size(Id, Recv),
+    Out = irc_text:truncate(clean_up(Text), Max, Ellipsis),
     {message, #{command  => privmsg,
                 receiver => Recv,
-                message  => irc_command:privmsg(Recv, TruncText)}};
-privmsg(Id, Recv, Text, divide) ->
-    MaxSize = privmsg_max_size(Id, Recv),
-    TextList = irc_text:divide(clean_up(Text), MaxSize),
+                message  => irc_command:privmsg(Recv, Out)}};
+
+privmsg(Id, Recv, Texts, #{mode := fractional} = Opts) ->
+    Ellipsis = maps:get(ellipsis, Opts, ?DEFAULT_TRUNC),
+    Max = privmsg_max_size(Id, Recv),
+    Ts = [{F, clean_up(T)} || {F, T} <- Texts],
+    Out = irc_text:fractional_truncate(Ts, Max, Ellipsis),
+    {message, #{command  => privmsg,
+                receiver => Recv,
+                message  => irc_command:privmsg(Recv, Out)}};
+
+privmsg(Id, Recv, Text, #{mode := divide}) ->
+    Max = privmsg_max_size(Id, Recv),
+    TextList = irc_text:divide(clean_up(Text), Max),
     F = fun (X) -> {message, #{command => privmsg,
                                receiver => Recv,
                                message => irc_command:privmsg(Recv, X)}}
@@ -198,8 +220,8 @@ privmsg(Id, Recv, Text, divide) ->
 
 
 ctcp_action(Id, Target, Text) ->
-    MaxSize = privmsg_max_size(Id, Target) - 9,
-    TruncText = irc_text:truncate(clean_up(Text), MaxSize, ?DEFAULT_TRUNC),
+    Max = privmsg_max_size(Id, Target) - 9,
+    Out = irc_text:truncate(clean_up(Text), Max, ?DEFAULT_TRUNC),
     {message, #{command  => privmsg,
                 receiver => Target,
-                message  => irc_command:ctcp_action(Target, TruncText)}}.
+                message  => irc_command:ctcp_action(Target, Out)}}.

src/lib/irc_text.erl

@@ -1,7 +1,9 @@
 -module(irc_text).
 
 
--export([divide/2, truncate/2, truncate/3]).
+-export([divide/2,
+         truncate/2, truncate/3,
+         fractional_truncate/2, fractional_truncate/3]).
 
 
 divide(Text, Limit) -> divide(string:to_graphemes(Text), Limit, 0, [], []).
@@ -43,3 +45,55 @@ truncate(Text, Limit, Ellipsis, Size, Acc) ->
         {error, _} ->
             lists:reverse([[Ellipsis] | Acc])
     end.
+
+
+%%--------------------------------------------------------------------
+%% Fractionally truncate a list of strings.
+%%
+%% The caller assigns to each string a fraction. This fraction describes how
+%% much of the final output each string will take.
+%%
+%% Assigning 1 instead of a fraction means that the string should not be
+%% truncated. In that case the whole string will be used and its byte size will
+%% be subtracted from the Limit available to fractional texts.
+%%
+%% Each string from the list is truncated so that it doesn't use more than
+%% (Fraction * Limit) bytes. All the fractions should add up to 1.
+%%
+%% @param Texts A list of tuples in the following format: [{0.0..1.0, iodata()}]
+%%
+%% Example: [{1,   "Text 1"},
+%%           {2/3, "Text 2"},
+%%           {1/3, "Text 3"}]
+%%
+%% @param Limit The maximum number of bytes allowed in the result.
+%% @param Ellipsis A string to append to any truncated text.
+%% @returns A single text string that can fit within the given Limit.
+%%--------------------------------------------------------------------
+
+-spec fractional_truncate(Texts :: [{number(), iodata()}],
+                          Limit :: integer())
+                         -> iodata().
+
+fractional_truncate(Texts, Limit) -> fractional_truncate(Texts, Limit, <<>>).
+
+
+-spec fractional_truncate(Texts :: [{number(), iodata()}],
+                          Limit :: integer(),
+                          Ellipsis :: iodata())
+                         -> iodata().
+
+fractional_truncate(Texts, Limit, Ellipsis) ->
+    Ones = unicode:characters_to_binary([T || {F, T} <- Texts, F =:= 1]),
+    Avail = Limit - byte_size(Ones),
+
+    F = fun ({1, T}, Acc) ->
+                [T | Acc];
+            ({F, T}, Acc) ->
+                Max = case floor(Avail * F) of
+                          Size when Size =< Avail -> Size;
+                          _Else                   -> Avail
+                      end,
+                [truncate(T, Max, Ellipsis) | Acc]
+        end,
+    lists:reverse(lists:foldl(F, [], Texts)).