deavmi / birchwood / #7

Committed 12 May 2024 04:08PM UTC coverage: 86.432%. First build

Build # #7

Build Type

push

coveralls-ruby

Committed by

web-flow

Commit Message

Upgrade/logging (#44)

* Dub

- Switched to `gogga` for logging

* birchwood.logging

- Added logging facilities

* Client

- Use new logging facility

* Receiver

- Use new logging facility

* Messages

- Use new logging facility

* Messages

- Cleaned up

* Dub

- Bumped

* Dub

- Bumped

* Revert "Dub"

This reverts commit a7049d1d8.

* Reapply "Dub"

This reverts commit 44b9b1982.

Run Details

22 of 24 new or added lines in 4 files covered. (91.67%)

516 of 597 relevant lines covered (86.43%)

260.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.86

/source/birchwood/protocol/messages.d

/** 
 * Message definition and tooling
 */
module birchwood.protocol.messages;

import dlog;

import std.string;
import std.conv : to, ConvException;
import birchwood.protocol.constants : ReplyType;

import birchwood.client.exceptions;
import birchwood.config.conninfo : ChecksMode;
import birchwood.logging;

/* TODO: We could move these all to `package.d` */

/** 
 * Encodes the provided message into a CRLF
 * terminated byte array
 *
 * Params:
 *   messageIn = the message to encode
 * Returns: the encoded message
 */
public ubyte[] encodeMessage(string messageIn)
{
    ubyte[] messageOut = cast(ubyte[])messageIn;
    messageOut~=[cast(ubyte)13, cast(ubyte)10];
    return messageOut;
}

public static string decodeMessage(ubyte[] messageIn)
{
    /* TODO: We could do a chekc to ESNURE it is well encoded */

    return cast(string)messageIn[0..messageIn.length-2];
    // return  null;
}

/** 
 * Checks if the provided message is valid (i.e.)
 * does not contain any CR or LF characters in it
 *
 * Params:
 *   message = the message to test
 * Returns: <code>true</code> if the message is valid,
 * <code>false</code> false otherwise
 */
 //TODO: Should we add an emptiness check here
public static bool isValidText(string message)
{
    foreach(char character; message)
    {
        if(character == 13 || character == 10)
        {
            return false;
        }
    }

    return true;
}

/**
 * Message types
 */
public final class Message
{
    /* Message contents */
    private string from;
    private string command;
    private string params;

    /* The numeric reply (as per Section 6 of RFC 1459) */
    private bool isNumericResponse = false;
    private ReplyType replyType = ReplyType.BIRCHWOOD_UNKNOWN_RESP_CODE;
    private bool isError = false;

    /** 
     * Constructs a new Message
     *
     * Params:
     *   from = the from parameter
     *   command = the command
     *   params = any optional parameters to the command
     */
    this(string from, string command, string params = "")
    {
        this.from = from;
        this.command = command;
        this.params = params;

        /* Check if this is a command reply */
        if(isNumeric(command))
        {
            isNumericResponse = true;
            
            //FIXME: SOmething is tripping it u, elts' see
            try
            {
                /* Grab the code */
                replyType = to!(ReplyType)(to!(ulong)(command));
                // TODO: Add validity check on range of values here, if bad throw exception
                // TODO: Add check for "6.3 Reserved numerics" or handling of SOME sorts atleast

                /* Error codes are in range of [401, 502] */
                if(replyType >= 401 && replyType <= 502)
                {
                    // TODO: Call error handler
                    isError = true;
                }
                /* Command replies are in range of [259, 395] */
                else if(replyType >= 259 && replyType <= 395)
                {
                    // TODO: Call command-reply handler
                    isError = false;
                }
            }
            catch(ConvException e)
            {
                DEBUG("<<< Unsupported response code (Error below) >>>");
                DEBUG(e);
            }
        }

        /* Parse the parameters into key-value pairs (if any) and trailing text (if any) */
        parameterParse();
    }

    /** 
     * Encodes this `Message` into a CRLF delimited
     * byte array
     *
     * If `ChecksMode` is set to `EASY` (default) then
     * any invalid characters will be stripped prior
     * to encoding
     *
     * Params:
     *    mode = the `ChecksMode` to use
     *
     * Throws: 
     *  `BirchwoodException` if `ChecksMode` is set to
     *  `HARDCORE` and invalid characters are present
     * Returns: the encoded format
     */
    public string encode(ChecksMode mode)
    {
        string fullLine;

        /** 
         * Copy over the values (they might be updated and we
         * want to leave the originals intact)
         */
        string fFrom = from, fCommand = command, fParams = params;
        
        /** 
         * If in `HARDCORE` mode then and illegal characters
         * are present, throw an exception
         */
        if(mode == ChecksMode.HARDCORE && (
                                            hic(fFrom) ||
                                            hic(fCommand) ||
                                            hic(fParams)
                                          ))
        {
            throw new BirchwoodException(ErrorType.ILLEGAL_CHARACTERS, "Invalid characters present");
        }
        /** 
         * If in `EASY` mode and illegal characters have
         * been found, then fix them up
         */
        else
        {
            // Strip illegal characters from all
            fFrom = sic(fFrom);
            fCommand = sic(fCommand);
            fParams = sic(fParams);
        }
        
        /* Combine */
        fullLine = fFrom~" "~fCommand~" "~fParams;

        

        return fullLine;
    }

    // TODO: comemnt
    private alias sic = stripIllegalCharacters;
    // TODO: comemnt
    private alias hic = hasIllegalCharacters;

    /** 
     * Checks whether the provided input string contains
     * any invalid characters
     *
     * Params:
     *   input = the string to check
     * Returns: `true` if so, `false` otherwise
     */
    // TODO: Add unittest
    public static bool hasIllegalCharacters(string input)
    {
        foreach(char character; input)
        {
            if(character == '\n' || character == '\r')
            {
                return true;
            }
        }

        return false;
    }

    /** 
     * Provided an input string this will strip any illegal
     * characters present within it
     *
     * Params:
     *   input = the string to filter
     * Returns: the filtered string
     */
    // TODO: Add unittest
    public static string stripIllegalCharacters(string input)
    {
        string stripped;
        foreach(char character; input)
        {
            if(character == '\n' || character == '\r')
            {
                continue;
            }

            stripped ~= character;
        }

        return stripped;
    }

    public static Message parseReceivedMessage(string message)
    {
        /* TODO: testing */

        /* From */
        string from;

        /* Command */
        string command;

        /* Params */
        string params;



        /* Check if there is a PREFIX (according to RFC 1459) */
        if(message[0] == ':')
        {
            /* prefix ends after first space (we fetch servername, host/user) */
            //TODO: make sure not -1
            long firstSpace = indexOf(message, ' ');

            /* TODO: double check the condition */
            if(firstSpace > 0)
            {
                from = message[1..firstSpace];

                // DEBUG("from: "~from);

                /* TODO: Find next space (what follows `from` is  `' ' { ' ' }`) */
                ulong i = firstSpace;
                for(; i < message.length; i++)
                {
                    if(message[i] != ' ')
                    {
                        break;
                    }
                }

                // writeln("Yo");

                string rem = message[i..message.length];
                // writeln("Rem: "~rem);
                long idx  = indexOf(rem, " "); //TOOD: -1 check

                /* Extract the command */
                command = rem[0..idx];
                // DEBUG("command: "~command);

                /* Params are everything till the end */
                i = idx;
                for(; i < rem.length; i++)
                {
                    if(rem[i] != ' ')
                    {
                        break;
                    }
                }
                params = rem[i..rem.length];
                // DEBUG("params: "~params);
            }
            else
            {
                //TODO: handle
                DEBUG("Malformed message start after :");
                assert(false);
            }

            
        }
        /* In this case it is only `<command> <params>` */
        else
        {

            long firstSpace = indexOf(message, " "); //TODO: Not find check
            
            command = message[0..firstSpace];

            ulong pos = firstSpace;
            for(; pos < message.length; pos++)
            {
                if(message[pos] != ' ')
                {
                    break;
                }
            }

            params = message[pos..message.length];

        }

        return new Message(from, command, params);
    }

    public override string toString()
    {
        return "(from: "~from~", command: "~command~", message: `"~params~"`)";
    }

    /** 
     * Returns the sender of the message
     *
     * Returns: The `from` field
     */
    public string getFrom()
    {
        return from;
    }
    
    /** 
     * Returns the command name
     *
     * Returns: The command itself
     */
    public string getCommand()
    {
        return command;
    }

    /** 
     * Returns the optional paremeters (if any)
     *
     * Returns: The parameters
     */
    public string getParams()
    {
        return params;
    }

    /** 
     * Retrieves the trailing text in the paramaters
     * (if any)
     *
     * Returns: the trailing text
     */
    public string getTrailing()
    {
        return ppTrailing;
    }

    /** 
     * Returns the parameters excluding the trailing text
     * which are seperated by spaces but only those
     * which are key-value pairs
     *
     * Returns: the key-value pair parameters
     */
    public string[string] getKVPairs()
    {
        return ppKVPairs;
    }

    /** 
     * Returns the parameters excluding the trailing text
     * which are seperated by spaces
     *
     * Returns: the parameters
     */
    public string[] getPairs()
    {
        return ppPairs;
    }

    private string ppTrailing;
    private string[string] ppKVPairs;
    private string[] ppPairs;


    version(unittest)
    {
        import std.stdio;
    }

    unittest
    {
        string testInput = "A:=1 A=2 :Hello this is text";
        writeln("Input: ", testInput);
        
        bool hasTrailer;
        string[] splitted = splitting(testInput, hasTrailer);
        writeln("Input (split): ", splitted);

        

        assert(cmp(splitted[0], "A:=1") == 0);
        assert(cmp(splitted[1], "A=2") == 0);

        /* Trailer test */
        assert(hasTrailer);
        assert(cmp(splitted[2], "Hello this is text") == 0);
    }

    unittest
    {
        string testInput = ":Hello this is text";
        bool hasTrailer;
        string[] splitted = splitting(testInput, hasTrailer);

        /* Trailer test */
        assert(hasTrailer);
        assert(cmp(splitted[0], "Hello this is text") == 0);
    }

    /** 
     * Imagine: `A:=1 A=2 :Hello` 
     *
     * Params:
     *   input = 
     * Returns: 
     */
    private static string[] splitting(string input, ref bool hasTrailer)
    {
        string[] splits;

        bool trailingMode;
        string buildUp;
        for(ulong idx = 0; idx < input.length; idx++)
        {
            /* Get current character */
            char curCHar = input[idx];


            if(trailingMode)
            {
                buildUp ~= curCHar;
                continue;
            }

            if(buildUp.length == 0)
            {
                if(curCHar == ':')
                {
                    trailingMode = true;
                    continue;
                }
            }
            

            if(curCHar ==  ' ')
            {
                /* Flush */
                splits ~= buildUp;
                buildUp = "";
            }
            else
            {
                buildUp ~= curCHar;
            }
        }

        if(buildUp.length)
        {
            splits ~= buildUp;
        }

        hasTrailer = trailingMode;

        return splits;
    }

    /** 
     * NOTE: This needs more work with trailing support
     * we must make sure we only look for lastInex of `:`
     * where it is first cyaracter after space but NOT within
     * an active parameter
     */
    private void parameterParse()
    {
        /* Only parse if there are params */
        if(params.length)
        {
            /* Trailing text */
            string trailing;

            /* Split the `<params>` */
            bool hasTrailer;
            string[] paramsSplit = splitting(params, hasTrailer);

            // logger.debug_("ParamsSPlit direct:", paramsSplit);
            
            

            /* Extract the trailer as the last item in the array (if it exists) */
            if(hasTrailer)
            {
                trailing = paramsSplit[paramsSplit.length-1];

                /* Remove it from the parameters */
                paramsSplit = paramsSplit[0..$-1];

                // logger.debug_("GOt railer ", trailing);
            }

            ppPairs = paramsSplit;


            /* Generate the key-value pairs */
            foreach(string pair; paramsSplit)
            {
                /* Only do this if we have an `=` in the current pair */
                if(indexOf(pair, "=") > -1)
                {
                    string key = split(pair, "=")[0];
                    string value = split(pair, "=")[1];
                    ppKVPairs[key] = value;
                }
            }

            /* Save the trailing */
            ppTrailing = trailing;

            // logger.debug_("ppTrailing: ", ppTrailing);
        }
    }

    /** 
     * Returns whether or not this message was
     * a numeric response
     *
     * Returns: `true` if numeric response
     * `false` otherwise
     */
    public bool isResponseMessage()
    {
        return isNumericResponse;
    }

    /** 
     * Returns whether or not this message is
     * an error kind-of numeric response
     *
     * Returns: `true` if numeric response
     * is an error, `false` otherwise
     */
    public bool isResponseError()
    {
        return isError;
    }

    /** 
     * Returns the type of reply (if this message
     * was a numeric response)
     *
     * Returns: the ReplyType
     */
    public ReplyType getReplyType()
    {
        return replyType;
    }
}

version(unittest)
{
    // Contains illegal characters
    string badString1 = "doos"~"bruh"~"lek"~cast(string)[10]~"ker";
    string badString2 = "doos"~"bruh"~"lek"~cast(string)[13]~"ker";
}

/**
 * Tests the detection of illegal characters in messages
 */
unittest
{
    assert(Message.hasIllegalCharacters(badString1) == true);
    assert(Message.hasIllegalCharacters(badString2) == true);
}

/**
 * Tests if a message containing bad characters,
 * once stripped, is then valid.
 *
 * Essentially, tests the stripper.
 */
unittest
{
    assert(Message.hasIllegalCharacters(Message.stripIllegalCharacters(badString1)) == false);
    assert(Message.hasIllegalCharacters(Message.stripIllegalCharacters(badString2)) == false);
}

/**
 * Tests the ability, at the `Message`-level, to detect
 * illegal characters and automatically strip them when
 * in `ChecksMode.EASY`
 */
unittest
{
    Message message = new Message(badString1, "fine", "fine");

    try
    {
        string encoded = message.encode(ChecksMode.EASY);
        assert(Message.hasIllegalCharacters(encoded) == false);
    }
    catch(BirchwoodException e)
    {
        assert(false);
    }
}

/**
 * Tests the ability, at the `Message`-level, to detect
 * illegal characters and throw an exception when in
 * `ChecksMode.HARDCORE`
 */
unittest
{
    Message message = new Message(badString1, "fine", "fine");

    try
    {
        message.encode(ChecksMode.HARDCORE);
        assert(false);
    }
    catch(BirchwoodException e)
    {
        assert(e.getType() == ErrorType.ILLEGAL_CHARACTERS);
    }
}

1	/**
2	* Message definition and tooling
3	*/
4	module birchwood.protocol.messages;
5
6	import dlog;
7
8	import std.string;
9	import std.conv : to, ConvException;
10	import birchwood.protocol.constants : ReplyType;
11
12	import birchwood.client.exceptions;
13	import birchwood.config.conninfo : ChecksMode;
14	import birchwood.logging;
15
16	/* TODO: We could move these all to `package.d` */
17
18	/**
19	* Encodes the provided message into a CRLF
20	* terminated byte array
21	*
22	* Params:
23	* messageIn = the message to encode
24	* Returns: the encoded message
25	*/
26	public ubyte[] encodeMessage(string messageIn)
27	{
28	ubyte[] messageOut = cast(ubyte[])messageIn;	36✔
29	messageOut~=[cast(ubyte)13, cast(ubyte)10];	36✔
30	return messageOut;	36✔
31	}
32
33	public static string decodeMessage(ubyte[] messageIn)
34	{
35	/* TODO: We could do a chekc to ESNURE it is well encoded */
36
37	return cast(string)messageIn[0..messageIn.length-2];	161✔
38	// return null;
39	}
40
41	/**
42	* Checks if the provided message is valid (i.e.)
43	* does not contain any CR or LF characters in it
44	*
45	* Params:
46	* message = the message to test
47	* Returns: <code>true</code> if the message is valid,
48	* <code>false</code> false otherwise
49	*/
50	//TODO: Should we add an emptiness check here
51	public static bool isValidText(string message)
52	{
53	foreach(char character; message)	×
54	{
55	if(character == 13 \|\| character == 10)	×
56	{
57	return false;	×
58	}
59	}
60
61	return true;	×
62	}
63
64	/**
65	* Message types
66	*/
67	public final class Message
68	{
69	/* Message contents */
70	private string from;
71	private string command;
72	private string params;
73
74	/* The numeric reply (as per Section 6 of RFC 1459) */
75	private bool isNumericResponse = false;
76	private ReplyType replyType = ReplyType.BIRCHWOOD_UNKNOWN_RESP_CODE;
77	private bool isError = false;
78
79	/**
80	* Constructs a new Message
81	*
82	* Params:
83	* from = the from parameter
84	* command = the command
85	* params = any optional parameters to the command
86	*/
87	this(string from, string command, string params = "")	199✔
88	{
89	this.from = from;	199✔
90	this.command = command;	199✔
91	this.params = params;	199✔
92
93	/* Check if this is a command reply */
94	if(isNumeric(command))	199✔
95	{
96	isNumericResponse = true;	133✔
97
98	//FIXME: SOmething is tripping it u, elts' see
99	try
100	{
101	/* Grab the code */
102	replyType = to!(ReplyType)(to!(ulong)(command));	133✔
103	// TODO: Add validity check on range of values here, if bad throw exception
104	// TODO: Add check for "6.3 Reserved numerics" or handling of SOME sorts atleast
105
106	/* Error codes are in range of [401, 502] */
107	if(replyType >= 401 && replyType <= 502)	131✔
108	{
109	// TODO: Call error handler
110	isError = true;	×
111	}
112	/* Command replies are in range of [259, 395] */
113	else if(replyType >= 259 && replyType <= 395)	238✔
114	{
115	// TODO: Call command-reply handler
116	isError = false;	107✔
117	}
118	}
119	catch(ConvException e)
120	{
121	DEBUG("<<< Unsupported response code (Error below) >>>");	2✔
122	DEBUG(e);	2✔
123	}
124	}
125
126	/* Parse the parameters into key-value pairs (if any) and trailing text (if any) */
127	parameterParse();	199✔
128	}
129
130	/**
131	* Encodes this `Message` into a CRLF delimited
132	* byte array
133	*
134	* If `ChecksMode` is set to `EASY` (default) then
135	* any invalid characters will be stripped prior
136	* to encoding
137	*
138	* Params:
139	* mode = the `ChecksMode` to use
140	*
141	* Throws:
142	* `BirchwoodException` if `ChecksMode` is set to
143	* `HARDCORE` and invalid characters are present
144	* Returns: the encoded format
145	*/
146	public string encode(ChecksMode mode)
147	{
148	string fullLine;	38✔
149
150	/**
151	* Copy over the values (they might be updated and we
152	* want to leave the originals intact)
153	*/
154	string fFrom = from, fCommand = command, fParams = params;	114✔
155
156	/**
157	* If in `HARDCORE` mode then and illegal characters
158	* are present, throw an exception
159	*/
160	if(mode == ChecksMode.HARDCORE && (	38✔
161	hic(fFrom) \|\|	1✔
162	hic(fCommand) \|\|	×
163	hic(fParams)	×
164	))
165	{
166	throw new BirchwoodException(ErrorType.ILLEGAL_CHARACTERS, "Invalid characters present");	1✔
167	}
168	/**
169	* If in `EASY` mode and illegal characters have
170	* been found, then fix them up
171	*/
172	else
173	{
174	// Strip illegal characters from all
175	fFrom = sic(fFrom);	37✔
176	fCommand = sic(fCommand);	37✔
177	fParams = sic(fParams);	37✔
178	}
179
180	/* Combine */
181	fullLine = fFrom~" "~fCommand~" "~fParams;	37✔
182
183
184
185	return fullLine;	37✔
186	}
187
188	// TODO: comemnt
189	private alias sic = stripIllegalCharacters;
190	// TODO: comemnt
191	private alias hic = hasIllegalCharacters;
192
193	/**
194	* Checks whether the provided input string contains
195	* any invalid characters
196	*
197	* Params:
198	* input = the string to check
199	* Returns: `true` if so, `false` otherwise
200	*/
201	// TODO: Add unittest
202	public static bool hasIllegalCharacters(string input)
203	{
204	foreach(char character; input)	3,321✔
205	{
206	if(character == '\n' \|\| character == '\r')	2,082✔
207	{
208	return true;	3✔
209	}
210	}
211
212	return false;	64✔
213	}
214
215	/**
216	* Provided an input string this will strip any illegal
217	* characters present within it
218	*
219	* Params:
220	* input = the string to filter
221	* Returns: the filtered string
222	*/
223	// TODO: Add unittest
224	public static string stripIllegalCharacters(string input)
225	{
226	string stripped;	113✔
227	foreach(char character; input)	4,314✔
228	{
229	if(character == '\n' \|\| character == '\r')	2,648✔
230	{
231	continue;	3✔
232	}
233
234	stripped ~= character;	1,322✔
235	}
236
237	return stripped;	113✔
238	}
239
240	public static Message parseReceivedMessage(string message)
241	{
242	/* TODO: testing */
243
244	/* From */
245	string from;	161✔
246
247	/* Command */
248	string command;	161✔
249
250	/* Params */
251	string params;	161✔
252
253
254
255	/* Check if there is a PREFIX (according to RFC 1459) */
256	if(message[0] == ':')	161✔
257	{
258	/* prefix ends after first space (we fetch servername, host/user) */
259	//TODO: make sure not -1
260	long firstSpace = indexOf(message, ' ');	157✔
261
262	/* TODO: double check the condition */
263	if(firstSpace > 0)	157✔
264	{
265	from = message[1..firstSpace];	157✔
266
267	// DEBUG("from: "~from);
268
269	/* TODO: Find next space (what follows `from` is `' ' { ' ' }`) */
270	ulong i = firstSpace;	157✔
271	for(; i < message.length; i++)	471✔
272	{
273	if(message[i] != ' ')	314✔
274	{
275	break;	157✔
276	}
277	}
278
279	// writeln("Yo");
280
281	string rem = message[i..message.length];	157✔
282	// writeln("Rem: "~rem);
283	long idx = indexOf(rem, " "); //TOOD: -1 check	157✔
284
285	/* Extract the command */
286	command = rem[0..idx];	157✔
287	// DEBUG("command: "~command);
288
289	/* Params are everything till the end */
290	i = idx;	157✔
291	for(; i < rem.length; i++)	471✔
292	{
293	if(rem[i] != ' ')	314✔
294	{
295	break;	157✔
296	}
297	}
298	params = rem[i..rem.length];	157✔
299	// DEBUG("params: "~params);
300	}
301	else
302	{
303	//TODO: handle
NEW 304	DEBUG("Malformed message start after :");	×
305	assert(false);
306	}
307
308
309	}
310	/* In this case it is only `<command> <params>` */
311	else
312	{
313
314	long firstSpace = indexOf(message, " "); //TODO: Not find check	4✔
315
316	command = message[0..firstSpace];	4✔
317
318	ulong pos = firstSpace;	4✔
319	for(; pos < message.length; pos++)	12✔
320	{
321	if(message[pos] != ' ')	8✔
322	{
323	break;	4✔
324	}
325	}
326
327	params = message[pos..message.length];	4✔
328
329	}
330
331	return new Message(from, command, params);	161✔
332	}
333
334	public override string toString()
335	{
336	return "(from: "~from~", command: "~command~", message: `"~params~"`)";	135✔
337	}
338
339	/**
340	* Returns the sender of the message
341	*
342	* Returns: The `from` field
343	*/
344	public string getFrom()
345	{
346	return from;	156✔
347	}
348
349	/**
350	* Returns the command name
351	*
352	* Returns: The command itself
353	*/
354	public string getCommand()
355	{
356	return command;	343✔
357	}
358
359	/**
360	* Returns the optional paremeters (if any)
361	*
362	* Returns: The parameters
363	*/
364	public string getParams()
365	{
366	return params;	184✔
367	}
368
369	/**
370	* Retrieves the trailing text in the paramaters
371	* (if any)
372	*
373	* Returns: the trailing text
374	*/
375	public string getTrailing()
376	{
377	return ppTrailing;	3✔
378	}
379
380	/**
381	* Returns the parameters excluding the trailing text
382	* which are seperated by spaces but only those
383	* which are key-value pairs
384	*
385	* Returns: the key-value pair parameters
386	*/
387	public string[string] getKVPairs()
388	{
389	return ppKVPairs;	19✔
390	}
391
392	/**
393	* Returns the parameters excluding the trailing text
394	* which are seperated by spaces
395	*
396	* Returns: the parameters
397	*/
398	public string[] getPairs()
399	{
400	return ppPairs;	×
401	}
402
403	private string ppTrailing;
404	private string[string] ppKVPairs;
405	private string[] ppPairs;
406
407
408	version(unittest)
409	{
410	import std.stdio;
411	}
412
413	unittest
414	{
415	string testInput = "A:=1 A=2 :Hello this is text";	1✔
416	writeln("Input: ", testInput);	1✔
417
418	bool hasTrailer;	1✔
419	string[] splitted = splitting(testInput, hasTrailer);	1✔
420	writeln("Input (split): ", splitted);	1✔
421
422
423
424	assert(cmp(splitted[0], "A:=1") == 0);	1✔
425	assert(cmp(splitted[1], "A=2") == 0);	1✔
426
427	/* Trailer test */
428	assert(hasTrailer);	1✔
429	assert(cmp(splitted[2], "Hello this is text") == 0);	1✔
430	}
431
432	unittest
433	{
434	string testInput = ":Hello this is text";	1✔
435	bool hasTrailer;	1✔
436	string[] splitted = splitting(testInput, hasTrailer);	1✔
437
438	/* Trailer test */
439	assert(hasTrailer);	1✔
440	assert(cmp(splitted[0], "Hello this is text") == 0);	1✔
441	}
442
443	/**
444	* Imagine: `A:=1 A=2 :Hello`
445	*
446	* Params:
447	* input =
448	* Returns:
449	*/
450	private static string[] splitting(string input, ref bool hasTrailer)
451	{
452	string[] splits;	200✔
453
454	bool trailingMode;	200✔
455	string buildUp;	200✔
456	for(ulong idx = 0; idx < input.length; idx++)	20,768✔
457	{
458	/* Get current character */
459	char curCHar = input[idx];	10,184✔
460
461
462	if(trailingMode)	10,184✔
463	{
464	buildUp ~= curCHar;	5,496✔
465	continue;	5,496✔
466	}
467
468	if(buildUp.length == 0)	4,688✔
469	{
470	if(curCHar == ':')	561✔
471	{
472	trailingMode = true;	155✔
473	continue;	155✔
474	}
475	}
476
477
478	if(curCHar == ' ')	4,533✔
479	{
480	/* Flush */
481	splits ~= buildUp;	365✔
482	buildUp = "";	365✔
483	}
484	else
485	{
486	buildUp ~= curCHar;	4,168✔
487	}
488	}
489
490	if(buildUp.length)	200✔
491	{
492	splits ~= buildUp;	196✔
493	}
494
495	hasTrailer = trailingMode;	200✔
496
497	return splits;	200✔
498	}
499
500	/**
501	* NOTE: This needs more work with trailing support
502	* we must make sure we only look for lastInex of `:`
503	* where it is first cyaracter after space but NOT within
504	* an active parameter
505	*/
506	private void parameterParse()
507	{
508	/* Only parse if there are params */
509	if(params.length)	199✔
510	{
511	/* Trailing text */
512	string trailing;	198✔
513
514	/* Split the `<params>` */
515	bool hasTrailer;	198✔
516	string[] paramsSplit = splitting(params, hasTrailer);	198✔
517
518	// logger.debug_("ParamsSPlit direct:", paramsSplit);
519
520
521
522	/* Extract the trailer as the last item in the array (if it exists) */
523	if(hasTrailer)	198✔
524	{
525	trailing = paramsSplit[paramsSplit.length-1];	153✔
526
527	/* Remove it from the parameters */
528	paramsSplit = paramsSplit[0..$-1];	153✔
529
530	// logger.debug_("GOt railer ", trailing);
531	}
532
533	ppPairs = paramsSplit;	198✔
534
535
536	/* Generate the key-value pairs */
537	foreach(string pair; paramsSplit)	1,806✔
538	{
539	/* Only do this if we have an `=` in the current pair */
540	if(indexOf(pair, "=") > -1)	404✔
541	{
542	string key = split(pair, "=")[0];	68✔
543	string value = split(pair, "=")[1];	68✔
544	ppKVPairs[key] = value;	68✔
545	}
546	}
547
548	/* Save the trailing */
549	ppTrailing = trailing;	198✔
550
551	// logger.debug_("ppTrailing: ", ppTrailing);
552	}
553	}
554
555	/**
556	* Returns whether or not this message was
557	* a numeric response
558	*
559	* Returns: `true` if numeric response
560	* `false` otherwise
561	*/
562	public bool isResponseMessage()
563	{
564	return isNumericResponse;	156✔
565	}
566
567	/**
568	* Returns whether or not this message is
569	* an error kind-of numeric response
570	*
571	* Returns: `true` if numeric response
572	* is an error, `false` otherwise
573	*/
574	public bool isResponseError()
575	{
576	return isError;	×
577	}
578
579	/**
580	* Returns the type of reply (if this message
581	* was a numeric response)
582	*
583	* Returns: the ReplyType
584	*/
585	public ReplyType getReplyType()
586	{
587	return replyType;	266✔
588	}
589	}
590
591	version(unittest)
592	{
593	// Contains illegal characters
594	string badString1 = "doos"~"bruh"~"lek"~cast(string)[10]~"ker";
595	string badString2 = "doos"~"bruh"~"lek"~cast(string)[13]~"ker";
596	}
597
598	/**
599	* Tests the detection of illegal characters in messages
600	*/
601	unittest
602	{
603	assert(Message.hasIllegalCharacters(badString1) == true);	1✔
604	assert(Message.hasIllegalCharacters(badString2) == true);	1✔
605	}
606
607	/**
608	* Tests if a message containing bad characters,
609	* once stripped, is then valid.
610	*
611	* Essentially, tests the stripper.
612	*/
613	unittest
614	{
615	assert(Message.hasIllegalCharacters(Message.stripIllegalCharacters(badString1)) == false);	1✔
616	assert(Message.hasIllegalCharacters(Message.stripIllegalCharacters(badString2)) == false);	1✔
617	}
618
619	/**
620	* Tests the ability, at the `Message`-level, to detect
621	* illegal characters and automatically strip them when
622	* in `ChecksMode.EASY`
623	*/
624	unittest
625	{
626	Message message = new Message(badString1, "fine", "fine");	1✔
627
628	try
629	{
630	string encoded = message.encode(ChecksMode.EASY);	1✔
631	assert(Message.hasIllegalCharacters(encoded) == false);	1✔
632	}
633	catch(BirchwoodException e)
634	{
635	assert(false);
636	}
637	}
638
639	/**
640	* Tests the ability, at the `Message`-level, to detect
641	* illegal characters and throw an exception when in
642	* `ChecksMode.HARDCORE`
643	*/
644	unittest
645	{
646	Message message = new Message(badString1, "fine", "fine");	1✔
647
648	try
649	{
650	message.encode(ChecksMode.HARDCORE);	1✔
651	assert(false);
652	}
653	catch(BirchwoodException e)
654	{
655	assert(e.getType() == ErrorType.ILLEGAL_CHARACTERS);	1✔
656	}
657	}

deavmi / birchwood / #7

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous