trackler 2.2.1.43 → 2.2.1.44

data/tracks/cfml/exercises/markdown/Markdown.cfc

@@ -0,0 +1,121 @@
+/**
+* Your implmentation of the Markdown exercise
+*/
+component {
+	
+	/**
+	* @returns
+	*/
+	function parse(required string input) {
+		
+		var lines = listToArray( arguments.input, chr( 10 ) );
+		var output = [];
+
+		var isInList = false;
+
+		for (var line in lines) {
+			var matches = reMatchNoCase( "^[##]+(.*)", line);
+			if ( matches.len() ) {
+				var hLevel = reMatchNoCase( "[##]+", matches[1])[1];
+				line = "<h#hLevel.len()#>" & trim( replace( matches[1], hLevel, "" ) ) & "</h#hLevel.len()#>";
+			}
+
+			matches = reMatchNoCase( "\*(.*)", line);
+			if ( matches.len() ) {
+				if ( !isInList ) {
+					isInList = true;
+					var isBold = false;
+					var isItalic = false;
+
+					var matches2 = reFindNoCase( "(.*)__(.*)__(.*)", matches[1], 0, true  );
+					if ( matches2.len[1] ) {
+						var match1 = mid(line, matches2.pos[2], matches2.len[2]);
+						var match2 = mid(line, matches2.pos[3], matches2.len[3]);
+						var match3 = mid(line, matches2.pos[4], matches2.len[4]);
+						matches[1] = match1 & "<strong>" & match2 & "</strong>" & match3;
+						isBold = true;
+					}
+
+					var matches3 = reFindNoCase( "(.*)_(.*)_(.*)", matches[1], 0, true  );
+					if ( matches3.len[1] ) {
+						var match1 = mid(line, matches3.pos[2], matches3.len[2]);
+						var match2 = mid(line, matches3.pos[3], matches3.len[3]);
+						var match3 = mid(line, matches3.pos[4], matches3.len[4]);
+						matches[1] = match1 & "<em>" & match2 & "</em>" & match3;
+						isItalic = true;
+					}
+
+					if ( isItalic || isBold ) {
+						line = "<ul><li>" & trim( replace( matches[1], "*", "", "all" ) ) & "</li>";
+					} 
+					else {
+						line = "<ul><li><p>" & trim( replace( matches[1], "*", "", "all" ) ) & "</p></li>";
+					}
+
+				} 
+				else {
+					var isBold = false;
+					var isItalic = false;
+
+					var matches2 = reFindNoCase( "(.*)__(.*)__(.*)", matches[1], 0, true );
+					if ( matches2.len[1] ) {
+						var match1 = mid(line, matches2.pos[2], matches2.len[2]);
+						var match2 = mid(line, matches2.pos[3], matches2.len[3]);
+						var match3 = mid(line, matches2.pos[4], matches2.len[4]);
+						matches[1] = match1 & "<strong>" & match2 & "</strong>" & match3;
+						isBold = true;
+					}
+
+					var matches3 = reFindNoCase( "(.*)_(.*)_(.*)", matches[1], 0, true );
+					if ( matches3.len[1] ) {
+						var match1 = mid(line, matches3.pos[2], matches3.len[2]);
+						var match2 = mid(line, matches3.pos[3], matches3.len[3]);
+						var match3 = mid(line, matches3.pos[4], matches3.len[4]);
+						matches[1] = match1 & "<em>" & match2 & "</em>" & match3;
+						isItalic = true;
+					}
+
+					if ( isItalic || isBold ) {
+						line = "<li>" & trim( replace( matches[1], "*", "", "all" ) ) & "</li>";
+					} 
+					else {
+						line = "<li><p>" & trim( replace( matches[1], "*", "", "all" ) ) & "</p></li>";
+					}
+				}
+			} 
+			else {
+				if ( isInList ) {
+					line = "</ul>" & line;
+					isInList = false;
+				}
+			}
+
+			if ( !reMatchNoCase( "<h|<ul|<p|<li", line ).len() ) {
+				line = "<p>#line#</p>";
+			}
+
+			var matches = reFindNoCase( "(.*)__(.*)__(.*)", line, 0, true  );
+			if ( matches.len[1] ) {
+				var match1 = mid(line, matches.pos[2], matches.len[2]);
+				var match2 = mid(line, matches.pos[3], matches.len[3]);
+				var match3 = mid(line, matches.pos[4], matches.len[4]);
+				line = match1 & "<strong>" & match2 & "</strong>" & match3;
+			}
+
+			var matches = reFindNoCase( "(.*)_(.*)_(.*)", line, 0, true  );
+			if ( matches.len[1] ) {
+				var match1 = mid(line, matches.pos[2], matches.len[2]);
+				var match2 = mid(line, matches.pos[3], matches.len[3]);
+				var match3 = mid(line, matches.pos[4], matches.len[4]);
+				line = match1 & "<em>" & match2 & "</em>" & match3;
+			}
+			output.append( line );
+		}
+		var html = arrayToList( output, "" );
+		if ( isInList ) {
+			html &= "</ul>";
+		}
+
+		return html;
+	}
+}

data/tracks/cfml/exercises/markdown/MarkdownTest.cfc

@@ -0,0 +1,51 @@
+component extends="testbox.system.BaseSpec" {
+
+	function beforeAll(){
+	  SUT = createObject( 'Markdown' );
+	}
+
+	function run(){
+	
+		describe( "My Markdown class", function(){			
+
+			it( 'parses normal text as a paragraph', function(){
+				expect( SUT.parse( input='This will be a paragraph' ) ).toBe( '<p>This will be a paragraph</p>' );
+			});
+
+			it( 'parsing italics', function(){
+				expect( SUT.parse( input='_This will be italic_' ) ).toBe( '<p><em>This will be italic</em></p>' );
+			});
+
+			it( 'parsing bold text', function(){
+				expect( SUT.parse( input='__This will be bold__' ) ).toBe( '<p><strong>This will be bold</strong></p>' );
+			});
+
+			it( 'mixed normal, italics and bold text', function(){
+				expect( SUT.parse( input='This will _be_ __mixed__' ) ).toBe( '<p>This will <em>be</em> <strong>mixed</strong></p>' );
+			});
+
+			it( 'with h1 header level', function(){
+				expect( SUT.parse( input='## This will be an h1' ) ).toBe( '<h1>This will be an h1</h1>' );
+			});
+
+			it( 'with h2 header level', function(){
+				expect( SUT.parse( input='#### This will be an h2' ) ).toBe( '<h2>This will be an h2</h2>' );
+			});
+
+			it( 'with h6 header level', function(){
+				expect( SUT.parse( input='############ This will be an h6' ) ).toBe( '<h6>This will be an h6</h6>' );
+			});
+
+			it( 'unordered lists', function(){
+				expect( SUT.parse( input='* Item 1#chr( 10 )#* Item 2' ) ).toBe( '<ul><li><p>Item 1</p></li><li><p>Item 2</p></li></ul>' );
+			});
+
+			it( 'With a little bit of everything', function(){
+				expect( SUT.parse( input='## Header!#chr( 10 )#* __Bold Item__#chr( 10 )#* _Italic Item_' ) ).toBe( '<h1>Header!</h1><ul><li><strong>Bold Item</strong></li><li><em>Italic Item</em></li></ul>' );
+			});
+
+		});
+		
+	}
+ 
+}

data/tracks/cfml/exercises/markdown/Solution.cfc

@@ -0,0 +1,204 @@
+/**
+* Here is an example solution for the Markdown exercise
+*/
+component {
+
+	/**
+	* Parse markdown
+	* 
+	* @input.hint markdown to parse
+	*/
+	public string function parse(required string input) {
+		
+		var lines = listToArray( arguments.input, chr( 10 ) );
+		var output = [];
+		var isInList = false;
+
+		for (var line in lines) {
+			line = parseHeader(line);
+			line = parseBold( line );
+			line = parseItalic( line );
+
+			line = parseList( line, isInList );
+			/* We are in a list if the line contains a list item and not the unordered list closing tag */
+			isInList = ( reFindNoCase("<li>", line ) && !reFindNoCase("</ul>", line ) );
+
+			line = parseParagraph( line );
+			output.append( line );
+		}
+
+		/* Just in case the last line was a list item  */
+		if ( isInList ) {
+			output.append( "</ul>" );
+		}
+
+		var html = arrayToList( output, "" );
+		return html;
+
+	}	
+
+	/**
+	*
+	* Parse  html headers from markdown text
+	*
+	* @markdown.hint Markdown text to parse
+	*
+	*/
+	private string function parseHeader( required string markdown ) {
+		/* Get the header number */
+		var headerNumber = reMatchNoCase( "^[##]+", arguments.markdown).len() ?  reMatchNoCase( "^[##]+", arguments.markdown)[1].len() : 0;
+		
+		if (headerNumber) {
+			var pattern = "^[##]+ (.*)";
+			var replacement = "<h#headerNumber#>\1</h#headerNumber#>";
+
+			var output = reReplaceNoCase( arguments.markdown, pattern, replacement);
+		}
+		else {
+			var output = arguments.markdown;
+		}	
+		
+		return output;
+	}
+
+	/**
+	*
+	* Parse a list
+	*
+	* @markdown.hint Markdown text to parse
+	* @isInList.hint Flag to indicate if currently parsing a list or not
+	*
+	*/
+	private string function parseList( 
+		required string markdown, 
+		required boolean isInList 
+	) {
+
+		var output = arguments.markdown;
+
+		if ( isListItem( arguments.markdown ) ) {
+			if ( !arguments.isInList ) {
+				output = "<ul>" & parseListItem( output );
+			}
+			else {
+				output = parseListItem( output );
+			}
+		}
+		else if ( arguments.isInList ) {
+			output = "</ul>" & output;
+		}
+		
+		return output;
+	}
+	
+
+	/**
+	*
+	* Parse a paragraph
+	*
+	* @markdown.hint Markdown text to parse
+	*
+	*/
+	private string function parseParagraph( required string markdown ) {
+
+		if ( !reMatchNoCase( "<h|<ul|<p|<li", arguments.markdown ).len() ) {
+			var output = "<p>#arguments.markdown#</p>";
+		}
+		else {
+			var output = arguments.markdown;
+		}
+
+		return output;
+	}
+
+	/**
+	*
+	* Wrap a list with <ul> tags
+	*
+	* @markdown.hint Markdown text to parse
+	*
+	*/
+	private string function wrapList( required string markdown ) {
+		return "<ul>#arguments.markdown#</ul>";
+	}
+
+	/**
+	*
+	* Check if markdown is a list item
+	*
+	* @markdown.hint Markdown text to parse
+	*
+	*/
+	public boolean function isListItem( required string markdown ) {
+		/* Use regex to determine if markdown is list item */
+		return ( reFindNoCase( "\* (.*)",arguments.markdown ) > 0 );
+	}
+	
+
+	/**
+	*
+	* Parse a list item
+	*
+	* @markdown.hint Markdown text to parse
+	*
+	*/
+	private string function parseListItem( required string markdown  ) {
+
+		var pattern = "\* (.*)";
+		var replacement = "<li>\1</li>";
+		var output = reReplaceNoCase( arguments.markdown, pattern, replacement );
+
+		/* Add a p tag to item if no other tag is present */
+		if ( !reFindNoCase("<li><", output ) ) {
+			var pattern = "<li>(.*)</li>";
+			var replacement = "<li><p>\1</p></li>";
+			var output = reReplaceNoCase( output, pattern, replacement );
+		}
+
+		return output;
+	}
+	
+
+	/**
+	*
+	* Parse bold text from markdown
+	*
+	* @markdown.hint Markdown text to parse
+	*
+	*/
+	private string function parseBold( required string markdown ) {
+		return parseWithDelimiter( arguments.markdown, "__", "strong" );
+	}
+
+	/**
+	*
+	* Parse bold text from markdown
+	*
+	* @markdown.hint Markdown text to parse
+	*
+	*/
+	private string function parseItalic( required string markdown ) {
+		
+		return parseWithDelimiter( arguments.markdown, "_", "em" );
+	}
+
+	/**
+	*
+	* Utility function to replace markdown delimiter with their tag equivalent
+	*
+	* @markdown.hint Markdown to parse
+	* @delimiter.hint Markdown syntax to replace with tag i.e __
+	* @tag.hint HTML tag to replace it with. i.e <strong>
+	*
+	*/
+	public any function parseWithDelimiter( 
+		required string markdown, 
+		required string delimiter, 
+		required string tag 
+	) {
+		var pattern = "#arguments.delimiter#(.*)#arguments.delimiter#";
+		var replacement = "<#arguments.tag#>\1</#arguments.tag#>";
+
+		return reReplaceNoCase( arguments.markdown, pattern, replacement);
+	}
+}

data/tracks/cfml/exercises/markdown/SolutionTest.cfc

@@ -0,0 +1,7 @@
+component extends="MarkdownTest" {
+
+	function beforeAll(){
+	  SUT = createObject( 'Solution' );
+	}
+
+}

data/tracks/cfml/exercises/markdown/TestRunner.cfc

@@ -0,0 +1,103 @@
+/**
+* I am a CommandBox task runner which you can use to test your implementation of this exercise against the 
+* provided test suite.  To use me, open the CommandBox CLI and run this:
+* 
+* CommandBox> task run TestRunner
+*
+* To start up a test watcher that will automatically rerun the test suite every time you save a file change, run this:
+*
+* CommandBox> task run TestRunner --watcher
+*
+*/
+component {
+	
+	/**
+	* @solution Runs the tests against the solution
+	* @watcher Start up a file watch that re-runs the tests on file changes. Use Ctrl-C to stop
+	*/
+	function run( boolean solution=false, boolean watcher=false ) {
+		
+		ensureTestBox();
+
+		if( watcher ) {
+		
+			// Tabula rasa
+			command( 'cls' ).run();
+				
+			// Start watcher
+			watch()
+				.paths( '*.cfc' )
+				.inDirectory( getCWD() )
+				.withDelay( 500 )
+				.onChange( function() {
+	
+					// Clear the screen
+					command( 'cls' )
+						.run();
+
+					// This is neccessary so changes to tests get picked up right away.
+					pagePoolClear();	
+					
+					runTests( solution );
+	
+				} )
+				.start();
+					
+		} else {
+			runTests( solution );
+		}			
+
+	}
+
+	/**
+	* Make sure the TestBox framework is installed
+	*/
+	private function ensureTestBox() {
+		var excerciseRoot = getCWD();
+		var testBoxRoot = excerciseRoot & '/testbox';
+		
+		if( !directoryExists( testBoxRoot ) ) {
+			
+			print.boldYellowLine( 'Installing some missing dependencies for you!' ).toConsole();
+			command( 'install' )
+				.inWorkingDirectory( excerciseRoot )
+				.run();
+		}
+		
+		// Bootstrap TestBox framework
+		filesystemUtil.createMapping( '/testbox', testBoxRoot );
+	}
+
+	/**
+	* Invoke TestBox to run the test suite
+	*/
+	private function runTests( boolean solution=false ) {
+		
+		// Create TestBox and run the tests
+		testData = new testbox.system.TestBox()
+			.runRaw( directory = {
+				// Find all CFCs...
+				mapping = filesystemUtil.makePathRelative( getCWD() ),
+				// ... in this directory ...
+				recurse = false,
+				// ... whose name ends in "test"
+				filter = function( path ) {
+					return path.reFind( ( solution ? 'Solution' : '' ) & 'Test.cfc$' );
+				 }
+			} )
+			.getMemento();
+		
+		// Print out the results with ANSI formatting for the CLI
+		getInstance( 'CLIRenderer@testbox-commands' )
+			.render( print, testData, true );
+			
+		print.toConsole();
+		
+		// Set proper exit code
+		if( testData.totalFail || testData.totalError ) {
+			setExitCode( 1 );
+		}
+	}
+
+}
+