trackler 2.2.1.52 → 2.2.1.53

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ba58003417ff7756c00e61bca5725599d51f36a
-  data.tar.gz: b224d56deaee8862e20e456a5431c77c84761ce7
+  metadata.gz: 95152d34553c950841be6dbe52afef273a56ab43
+  data.tar.gz: 4d2c405d864d1c9fef3295f2cc30b316fdbc30f2
 SHA512:
-  metadata.gz: 228596af71741d35e867a78201c19b7497a186a65c85b4cf1656de33d81d722f0bff10436e7cdf4eb6c9841eb0c6bde13440fb05bcf34257ed59904e2397dd5e
-  data.tar.gz: 2c111f16d5aba64c6f455ef360626fef978c6b3341fa616a54778e112000f2e6eaa5ff78141d643151a74c7742041422d70f30086c92672ec66a38af90203cb7
+  metadata.gz: ebdadfa92b814621a979f0dbdb8060f3d1a952e000a93cea60b4a71cef0435ca67723bfd2ec5f8ad109acd826b3024d7890283cbad44f2fda01e065f8f6b805b
+  data.tar.gz: d8fa0417ab4cc2173f02b5fa5aa90975d5b62cdc8a2c1f8d965fbdfe458b05371273ad47ffb337eb3855d4a331f33a873568a3197513e05480e285c09ef2ee9b

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.52"
+  VERSION = "2.2.1.53"
 end

data/problem-specifications/exercises/leap/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "leap",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "cases": [
     {
       "description": "year not divisible by 4: common year",
@@ -11,7 +11,7 @@
     {
       "description": "year divisible by 4, not divisible by 100: leap year",
       "property": "leapYear",
-      "input": 2020,
+      "input": 1996,
       "expected": true
     },
     {

data/tracks/cfml/tasks/FormatConfig.cfc

@@ -1,5 +1,5 @@
 /**
-* This is a simple task runner that formats the JSON config file.  This should only be neccessary if yoiu've edited it by 
+* This is a simple task runner that formats the JSON config file.  This should only be neccessary if you've edited it by 
 * hand and want to get it back into the proper format as far as spacing and indentation goes.  This follows the same format as `configlet fmt`
 */
 component {
@@ -9,17 +9,19 @@ component {
 		var repoRootPath = expandPath( getDirectoryFromPath( getCurrentTemplatePath() ) & '../' );
 		// Read in the current JSON config file
 		var configJSONRaw = fileRead( repoRootPath & '/config.json' );
-		var configJSON = deserializeJSON( configJSONRaw );
 		
-		var newConfigJSONRaw = formatterUtil.formatJSON( json=configJSON, indent='  ' , lineEnding=chr( 10 ), spaceAfterColon=true );
+		// Format JSON file to spec
+		var newConfigJSONRaw = formatterUtil.formatJSON( json=configJSONRaw, indent='  ' , lineEnding=chr( 10 ), spaceAfterColon=true );
 		
+		// Only save if it's different to avoid touching the file needlessly
 		if( newConfigJSONRaw != configJSONRaw ) {
+			
 			// Write it back out with the proper formatting styles applied
 			fileWrite( repoRootPath & '/config.json', newConfigJSONRaw );
 		
 			print.greenLine( 'Config file [#repoRootPath#config.json] formatted!' );
 		} else {
-			print.whiteLine( 'Config file [#repoRootPath#config.json] is already formatted!' );
+			print.whiteLine( 'Config file [#repoRootPath#config.json] is already formatted!  No Chanages needed.' );
 		}
 	}
 	

data/tracks/cfml/tasks/GenerateReadme.cfc

@@ -0,0 +1,197 @@
+/**
+* Generate README.md files for exercises
+*/
+component  {
+
+	/**
+	* Run the task to generate read me files
+	*/
+	function run(
+		slug,
+		boolean all=false,
+		boolean force=false
+	){
+
+		/* Init global variables */
+		repoRootPath = expandPath( getDirectoryFromPath( getCurrentTemplatePath() ) & '../' );
+		problemSpecsPath = expandPath( getDirectoryFromPath( getCurrentTemplatePath() ) & '../../problem-specifications' );
+		trackReadmeInsert= fileRead( repoRootPath & "docs/EXERCISE_README_INSERT.md" );
+		overwriteExistingFiles = arguments.force;	
+
+		if( !directoryExists( problemSpecsPath ) ){
+			error( 'Cannot find [problem-specifications] repo.  It needs to be git cloned to [#problemSpecsPath#]' );
+		}
+		
+		if( all ) {
+			
+			// Get an array of all the excercise names
+			var exercises = directoryList( expandPath( getDirectoryFromPath( getCurrentTemplatePath() ) & '../exercises' ) )
+				.map( function( path ) {
+					return path.listLast( '/\' );
+				} );
+		
+		} else {
+		
+			// Acquire slug
+			if( isNull( arguments.slug ) ) {
+				arguments.slug = ask( 'Exercise slug as defined by Excercism. Ex: "hello-world": ' );
+			}
+			var exercises = [ slug ];
+			
+		}
+
+		exercises.each( function( slug ) {
+			
+			generateReadme( arguments.slug );
+			
+		} ); // End exercises.each()
+	
+	}
+
+	private function generateReadme( required string slug ) {
+
+		var readmeContent = "";
+		var readMeFile = repoRootPath & "/exercises/" & arguments.slug & "/README.md";
+
+		if ( !fileExists(readMeFile) || overwriteExistingFiles) {
+
+			var spec = getSpec( arguments.slug );
+
+			readmeContent = "## #spec.name#" & chr( 10 ) & chr( 10 );
+			readmeContent = readmeContent & spec.description & chr( 10 );
+			readmeContent = readmeContent & getHints( arguments.slug ) & chr( 10 );
+			readmeContent = readmeContent & trackReadmeInsert & chr( 10 );
+			readmeContent = readmeContent & spec.credits & chr( 10 );
+			readmeContent = readmeContent & "#### Submitting Incomplete Solutions#chr( 10 )#It's possible to submit an incomplete solution so you can see how others have completed the exercise.#chr( 10 )#";
+
+			/* Write the file */
+			fileWrite( readMeFile , readmeContent );
+
+			print.greenLine( 'Readme generated!' )
+				.indentedYellowLine( readMeFile )
+				.toConsole();
+		}
+		else {
+			print.redLine("README.md already exists! Use the overwrite=true to overwrite the file.")
+				.indentedYellowLine( readMeFile )
+				.toConsole();
+		}
+
+	}
+
+	/**
+	*
+	* Get the optional .meta/hint.md content
+	*
+	*/
+	private function getHints( required string slug ) {
+
+		var hintsFilePath = repoRootPath & "/exercises/" & arguments.slug & "/.meta/hints.md";
+		var hints = fileExists( hintsFilePath ) ? fileRead( hintsFilePath ) : "";
+
+		return hints;
+	}
+
+	private function getSpec( required string slug ) {
+
+		var spec = getExerciseMetadata( arguments.slug );
+
+		/* Use title from metadata.yml if provided else we must use the slug */
+		if ( len( spec.title )) {
+			spec.name = spec.title;
+		}
+		else {
+			spec.name = titleCaseSlug( arguments.slug );
+		}
+
+		spec.credits = getCredits( spec );
+		spec.description = getDescription( arguments.slug );
+
+		return spec;
+	}
+
+	/**
+	*
+	* Get the exercise description
+	*
+	*/
+	private function getDescription( required string slug ) {
+
+		var descriptionFilePath = problemSpecsPath & "/exercises/" & arguments.slug & "/description.md";
+		 
+		return fileExists( descriptionFilePath ) ? trim( fileRead( descriptionFilePath ) ) : "";
+	}
+
+	/**
+	*
+	* Get the content for exercise credits
+	*
+	*/
+	private function getCredits( required struct spec ) {
+
+		if ( spec.source_url == "" ) {
+			var credits =  spec.source;
+		}
+		else if ( spec.source == "") {
+			var credits =  "[#spec.source_url#](#spec.source_url#)";
+		}
+		else {
+			var credits = "#spec.source# [#spec.source_url#](#spec.source_url#)";
+		}
+
+		if ( len( credits ) ) {
+			credits = "#### Source" & chr( 10 ) & chr( 10 ) & credits & chr( 10 );
+		}
+
+		return  credits;
+	}
+
+	/**
+	*
+	* Convert exercise slug to a title
+	*
+	*/
+	private function titleCaseSlug( required string slug ) {
+		return trim( reReplace( arguments.slug, "(\b|-)([a-zA-Z])", " \u\2", "all" ) );
+	}
+
+	/**
+	*
+	* Get exercise metadata from metadata.yml in the problem-specifications
+	*
+	*/
+	private struct function getExerciseMetadata( required string slug ) {
+
+		var metadataFilePath = problemSpecsPath & "/exercises/" & arguments.slug & "/metadata.yml";
+		var content = fileRead(metadataFilePath);
+		var metadata = {};
+
+		/* Get the title if provided in metadata.yml */
+		metadata.title = parseMetadata( "title", content );
+
+		/* Get the source of the exercise if provided in metadata.yml */
+		metadata.source = parseMetadata( "source", content );
+
+		/* Get the source url if provided in metadata.yml */
+		metadata.source_url = parseMetadata( "source_url", content );
+
+		return metadata;
+	}
+
+	/**
+	*
+	* Parse metadata from metadata.yml content
+	*
+	*/
+	private string function parseMetadata( required string key, required string content ) {
+		var result = "";
+
+		var matches = reFindNoCase( "#arguments.key#: ""(.*?)""", content, 1, true );
+		if ( matches.pos.len() == 2 ) {
+			result = mid( content, matches.pos[2], matches.len[2]);
+		}
+
+		return result;
+	}
+
+}

data/tracks/cfml/tasks/ScaffoldExercise.cfc

@@ -79,6 +79,12 @@ component {
 			.params( 'GenerateTests', 'run', slug )
 			.inWorkingDirectory( repoRootPath & '/tasks' )
 			.run();
+
+		// Generate README.md
+		command( 'task run' )
+			.params( 'GenerateReadme', 'run', slug )
+			.inWorkingDirectory( repoRootPath & '/tasks' )
+			.run();
 		
 	}
 	

data/tracks/csharp/config.json

@@ -64,7 +64,7 @@
         "optional_values",
         "strings"
       ],
-      "unlocked_by": "null",
+      "unlocked_by": null,
       "uuid": "57f02d0e-7b75-473b-892d-26a7d980c4ce"
     },
     {

data/tracks/delphi/exercises/leap/uLeapTests.pas

@@ -36,7 +36,7 @@ end;
 
 procedure YearTest.year_divisible_by_4_not_divisible_by_100_leap_year;
 begin
-  assert.IsTrue(TYear.IsLeap(2020), 'Expected ''true'', 2020 is a leap year.');
+  assert.IsTrue(TYear.IsLeap(1996), 'Expected ''true'', 1996 is a leap year.');
 end;
 
 procedure YearTest.year_divisible_by_100_not_divisible_by_400_common_year;

data/tracks/fsharp/exercises/clock/Clock.fs

@@ -1,6 +1,6 @@
 module Clock
 
-let mkClock hours minutes = failwith "You need to implement this function."
+let create hours minutes = failwith "You need to implement this function."
 
 let add minutes clock = failwith "You need to implement this function."
 

data/tracks/fsharp/exercises/clock/ClockTest.fs

@@ -1,96 +1,274 @@
+// This file was auto-generated based on version 1.0.1 of the canonical data.
+
 module ClockTest
 
-open System
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open Clock
 
 [<Fact>]
-let ``Prints 8 o'clock`` () =
-    let clock = mkClock 8 0
+let ``On the hour`` () =
+    let clock = create 8 0
     display clock |> should equal "08:00"
 
-[<Fact(Skip = "Remove to run test")>]     
-let ``Prints 9 o'clock`` () =
-    let clock = mkClock 9 0
-    display clock |> should equal "09:00"
-
-[<Fact(Skip = "Remove to run test")>]     
-let ``Can print single-digit minutes`` () =
-    let clock = mkClock 11 9
+[<Fact(Skip = "Remove to run test")>]
+let ``Past the hour`` () =
+    let clock = create 11 9
     display clock |> should equal "11:09"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can print double-digit minutes`` () =
-    let clock = mkClock 11 19
-    display clock |> should equal "11:19"
+let ``Midnight is zero hours`` () =
+    let clock = create 24 0
+    display clock |> should equal "00:00"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add minutes`` () =
-    let clock = mkClock 10 0
-    let added = clock |> add 3
-    display added |> should equal "10:03"
+let ``Hour rolls over`` () =
+    let clock = create 25 0
+    display clock |> should equal "01:00"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add over an hour`` () =
-    let clock = mkClock 10 0
-    let added = clock |> add 63
-    display added |> should equal "11:03"
+let ``Hour rolls over continuously`` () =
+    let clock = create 100 0
+    display clock |> should equal "04:00"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can add over more than one day`` () =
-    let clock = mkClock 10 0
-    let added = clock |> add 7224
-    display added |> should equal "10:24"
+let ``Sixty minutes is next hour`` () =
+    let clock = create 1 60
+    display clock |> should equal "02:00"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can subtract minutes`` () =
-    let clock = mkClock 10 3
-    let subtracted = clock |> subtract 3
-    display subtracted |> should equal "10:00"
+let ``Minutes roll over`` () =
+    let clock = create 0 160
+    display clock |> should equal "02:40"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can subtract to previous hour`` () =
-    let clock = mkClock 10 3
-    let subtracted = clock |> subtract 30
-    display subtracted |> should equal "09:33"
+let ``Minutes roll over continuously`` () =
+    let clock = create 0 1723
+    display clock |> should equal "04:43"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Can subtract over an hour`` () =
-    let clock = mkClock 10 3
-    let subtracted = clock |> subtract 70
-    display subtracted |> should equal "08:53"
+let ``Hour and minutes roll over`` () =
+    let clock = create 25 160
+    display clock |> should equal "03:40"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Wraps around midnight`` () =
-    let clock = mkClock 23 59
-    let added = clock |> add 2
-    display added |> should equal "00:01"
+let ``Hour and minutes roll over continuously`` () =
+    let clock = create 201 3001
+    display clock |> should equal "11:01"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Wraps around midnight backwards`` () =
-    let clock = mkClock 0 1
-    let subtracted = clock |> subtract 2
-    display subtracted |> should equal "23:59"
+let ``Hour and minutes roll over to exactly midnight`` () =
+    let clock = create 72 8640
+    display clock |> should equal "00:00"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Midnight is zero hundred hours`` () =
-    let clock = mkClock 24 0
-    display clock |> should equal "00:00"
+let ``Negative hour`` () =
+    let clock = create -1 15
+    display clock |> should equal "23:15"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sixty minutes is next hour`` () =
-    let clock = mkClock 1 60
-    display clock |> should equal "02:00"
+let ``Negative hour rolls over`` () =
+    let clock = create -25 0
+    display clock |> should equal "23:00"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Negative hour rolls over continuously`` () =
+    let clock = create -91 0
+    display clock |> should equal "05:00"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Negative minutes`` () =
+    let clock = create 1 -40
+    display clock |> should equal "00:20"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Negative minutes roll over`` () =
+    let clock = create 1 -160
+    display clock |> should equal "22:20"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Negative minutes roll over continuously`` () =
+    let clock = create 1 -4820
+    display clock |> should equal "16:40"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Negative hour and minutes both roll over`` () =
+    let clock = create -25 -160
+    display clock |> should equal "20:20"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Negative hour and minutes both roll over continuously`` () =
+    let clock = create -121 -5810
+    display clock |> should equal "22:10"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Add minutes`` () =
+    let clock = create 10 0
+    add 3 clock |> display |> should equal "10:03"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Add no minutes`` () =
+    let clock = create 6 41
+    add 0 clock |> display |> should equal "06:41"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Add to next hour`` () =
+    let clock = create 0 45
+    add 40 clock |> display |> should equal "01:25"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Add more than one hour`` () =
+    let clock = create 10 0
+    add 61 clock |> display |> should equal "11:01"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Add more than two hours with carry`` () =
+    let clock = create 0 45
+    add 160 clock |> display |> should equal "03:25"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Add across midnight`` () =
+    let clock = create 23 59
+    add 2 clock |> display |> should equal "00:01"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Add more than one day (1500 min = 25 hrs)`` () =
+    let clock = create 5 32
+    add 1500 clock |> display |> should equal "06:32"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Add more than two days`` () =
+    let clock = create 1 1
+    add 3500 clock |> display |> should equal "11:21"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtract minutes`` () =
+    let clock = create 10 3
+    add -3 clock |> display |> should equal "10:00"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtract to previous hour`` () =
+    let clock = create 10 3
+    add -30 clock |> display |> should equal "09:33"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtract more than an hour`` () =
+    let clock = create 10 3
+    add -70 clock |> display |> should equal "08:53"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtract across midnight`` () =
+    let clock = create 0 3
+    add -4 clock |> display |> should equal "23:59"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtract more than two hours`` () =
+    let clock = create 0 0
+    add -160 clock |> display |> should equal "21:20"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtract more than two hours with borrow`` () =
+    let clock = create 6 15
+    add -160 clock |> display |> should equal "03:35"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtract more than one day (1500 min = 25 hrs)`` () =
+    let clock = create 5 32
+    add -1500 clock |> display |> should equal "04:32"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Subtract more than two days`` () =
+    let clock = create 2 20
+    add -3000 clock |> display |> should equal "00:20"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with same time`` () =
+    let clock1 = create 15 37
+    let clock2 = create 15 37
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks a minute apart`` () =
+    let clock1 = create 15 36
+    let clock2 = create 15 37
+    clock1 = clock2 |> should equal false
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks an hour apart`` () =
+    let clock1 = create 14 37
+    let clock2 = create 15 37
+    clock1 = clock2 |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Clocks with same time are equal`` () =
-    let clock1 = mkClock 14 30
-    let clock2 = mkClock 14 30
-    clock1 |> should equal clock2
+let ``Clocks with hour overflow`` () =
+    let clock1 = create 10 37
+    let clock2 = create 34 37
+    clock1 = clock2 |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Overflown clocks with same time are equal`` () =
-    let clock1 = mkClock 14 30
-    let clock2 = mkClock 38 30
-    clock1 |> should equal clock2
+let ``Clocks with hour overflow by several days`` () =
+    let clock1 = create 3 11
+    let clock2 = create 99 11
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with negative hour`` () =
+    let clock1 = create 22 40
+    let clock2 = create -2 40
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with negative hour that wraps`` () =
+    let clock1 = create 17 3
+    let clock2 = create -31 3
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with negative hour that wraps multiple times`` () =
+    let clock1 = create 13 49
+    let clock2 = create -83 49
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with minute overflow`` () =
+    let clock1 = create 0 1
+    let clock2 = create 0 1441
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with minute overflow by several days`` () =
+    let clock1 = create 2 2
+    let clock2 = create 2 4322
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with negative minute`` () =
+    let clock1 = create 2 40
+    let clock2 = create 3 -20
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with negative minute that wraps`` () =
+    let clock1 = create 4 10
+    let clock2 = create 5 -1490
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with negative minute that wraps multiple times`` () =
+    let clock1 = create 6 15
+    let clock2 = create 6 -4305
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with negative hours and minutes`` () =
+    let clock1 = create 7 32
+    let clock2 = create -12 -268
+    clock1 = clock2 |> should equal true
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Clocks with negative hours and minutes that wrap`` () =
+    let clock1 = create 18 7
+    let clock2 = create -54 -11513
+    clock1 = clock2 |> should equal true
+