trackler 2.0.8.51 → 2.0.8.52

data/tracks/go/README.md

@@ -181,10 +181,23 @@ directory within each exercise that makes use of a test cases generator. This
 *.meta* directory will be ignored when a user fetches an exercise.
 
 Whenever the shared JSON data changes, the test cases will need to be regenerated.
-To do this, make sure that the **x-common** repository has been cloned in the same
-parent-directory as the **xgo** repository. Then navigate into the **xgo**
-directory and run `go run exercises/<exercise>/.meta/gen.go`. You should see
-that the `<exercise>/cases_test.go` file has changed. Commit the change.
+The generator will first look for a local copy of the **x-common** repository.
+If there isn't one it will attempt to get the relevant json data for the
+exercise from the **x-common** repository on GitHub.
+
+To use a local copy of the **x-common** repository, make sure that it has been
+cloned into the same parent-directory as the **xgo** repository.
+
+```sh
+$ tree -L 1 .
+.
+├── x-common
+└── xgo
+```
+
+To regenerate the test cases, navigate into the **xgo** directory and run
+`go run exercises/<exercise>/.meta/gen.go`. You should see that the
+`<exercise>/cases_test.go` file has changed. Commit the change.
 
 ## Pull requests
 

data/tracks/go/gen/gen.go

@@ -7,18 +7,20 @@ import (
 	"fmt"
 	"go/format"
 	"io/ioutil"
+	"log"
+	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"text/template"
+	"time"
 )
 
-// dirMetadata is the location of the x-common repository
-// on the filesystem.
-// We're making the assumption that the x-common repository
-// has been cloned to the same parent directory as the xgo
-// repository. E.g.
+// dirMetadata is the location of the x-common repository on the filesystem.
+// We're making the assumption that the x-common repository has been cloned to
+// the same parent directory as the xgo repository.
+// E.g.
 //
 //     $ tree -L 1 .
 //     .
@@ -31,7 +33,21 @@ var dirMetadata string
 // the exercise directory. Falls back to the present working directory.
 var dirExercise string
 
-// Header tells how the test data was generated, for display in the header of cases_test.go
+// genClient creates an http client with a 10 second timeout so we don't get
+// stuck waiting for a response.
+var genClient = &http.Client{Timeout: 10 * time.Second}
+
+const (
+	// canonicalDataURL is the URL for the raw canonical-data.json data,
+	// requires exercise name.
+	canonicalDataURL = "https://raw.githubusercontent.com/exercism/x-common/master/exercises/%s/canonical-data.json"
+	// commitsURL is the GitHub api endpoint for the canonical-data.json
+	// file commit history, requires exercise name.
+	commitsURL = "https://api.github.com/repos/exercism/x-common/commits?path=exercises/%s/canonical-data.json"
+)
+
+// Header tells how the test data was generated, for display in the header of
+// cases_test.go
 type Header struct {
 	// Ori is a deprecated short name for Origin.
 	// TODO: Remove Ori once everything switches to Origin.
@@ -70,11 +86,21 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
 		return errors.New("unable to determine current path")
 	}
 	jFile := filepath.Join("exercises", exercise, "canonical-data.json")
-	// find and read the json source file
-	jPath, jOrigin, jCommit := getPath(jFile)
+	// try to find and read the local json source file
+	log.Printf("[LOCAL] fetching %s test data\n", exercise)
+	jPath, jOrigin, jCommit := getLocal(jFile)
+	if jPath != "" {
+		log.Printf("[LOCAL] source: %s\n", jPath)
+	}
 	jSrc, err := ioutil.ReadFile(filepath.Join(jPath, jFile))
 	if err != nil {
-		return err
+		// fetch json data remotely if there's no local file
+		log.Println("[LOCAL] No test data found")
+		log.Printf("[REMOTE] fetching %s test data\n", exercise)
+		jSrc, jOrigin, jCommit, err = getRemote(exercise)
+		if err != nil {
+			return err
+		}
 	}
 
 	// unmarshal the json source to a Go structure
@@ -91,7 +117,7 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
 		Version string
 	}
 	if err := json.Unmarshal(jSrc, &commonMetadata); err != nil {
-		return fmt.Errorf(`Didn't contain version: %v`, err)
+		return fmt.Errorf(`didn't contain version: %v`, err)
 	}
 
 	// package up a little meta data
@@ -107,7 +133,7 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
 
 	// render the Go test cases
 	var b bytes.Buffer
-	if err = t.Execute(&b, &d); err != nil {
+	if err := t.Execute(&b, &d); err != nil {
 		return err
 	}
 	// clean it up
@@ -119,17 +145,17 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
 	return ioutil.WriteFile(filepath.Join(dirExercise, "cases_test.go"), src, 0666)
 }
 
-func getPath(jFile string) (jPath, jOrigin, jCommit string) {
+func getLocal(jFile string) (jPath, jOrigin, jCommit string) {
 	// Ideally draw from a .json which is pulled from the official x-common
 	// repository.  For development however, accept a file in current directory
 	// if there is no .json in source control.  Also allow an override in any
 	// case by environment variable.
-	if jPath = os.Getenv("EXTEST"); jPath > "" {
+	if jPath := os.Getenv("EXTEST"); jPath > "" {
 		return jPath, "local file", "" // override
 	}
 	c := exec.Command("git", "log", "-1", "--oneline", jFile)
 	c.Dir = dirMetadata
-	ori, err := c.Output()
+	origin, err := c.Output()
 	if err != nil {
 		return "", "local file", "" // no source control
 	}
@@ -137,5 +163,49 @@ func getPath(jFile string) (jPath, jOrigin, jCommit string) {
 		return "", "local file", "" // not in source control
 	}
 	// good.  return source control dir and commit.
-	return c.Dir, "exercism/x-common", string(bytes.TrimSpace(ori))
+	return c.Dir, "exercism/x-common", string(bytes.TrimSpace(origin))
+}
+
+func getRemote(exercise string) (body []byte, jOrigin string, jCommit string, err error) {
+	url := fmt.Sprintf(canonicalDataURL, exercise)
+	resp, err := genClient.Get(url)
+	if err != nil {
+		return []byte{}, "", "", err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return []byte{}, "", "", fmt.Errorf("error fetching remote data: %s", resp.Status)
+	}
+	defer resp.Body.Close()
+	body, err = ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return []byte{}, "", "", err
+	}
+	c, err := getRemoteCommit(exercise)
+	if err != nil {
+		// we always expect to have the commit in the cases_test.go
+		// file, so return the error if we can't fetch it
+		return []byte{}, "", "", err
+	}
+	log.Printf("[REMOTE] source: %s\n", url)
+	return body, "exercism/x-common", c, nil
+}
+
+func getRemoteCommit(exercise string) (string, error) {
+	type Commits struct {
+		Sha    string
+		Commit struct {
+			Message string
+		}
+	}
+	resp, err := genClient.Get(fmt.Sprintf(commitsURL, exercise))
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	var c []Commits
+	err = json.NewDecoder(resp.Body).Decode(&c)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s %s", c[0].Sha[0:7], c[0].Commit.Message), nil
 }

data/tracks/java/exercises/pascals-triangle/src/example/java/PascalsTriangleGenerator.java

@@ -0,0 +1,21 @@
+class PascalsTriangleGenerator {
+
+  int[][] generateTriangle(int rows) {
+    if (rows < 0) {
+      throw new IllegalArgumentException("Rows can't be negative!");
+    }
+
+    int[][] triangle = new int[rows][];
+
+    for (int i = 0; i < rows; i++) {
+      triangle[i] = new int[i + 1];
+      triangle[i][0] = 1;
+      for (int j = 1; j < i; j++) {
+        triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j];
+      }
+      triangle[i][i] = 1;
+    }
+    return triangle;
+  }
+
+}

data/tracks/java/exercises/pascals-triangle/src/test/java/PascalsTriangleGeneratorTest.java

@@ -0,0 +1,86 @@
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
+
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+/*
+ * version: 1.0.0
+ */
+public class PascalsTriangleGeneratorTest {
+
+    private PascalsTriangleGenerator pascalsTriangleGenerator;
+
+    @Before
+    public void setUp() {
+        pascalsTriangleGenerator = new PascalsTriangleGenerator();
+    }
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Test
+    public void testTriangleWithZeroRows() {
+        int[][] expectedOutput = new int[][]{};
+
+        assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(0));
+    }
+
+    @Ignore
+    @Test
+    public void testTriangleWithOneRow() {
+        int[][] expectedOutput = new int[][]{
+            {1}
+        };
+
+        assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(1));
+    }
+
+    @Ignore
+    @Test
+    public void testTriangleWithTwoRows() {
+        int[][] expectedOutput = new int[][]{
+            {1},
+            {1, 1}
+        };
+
+        assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(2));
+    }
+
+    @Ignore
+    @Test
+    public void testTriangleWithThreeRows() {
+        int[][] expectedOutput = new int[][]{
+            {1},
+            {1, 1},
+            {1, 2, 1}
+        };
+
+        assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(3));
+    }
+
+    @Ignore
+    @Test
+    public void testTriangleWithFourRows() {
+        int[][] expectedOutput = new int[][]{
+            {1},
+            {1, 1},
+            {1, 2, 1},
+            {1, 3, 3, 1}
+        };
+
+        assertArrayEquals(expectedOutput, pascalsTriangleGenerator.generateTriangle(4));
+    }
+
+    @Ignore
+    @Test
+    public void testValidatesNotNegativeRows() {
+        thrown.expect(IllegalArgumentException.class);
+        pascalsTriangleGenerator.generateTriangle(-1);
+    }
+
+}

data/tracks/javascript/exercises/leap/HINT.md

@@ -0,0 +1,52 @@
+This is the first test for this exercise:
+
+```javascript
+  it('is not very common', function() {
+    var year = new Year(2015);
+    expect(year.isLeap()).toBe(false);
+  });
+```
+
+Each test in the exercise follows the same pattern: 
+
+  1. A new Year is instantiated with a value and stored in a variable: year.
+  2. The test calls an instance method, isLeap(), from the variable `year`.
+
+The `Year` function is a constructor, which means that it is specifically designed to provide a template for new objects.
+
+When a new `Year` object is created:
+
+```javascript
+  var year = new Year(2015);
+```
+
+We expect `year` to, at the very least, have a specific value (in this case 2015) assigned to it.  Otherwise it would not represent an actual year.
+
+This means that we must store the value passed as a parameter when the new `Year` is created (2015), so that the new `Year` can access it.
+
+The way a constructor stores these fundamental values (instance variables) is like this:
+
+```javascript
+  var Constructor = function(input) {
+    this.value = input;
+  };
+```
+
+The `this` in the constructor refers to the newly created instance of the `Constructor`.
+
+Once the input (parameter) is stored in an instance variable, any instance methods, such as:
+
+```javascript
+  Constructor.prototype.instanceMethod = function() {
+    // this method can now access the input by calling `this.value`
+  };
+```
+
+The instance method accesses the input using `this.value` (in this example).
+
+This is why code needs to be written in two separate functions:
+
+  1. The first function, `Year`, is a constructor that serves as a template for year objects that are created with their value (such as 2015).
+     This function needs to store the input when a new `Year` is created.
+  2. The second function, isLeap(), is an instance method that is called from a new `year`. 
+     This function (method) should contain the logic to determine if the given year is a leap year.

data/tracks/javascript/exercises/leap/leap.js

@@ -3,9 +3,13 @@
 // convenience to get you started writing code faster.
 //
 
-var Year = function() {};
+var Year = function(input) {
+//
+// YOUR CODE GOES HERE
+//  
+};
 
-Year.prototype.isLeap = function(input) {
+Year.prototype.isLeap = function() {
 //
 // YOUR CODE GOES HERE
 //

data/tracks/objective-c/docs/TESTS.md

@@ -29,19 +29,20 @@ __Note:__ If you receive the error "No visible `@interface` for ExerciseName dec
 
 ### A Test Runner
 
-An alternative to manually generating the project file is to use a test runner utility, written in ruby, that will create a project file for you with the test file, header file and source file.
+An alternative to manually generating the project file is to use a test runner utility written in ruby, [`objc`](https://rubygems.org/gems/objc/), that will create a project file for you with the test file, header file and source file.
 
 ```bash
 $ gem install objc
-$ brew install xctool
 ```
 
 Run the tests with:
 
 ```bash
-$ objc ExerciseName
+$ objc -x ExerciseName
 ```
 
-The objc utility uses the exercise name to find the test file, `ExerciseNameTest.m`, the header file, `ExerciseName.h` and source file `ExerciseName.m`. The files are inserted into a temporary Xcode Project and then `xctool` is used to run the tests for the project.
+(Note the `-x`/`--xcodebuild` flag, which specifies using `xcodebuild` instead of `xctool`. The latter does not work with Xcode's latest releases.)
+
+The objc utility uses the exercise name to find the test file, `ExerciseNameTest.m`, the header file, `ExerciseName.h` and source file `ExerciseName.m`. The files are inserted into a temporary Xcode Project and then `xcodebuild` is used to run the tests for the project.
 
 While `objc` makes it so you never have to launch Xcode to complete these exercises, the error messages and feedback through the command-line are not as clear as through the Xcode user interface.

data/tracks/purescript/config.json

@@ -136,6 +136,14 @@
       "topics": [
         "strings"
       ]
+    },
+    {
+      "slug": "crypto-square",
+      "difficulty": 1,
+      "topics": [
+        "strings",
+        "matrices"
+      ]
     }
   ],
   "deprecated": [

data/tracks/purescript/exercises/crypto-square/bower.json

@@ -0,0 +1,18 @@
+{
+  "name": "crypto-square",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-prelude": "^3.0.0",
+    "purescript-strings": "^3.0.0",
+    "purescript-unicode": "^3.0.1"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^3.0.0",
+    "purescript-test-unit": "^11.0.0"
+  }
+}

data/tracks/purescript/exercises/crypto-square/examples/src/CryptoSquare.purs

@@ -0,0 +1,63 @@
+module CryptoSquare
+  ( normalizedPlaintext
+  , plaintextSegments
+  , encoded
+  , ciphertext
+  ) where
+
+import Prelude
+import Data.Array as A
+import Data.Array (filter, fromFoldable, replicate, toUnfoldable, (:))
+import Data.Char.Unicode (isAlphaNum)
+import Data.Foldable (maximum)
+import Data.Int (ceil, toNumber)
+import Data.List (transpose)
+import Data.Maybe (fromMaybe)
+import Data.String (drop, fromCharArray, joinWith, length, take, toCharArray, toLower)
+import Math (sqrt)
+
+normalizedPlaintext :: String -> String
+normalizedPlaintext
+  = toCharArray
+    >>> filter isAlphaNum
+    >>> fromCharArray
+    >>> toLower
+
+plaintextSegments :: String -> Array String
+plaintextSegments str = toSquare norm
+  where norm = normalizedPlaintext str
+        cols = sqrt (length norm # toNumber) # ceil
+        toSquare "" = []
+        toSquare s  = take cols s : toSquare (drop cols s)
+
+transposeArray :: forall a. Array (Array a) -> Array (Array a)
+transposeArray
+  = toUnfoldable
+    >>> map toUnfoldable
+    >>> transpose
+    >>> map fromFoldable
+    >>> fromFoldable
+
+encoded :: String -> String
+encoded = plaintextSegments
+          >>> map toCharArray
+          >>> transposeArray
+          >>> map fromCharArray
+          >>> joinWith ""
+
+spaces :: Int -> Array Char
+spaces n = replicate n ' '
+
+equalPad :: Array (Array Char) -> Array (Array Char)
+equalPad arr = map pad arr
+  where width = fromMaybe 0 (maximum $ map A.length arr)
+        pad el = el <> spaces (width - A.length el)
+
+ciphertext :: String -> String
+ciphertext = plaintextSegments
+             >>> map toCharArray
+             >>> transposeArray
+             >>> equalPad
+             >>> map fromCharArray
+             >>> joinWith " "
+