trackler 2.2.1.33 → 2.2.1.34

data/tracks/coldfusion/config/maintainers.json

@@ -1,6 +1,13 @@
 {
   "maintainers": [
-
+	{
+	  "github_username": "bdw429s",
+	  "show_on_website": true,
+	  "name": "Brad Wood",
+	  "bio": "ColdBox/CommandBox Developer Advocate. Lucee Member. System Architect. CFML dev. DBA. Dad. Handyman. Ready for a revolution.",
+	  "link_text": "Tech Blog",
+	  "link_url": "http://www.codersrevolution.com/"
+	}
   ],
   "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md"
 }

data/tracks/coldfusion/docs/ABOUT.md

@@ -0,0 +1,8 @@
+ColdFusion (CFML) is a JVM scripting language whose syntax is similar to C or JavaScript.  It JIT compiles to byte code that runs on the JVM but is dynamic and loosely typed, making it fast and easy to develop in.  CF is a multi-paradigmed language, supporting classical OO and functional programming.  
+
+CF also has a built in tag-based templating language that makes it ideal for web apps.  It runs in a J2EE container with many bundled libraries that make it very productive without the need to install many packages. CF has native support zip files, PDF and Excel generation, E-mails, FTP, HTTP, S3 file systems, ESAPI security libraries, JDBC drivers, JSON data types and REST APIs.  
+
+CF can also leverage any Java project by dropping the jars in project and directly instantiating Java objects in your code.  You can learn more about basic syntax and first class data types in this guide: [Modern ColdFusion (CFML) in 100 Minutes](https://www.gitbook.com/book/ortus/modern-coldfusion-cfml-in-100-minutes/details)
+
+
+

data/tracks/coldfusion/docs/EXERCISE_README_INSERT.md

@@ -0,0 +1,15 @@
+* * * *
+
+To run the code in this exercise, you will only need to have [CommandBox CLI installed](https://ortus.gitbooks.io/commandbox-documentation/content/setup/installation.html).  This binary runs CFML code from the command line.
+
+To run the tests, `cd` into the exercise folder and run the following:
+
+```bash 
+box task run TestRunner
+# Or start up a test watcher that will rerun when files change
+box task run TestRunner --watcher
+```
+
+The tests leverage a library called TestBox which supports xUnit and BDD style of testing.  All test suites will be written in the [BDD style](https://testbox.ortusbooks.com/content/primers/bdd/specs.html) which uses closures to define test specs.  You won't need to worry about installing TestBox.  The CLI test runner will take care of that for you.  You just need to be connected to the internet the first time you run it.  You can read more about it here:
+
+[https://testbox.ortusbooks.com/content/](https://testbox.ortusbooks.com/content/)

data/tracks/coldfusion/docs/INSTALLATION.md

@@ -0,0 +1,35 @@
+## Installation
+
+The only thing you will need to run these exercises is [CommandBox CLI](https://ortus.gitbooks.io/commandbox-documentation/content/getting_started_guide.html) and [Java 7+](https://java.com/en/download/) installed.  CommandBox CLI is supported on Mac, Linux, and Windows, and the installation guide can be found here:
+
+[https://ortus.gitbooks.io/commandbox-documentation/content/setup/installation.html](https://ortus.gitbooks.io/commandbox-documentation/content/setup/installation.html)
+
+An example of getting CommandBox CLI setup if you're a Homebrew user on Mac would be:
+
+```bash
+brew install commandbox
+```
+
+Once you have the CLI installed, you can play withe REPL:
+
+```bash
+box repl
+```
+
+You can directly execute .cfm pages:
+
+```bash
+box exec myTest.cfm
+```
+
+And you can even start up a web server in any directory of your hard drive:
+
+```bash
+box server start
+```
+
+CommandBox has an interactive shell you can use that has enhanced tab completion and runs faster.  Enter it by just running the `box` binary with no arguments.
+
+```bash
+box
+```

data/tracks/coldfusion/docs/LEARNING.md

@@ -0,0 +1,37 @@
+## Recommended Learning Resources
+
+Welcome to learning ColdFusion (CFML)!  CFML is a dynamic and loosely typed JVM scripting language.  It has two different file types. `.cfm` files (ColdFusion markup)_ are purely procedural and use the tag-based syntax for templating out HTML.  You would use these for views if building a web site:
+
+**index.cfm**
+
+```xml
+<cfoutput>
+	<html>
+		<h1>Welcome to my site, #FirstName# #LastName#!
+	</html>
+</cfoutput>
+```
+
+The other type of file is the `.cfc` (ColdFusion Component) and it is how you declare a class.  Components are used for business logic, models, and controllers.  These usually use the script syntax, which reads similar to JavaScript.
+
+**Car.cfc**
+
+```js
+component accessors=true {
+	property name='make' type='string';
+	property name='model' type='string';
+	property name='year' type='number';
+
+	function init() {
+		return this;
+	}
+ 
+}
+```
+
+Here are some guides for learning more about CFML
+ 
+* [Modern ColdFusion (CFML) in 100 Minutes](https://www.gitbook.com/book/ortus/modern-coldfusion-cfml-in-100-minutes/details)
+* [CF SCript Cheatsheet](http://www.petefreitag.com/cheatsheets/coldfusion/cfscript/)
+* [Learn CF In A Week](http://www.learncfinaweek.com/)
+* [CommandBox CLI Getting Started Guide](https://ortus.gitbooks.io/commandbox-documentation/content/getting_started_guide.html)

data/tracks/coldfusion/docs/RESOURCES.md

@@ -0,0 +1,29 @@
+## Recommended Resources
+
+### Learning
+* [Modern ColdFusion (CFML) in 100 Minutes](https://www.gitbook.com/book/ortus/modern-coldfusion-cfml-in-100-minutes/details)
+* [CF SCript Cheatsheet](http://www.petefreitag.com/cheatsheets/coldfusion/cfscript/)
+* [Learn CF In A Week](http://www.learncfinaweek.com/)
+
+### CF Engines
+
+* [Lucee Server](http://lucee.org/) - A free open source CFML engine
+* [Adobe ColdFusion](http://www.adobe.com/products/coldfusion-family.html) - A commercially supported Enterprise CF engine  
+
+### Online Communities
+
+* [CFML Slack](https://cfml-slack.herokuapp.com/)
+* [Stack Overflow](https://stackoverflow.com/questions/tagged/coldfusion)
+* [Community Resource Page](http://carehart.org/cf411/)
+* [Lucee Server Discourse Forum](https://dev.lucee.org/)
+* [Twitter](https://twitter.com/search?q=coldfusion&src=typd)
+
+### Tools
+
+* [CF Docs](https://cfdocs.org/)
+* [Try CF](https://www.trycf.com/)
+* [ColdBox MVC](https://coldbox.ortusbooks.com/content/full/getting_started_guide/)
+* [CFWheels  MVC](https://cfwheels.org/)
+* [FW/1 MVC](http://framework-one.github.io/documentation/)
+* [CommandBox CLI](https://ortus.gitbooks.io/commandbox-documentation/content/getting_started_guide.html)
+* [ForgeBox Package repo](https://www.forgebox.io/)

data/tracks/coldfusion/docs/SNIPPET.txt

@@ -0,0 +1,8 @@
+component {
+
+  // helloWorld greets the world.
+  function helloWorld() {
+    return 'Hello, World!';
+  }
+
+}

data/tracks/coldfusion/docs/TESTS.md

@@ -0,0 +1,19 @@
+## Running Tests
+
+To run the test for a given exercise, `cd` into the folder and run the following:
+
+```bash 
+box task run TestRunner
+# Or start up a test watcher that will rerun when files change
+box task run TestRunner --watcher
+```
+
+If you want to run the test suite against the solution: 
+
+```bash 
+box task run TestRunner --solution
+```
+
+The tests leverage a library called TestBox which supports xUnit and BDD style of testing.  All test suites will be written in the [BDD style](https://testbox.ortusbooks.com/content/primers/bdd/specs.html) which uses closures to define test specs.  You won't need to worry about installing TestBox.  The CLI test runner will take care of that for you.  You just need to be connected to the internet the first time you run it.  You can read more about it here:
+
+[https://testbox.ortusbooks.com/content/](https://testbox.ortusbooks.com/content/)

data/tracks/coldfusion/exercises/acronym/Acronym.cfc

@@ -0,0 +1,13 @@
+/**
+* Your implmentation of the Acronym exercise
+*/
+component {
+	
+	/**
+	* @returns 
+	*/
+	 function abbreviate( phrase ) {
+		// Implement me here
+	}
+	
+}

data/tracks/coldfusion/exercises/acronym/AcronymTest.cfc

@@ -0,0 +1,43 @@
+component extends="testbox.system.BaseSpec" {
+
+	function beforeAll(){
+	  SUT = createObject( 'Acronym' );
+	}
+
+	function run(){
+	
+		describe( "My Acronym class", function(){			
+
+			describe( 'Abbreviate a phrase', function(){
+
+				it( 'basic', function(){
+					expect( SUT.abbreviate( phrase='Portable Network Graphics' ) ).toBe( 'PNG' );
+				});
+
+				it( 'lowercase words', function(){
+					expect( SUT.abbreviate( phrase='Ruby on Rails' ) ).toBe( 'ROR' );
+				});
+
+				it( 'punctuation', function(){
+					expect( SUT.abbreviate( phrase='First In,  First Out' ) ).toBe( 'FIFO' );
+				});
+
+				it( 'all caps words', function(){
+					expect( SUT.abbreviate( phrase='PHP: Hypertext Preprocessor' ) ).toBe( 'PHP' );
+				});
+
+				it( 'non-acronym all caps word', function(){
+					expect( SUT.abbreviate( phrase='GNU Image Manipulation Program' ) ).toBe( 'GIMP' );
+				});
+
+				it( 'hyphenated', function(){
+					expect( SUT.abbreviate( phrase='Complementary metal-oxide semiconductor' ) ).toBe( 'CMOS' );
+				});
+
+			});
+
+		});
+		
+	}
+ 
+}

data/tracks/coldfusion/exercises/acronym/Solution.cfc

@@ -0,0 +1,22 @@
+/**
+* Here is an example solution for the Acronym exercise
+*/
+component {
+
+	function abbreviate( phrase ) {
+		
+		return phrase
+			// Break up string on spaces or hyphens
+			.listToArray( ' -' )
+			// Strip first char of each word
+			.map( function( word ) {
+				return word.left( 1 );
+			} )
+			// Concat back to string
+			.toList( '' )
+			// Upper case for good measure
+			.uCase();
+			
+	}
+			
+}

data/tracks/coldfusion/exercises/acronym/SolutionTest.cfc

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

data/tracks/coldfusion/exercises/acronym/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 );
+		}
+	}
+
+}
+

data/tracks/coldfusion/exercises/acronym/box.json

@@ -0,0 +1,8 @@
+{
+    "dependencies":{
+        "testbox":"^2.5.0+107"
+    },
+    "installPaths":{
+        "testbox":"testbox"
+    }
+}

data/tracks/coldfusion/exercises/acronym/index.cfm

@@ -0,0 +1,37 @@
+<!--- 
+
+This file will only be used if you want to start up a web server in this directory.  You can do so by running:
+
+$> box
+CommandBox> install
+CommandBox> server start
+
+However, this is not necessary unless you really just want to use the HTML reporters on TestBox.  
+Ideally, you'll skip the need for this file entirely and just run the tests directly frm the CLI like this:
+
+CommandBox> task run TestRunner
+
+ --->
+<cfsetting showDebugOutput="false">
+<cfparam name="url.reporter" 		default="simple">
+<cfscript>
+	// get a list of all CFCs in this folder whose name looks like "XXXTest.cfc"
+	// And turn it into compnent path relative to the web root
+	url.bundles = directoryList(
+			path=expandPath( '/' ),
+			filter='*Test.cfc' )
+		.map( function( path ) {
+			return path
+					.replaceNoCase( expandPath( '/' ), '' )
+					.left( -4 )
+		} )
+		.toList();
+</cfscript>
+
+<!--- Ensure TestBox --->
+<cfif fileExists( "/testbox/system/runners/HTMLRunner.cfm" )>
+	<!--- Include the TestBox HTML Runner --->
+	<cfinclude template="/testbox/system/runners/HTMLRunner.cfm">
+<cfelse>
+	Oops, you don't have TestBox installed yet! Please run <b>box install</b> from the root of your excercise folder and refresh this page.	
+</cfif>

data/tracks/coldfusion/exercises/atbash-cipher/AtbashCipher.cfc

@@ -0,0 +1,14 @@
+/**
+* Your implmentation of the AtbashCipher exercise
+*/
+component {
+	
+	function encode( phrase ) {
+		// Implement me here
+	}
+	
+	function decode( phrase ) {
+		// Implement me here
+	}
+	
+}