trackler 2.2.1.71 → 2.2.1.72

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 035f344758e70ee0d97c2246e5cfdf0878ec339b
-  data.tar.gz: 7b52f923df0cb958c251e599a75de951173521ee
+  metadata.gz: d3bd9240f0de766be65b492e5fe9bab8a3ceb6ef
+  data.tar.gz: 8cd5b56c4a4dabb98182c34e81d50b91458ddd4d
 SHA512:
-  metadata.gz: cdbc6ff2470de2c426509584b99d3853b3f59c25f6942883f8902a3acc8baae255f23b8f202758f3ea646d63c98d11acec4cedf6c78d5c64731737390b0ebb99
-  data.tar.gz: a47dc3a6adc5811139e22b25216924c2b669088bc12def99668fb36fec8cc69dbbb8571b4281981c5bdb427cb9373289e931c6df766732230dabafd286cb3cb8
+  metadata.gz: 8297750930c42b01dffe6903268abbf30d5a28648030cf0b973e4663b821c08e2555e99ed2bb94c4b126535da53b7fabd2293d8aa2907e53d92b3f8f60cca1e4
+  data.tar.gz: 2f41e6a9e8ff281e84587a7f934b6ea58c5f84c79b2102aa6fea886caaa9c35106283e5059498bd4cd808bdf16ed00cc17614fdc2c83290beea9fc859584d674

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.71"
+  VERSION = "2.2.1.72"
 end

data/problem-specifications/exercises/book-store/canonical-data.json

@@ -1,13 +1,13 @@
 {
   "exercise": "book-store",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "cases": [
     {
       "description": "Return the total basket price after applying the best discount.",
       "comments": [
         "Calculate lowest price for a shopping basket containing books only from ",
         "a single series.  There is no discount advantage for having more than ",
-        "one copy of any single book in a grouping."      
+        "one copy of any single book in a grouping."
       ],
       "cases": [
         {
@@ -100,6 +100,13 @@
          "basket": [1,1,2,2,3,3,4,4,5,5,1,2],
          "targetgrouping": [[1,2,3,4,5],[1,2,3,4,5],[1,2]],
          "expected": 75.20
+        },
+        {
+         "property": "total",
+         "description": "Four groups of four are cheaper than two groups each of five and three",
+         "basket": [1,1,2,2,3,3,4,5,1,1,2,2,3,3,4,5],
+         "targetgrouping": [[1,2,3,4],[1,2,3,5],[1,2,3,4],[1,2,3,5]],
+         "expected": 102.4
         }
      ]
     }

data/problem-specifications/exercises/word-count/canonical-data.json

@@ -111,6 +111,15 @@
         "large": 2,
         "and": 1
       }
+    },
+    {
+      "description": "multiple spaces not detected as a word",
+      "property": "countwords",
+      "input": " multiple   whitespaces",
+      "expected": {
+        "multiple": 1,
+        "whitespaces": 1
+      }
     }
   ]
 }

data/tracks/bash/CONTRIBUTING.md

@@ -0,0 +1,199 @@
+# Contributing to the Bash Track
+
+There are a lot of great resources for contributing to Exercism in general already.  Check out the [docs](https://github.com/exercism/docs) repository for a larger overview and some more general purpose instructions.
+
+A great way to get started contributing is [porting an exercise from another track](#porting-an-exercise-from-another-language)!  It helps you get into the repository, learn your way around, and see how things are structured.
+
+## Getting Set Up
+
+In order to run any of the test files (or examples, for that matter), you're going to need Bash.  If you're on OSX or Linux, this shouldn't be a problem for you.  Additionally, you'll need the Bash test runner that we're using: `bats`.  This can be installed via your package manager.  For more specifics, see the [tests page of this repository's docs](https://github.com/exercism/bash/blob/master/docs/TESTS.md).
+
+## Porting an Exercise from Another Language
+
+Porting an exercise from another language is easy (ish)!  You can follow this step-by-step guide (specific for this repository) to get it done.
+
+### Initial Setup
+
+Fork the Bash repository on GitHub (which you are currently in).
+
+![Fork button](img/fork-repository.png)
+
+Clone the repository to your computer.
+
+```bash
+$ git clone https://github.com/<your-user-name>/bash.git
+$ cd bash
+```
+
+Look through the [list of exercises not yet implemented in Bash](http://exercism.io/languages/bash/todo).  Once you've found one you like, make sure that someone's not already working on it by checking the [current open pull requests](https://github.com/exercism/bash/pulls).  Also double check that the exercise isn't in the list of exercises already implemented in your freshly cloned repository: `path/to/bash/exercises`.  Once you've selected an exercise you like, locate its *slug* (unique name) in [the master list of problem specifications](https://github.com/exercism/problem-specifications/tree/master/exercises).
+
+Create a directory in your local `exercises` folder with that same slug name.
+
+```bash
+# Optionally, but probably a good idea, create a new branch for your exercise
+$ git checkout -b <your-slug-here>
+# Create the new exercise directory
+$ mkdir exercises/<your-slug-here>
+```
+
+At the very least, you're going to need to create a `README.md`, a test file (`your_exercise_test.sh`), and an example file which, by convention, you should name `example.sh` when you're done.  For ease of debugging, you can start by naming your file `your_exercise.sh`.
+
+```bash
+$ touch README.md
+$ touch <your-exercise>_test.sh
+$ touch <your-exercise>.sh
+```
+
+Ensure that both of the shell script files are executeable.
+
+```bash
+$ chmod a+x <your-exercise>_test.sh <your-exercise>.sh
+```
+
+Many, if not all, of the current exercises have *canonical data* about them that is the same accross all languages.  This makes it so you don't have to come up with test cases or informative intro material yourself.  You're welcome!  Head over to your specific exercise page in the [master list](https://github.com/exercism/problem-specifications/tree/master/exercises) (same link as above).  Specifically right now, you're interested in `canonical_data.json`.
+
+![Canonical data example](img/canonical-data-example.png)
+
+Currently, you're interested in all of the `"cases"`.  Each of these is a test case that you'll have to implement in the specific vernacular of our test-runner, `bats`.  Check out [this repository's test documentation](https://github.com/exercism/bash/blob/master/docs/TESTS.md) if you missed the [Getting Set Up](#getting-set-up) section above.
+
+### Generating the Tests
+
+Implement each of the test cases (along with any comments or explanations you think are necessary for people who aren't sure of themselves).  When in doubt, check out the other, already implemented exercises for an example.  Here's an example of implementing the test case shown above.
+
+```bash
+#!/bin/bash
+
+@test 'Say Hi!' {
+  run bash hello_world.sh
+  
+  [ "$status" -eq 0 ]
+  [ "$output" = "Hello, World" ]
+}
+
+# ... The rest of your tests
+```
+
+For each test you create, you should use the `description` value for the test case description.  The `property` value is generally used by other languages to specify what the function to be run is called.  Use your best judgement and check out how other exercises handle this.  If there's just one property, you can just test the script as a whole.  If there's multiple properties, consider testing those as either subcommands or flags (e.g. an exercise with an encode and a decode property could be handled by `run bash cyper.sh encode <argument>` or by `run bash cypher.sh -e <argument>`).  You're the one writing the tests, so you decide.  You'll get feedback when you open your pull request anyways, so don't stress too much about it.
+
+You can check to see if your example script works by running `bats`.
+
+```bash
+$ bats hello_world_test.sh
+```
+
+### Implementing an Example Solution
+
+If you've been following along so far, your tests should fail.  Go ahead and implement your solution in the `<your-exercise>.sh` file.  Make sure your file has `#!/bin/bash` at the top.
+
+Keep running your test file against it until your tests all pass.  This process should help ensure that both your tests *and* your example are ship shape!
+
+Once your tests and example are complete, rename `<your-exercise>.sh` to `example.sh` to match all the other exercises.
+
+### Updating the Config
+
+Exercism makes heavy use of configuration files to automate things.  Now that you're done with your solution, you can add your problem to `bash/config.json`.  Check out the [configuration description](https://github.com/exercism/docs/blob/master/language-tracks/configuration/exercises.md) in the Exercism docs for more info on each item.
+
+```json
+// config.json
+{
+  "exercises": [
+    // ... All the other exercises
+  	{
+      "core": false, // True or false, you decide
+      "unlocked_by": "leap", // If core is false, pick a core exercise that
+      						 // unlocks this one.  Something similar, but easier
+      "difficulty": 1, // 1 == easy, 10 == impossible, you decide
+      "slug": "<your-exercise>",
+      "topics": [
+        "control_flow_conditionals",
+        "mathematics" // These can come from the topics list, linked below
+      ],
+      "uuid": "9ac0b041-a7aa-4b0c-952a-d38d35e2cd65" // see below
+	}
+  ]
+}
+```
+
+Possible topics that describe your exercise can come from the [topics master list](https://github.com/exercism/problem-specifications/blob/master/TOPICS.txt), but you're not limited to those.
+
+In order to get the `uuid` and check your work, you'll need the configlet, which is a handy tool created to automate some of the more monotonous tasks involved with this.  See the [configlet documentation](https://github.com/exercism/configlet) for more info.  Make sure you have the most current configlet by running:
+
+```bash
+$ bin/fetch-configlet
+```
+
+Each exercise *for each language* needs a unique ID number — a `uuid`.  The configley can help you generate one.
+
+```bash
+$ bin/configlet uuid
+```
+
+Copy/paste the generated value into the `uuid` field of your exercise.  Once you're done, it's time to check your work.  Run the configlet linter.
+
+```bash
+$ bin/configlet lint .
+# If for some reason you're not inside the project directory, instead use
+$ bin/configlet lint path/to/bash
+```
+
+Hopefully it says everything is OK!
+
+### Creating the README
+
+There are two ways to create the README: generate it via the configlet, or manually create it.  This guide covers them both.
+
+#### Using the Configlet
+
+The configlet has a generate command that uses Go templating and pulls from the repository's `config` directory as well as each exercise's `.meta` directory.  Learn more in the [configlet docs](https://github.com/exercism/configlet).  You should just be able to run:
+
+```bash
+$ bin/configlet generate <your-exercise>
+```
+
+This should auto-generate a nice README in your exercise directory.  If it gives you any issues, no worries!  You can always get it done by...
+
+#### Doing It Manually
+
+Use the `config/exercise_readme.go.tmpl` file as a guide.  The README should look something like this:
+
+```markdown
+# <Your Exercise Title>
+
+... Description copied from the master exercise repo (where you got your tests)
+
+... Any additional hints that need provided
+
+... Bash standard material, copied from `docs/EXERCISE_README_INSERT.md`
+
+## Source
+
+... Copy credits from the master exercise repo
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+```
+
+### Cleaning Up
+
+20. If you've been practicing good version control throughout this process, you may have several commits.  At this point, you're almost ready to submit your pull request, but you should rebase against the most recent upstream master branch.
+
+```bash
+# Assuming you've alread 'git added' and 'git commited'
+# If you don't already have the exercism/bash as your upstream remote:
+$ git remote add upstream https://github.com/exercism/bash.git
+# To get the most recent upstream version
+$ git fetch upstream
+# Rebase onto the upstream
+$ git rebase upstream/master
+```
+
+21. Now you're ready to sync up with Github and open your pull request!
+
+```bash
+$ git push --force-with-lease origin <your-branch-name>
+```
+
+![Create pull request](img/create-pr.png)
+
+Good luck, happy scripting, and thanks for your help!

data/tracks/bash/config.json

@@ -66,6 +66,16 @@
       "unlocked_by": "leap",
       "uuid": "ca5139b4-8b2f-44ea-8d83-0b8ca7674436"
     },
+    {
+      "core": true,
+      "difficulty": 1,
+      "slug": "error-handling",
+      "topics": [
+        "error_handling",
+        "input_validation"
+      ],
+      "uuid": "b2b4ee35-108f-45ce-b294-c10d332e5579"
+    },
     {
       "core": true,
       "difficulty": 2,
@@ -152,16 +162,6 @@
       "unlocked_by": "pangram",
       "uuid": "9f9a1a49-472f-4a39-aa28-6aa17eeebdc7"
     },
-    {
-      "core": true,
-      "difficulty": 1,
-      "slug": "error-handling",
-      "topics": [
-        "error_handling",
-        "input_validation"
-      ],
-      "uuid": "b2b4ee35-108f-45ce-b294-c10d332e5579"
-    },
     {
       "core": false,
       "difficulty": 5,
@@ -173,8 +173,21 @@
       ],
       "unlocked_by": "hamming",
       "uuid": "03808072-0228-6580-7a9b-cc709a8a5b8c0e600b9"
+    },
+    {
+      "core": false,
+      "difficulty": 2,
+      "slug": "triangle",
+      "topics": [
+        "boolean_logic",
+        "input_validation",
+        "number_comparison",
+        "mathematics"
+      ],
+      "unlocked_by": "leap",
+      "uuid": "496e130a-063a-6380-19dc-179f05534717226bca1"
     }
   ],
   "foregone": [],
   "language": "Bash"
-}
+}

data/tracks/bash/exercises/triangle/README.md

@@ -0,0 +1,38 @@
+# Triangle
+
+Determine if a triangle is equilateral, isosceles, or scalene.
+
+An _equilateral_ triangle has all three sides the same length.
+
+An _isosceles_ triangle has at least two sides the same length. (It is sometimes
+specified as having exactly two sides the same length, but for the purposes of
+this exercise we'll say at least two.)
+
+A _scalene_ triangle has all sides of different lengths.
+
+## Note
+
+For a shape to be a triangle at all, all sides have to be of length > 0, and
+the sum of the lengths of any two sides must be greater than or equal to the
+length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
+
+## Dig Deeper
+
+The case where the sum of the lengths of two sides _equals_ that of the
+third is known as a _degenerate_ triangle - it has zero area and looks like
+a single line. Feel free to add your own code/tests to check for degenerate triangles.
+
+## Tests
+
+Run the tests with:
+
+```bash
+    bats triangle_test.sh
+```
+
+## Source
+
+The [Ruby Koans](http://rubykoans.com) triangle project, parts 1 & 2
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/bash/exercises/triangle/example.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+set -o errexit   # Stop script on command error
+set -o nounset   # Error out if accessing undefined variable name
+set -o pipefail  # Error out if any step in a pipe errors out
+
+if [[ $# -ne 4 ]]; then
+  echo "Usage: $0 [equilateral | isosceles | scalene] <s1> <s2> <s3>"
+  exit 2 # Improper inputs
+fi
+
+triangle_type=$1
+s1=$2
+s2=$3
+s3=$4
+
+assert() {
+  # Takes a numerical inequality in a string.
+  # Pipes it through to bc
+  # Float-proof numeric comparison :
+  [[ $( echo $1 | bc -l ) -eq 1 ]]
+}
+
+valid_triangle() {
+  # Takes three sides lengths (numeric) $1, $2, $3
+  # If any side is zero, returns false
+  assert "$1 == 0" || assert "$2 == 0" || assert "$3 == 0" && return 1
+  # If triangle doesn't meet inequality requirement, returns false
+  assert "$1 + $2 <= $3" || assert "$1 + $3 <= $2" || assert "$2 + $3 <= $1" && return 1
+  return 0
+}
+
+if ! valid_triangle $s1 $s2 $s3; then
+  echo "Sides do not meet triangle inequality requirement."
+  echo "Given a <= b <= c and a, b, c != 0, a + b >= c"
+  exit 1
+fi
+
+equilateral() {
+  assert "$1 == $2" && assert "$1 == $3"
+}
+
+isosceles() {
+  assert "$1 == $2" || assert "$1 == $3" || assert "$2 == $3"
+}
+  
+scalene() {
+  assert "$1 != $2" && assert "$1 != $3" && assert "$2 != $3"
+}
+
+# Bash Ternary Operator:
+# (boolean value/calculation) && action if true || action if false
+# Works because of boolean shortcutting.
+# If boolean clause is false, it doesn't evaluate the other side of &&
+# If first thing is false, it evaluates the item after ||,
+# but if first two are true, doesn't bother evaluating last part.
+$triangle_type $s1 $s2 $s3 && exit 0 || exit 1

data/tracks/bash/exercises/triangle/triangle_test.sh

@@ -0,0 +1,126 @@
+#!/bin/bash
+
+# Test Equilateral
+@test "true if all sides are equal" {
+  # skip
+  run bash triangle.sh equilateral 2 2 2
+
+  [ "$status" -eq 0 ]
+}
+
+@test "false if any side is unequal" {
+  skip
+  run bash triangle.sh equilateral 2 3 2
+
+  [ "$status" -eq 1 ]
+}
+
+@test "false if no side is equal" {
+  skip
+  run bash triangle.sh equilateral 5 4 6
+
+  [ "$status" -eq 1 ]
+}
+
+@test "all zero sides illegal, so the triangle is not equilateral" {
+  skip
+  run bash triangle.sh equilateral 0 0 0
+
+  [ "$status" -eq 1 ]
+}
+
+# BONUS: Deal with floating point numbers
+@test "sides may be floats" {
+  skip
+  run bash triangle.sh equilateral 0.5 0.5 0.5
+
+  [ "$status" -eq 0 ]
+}
+
+# Test Isosceles
+@test "true if last two sides are equal" {
+  skip
+  run bash triangle.sh isosceles 3 4 4
+
+  [ "$status" -eq 0 ]
+}
+
+@test "true if first two sides are equal" {
+  skip
+  run bash triangle.sh isosceles 4 4 3
+
+  [ "$status" -eq 0 ]
+}
+
+@test "true if first and last sides are equal" {
+  skip
+  run bash triangle.sh isosceles 4 3 4
+
+  [ "$status" -eq 0 ]
+}
+
+@test "equilateral triangles are also isosceles" {
+  skip
+  run bash triangle.sh isosceles 4 4 4
+
+  [ "$status" -eq 0 ]
+}
+
+@test "false if no sides are equal" {
+  skip
+  run bash triangle.sh isosceles 2 3 4
+
+  [ "$status" -eq 1 ]
+}
+
+@test "sides that violate triangle inequality are not isosceles, even if two are equal" {
+  skip
+  run bash triangle.sh isosceles 1 1 3
+
+  [ "$status" -eq 1 ]
+}
+
+# BONUS: Deal with floating point numbers
+@test "isosceles sides may be floats" {
+  skip
+  run bash triangle.sh isosceles 0.5 0.4 0.5
+
+  [ "$status" -eq 0 ]
+}
+
+# Test Scalene
+@test "true if no sides are equal" {
+  skip
+  run bash triangle.sh scalene 5 4 6
+
+  [ "$status" -eq 0 ]
+}
+
+@test "false if all sides are equal" {
+  skip
+  run bash triangle.sh scalene 4 4 4
+
+  [ "$status" -eq 1 ]
+}
+
+@test "false if two sides are equal" {
+  skip
+  run bash triangle.sh scalene 4 4 3
+
+  [ "$status" -eq 1 ]
+}
+
+@test "sides that violate triangle inequality are not scalene even if they are all different" {
+  skip
+  run bash triangle.sh scalene 7 3 2
+
+  [ "$status" -eq 1 ]
+}
+
+# BONUS: Deal with floating point numbers
+@test "scalene sides may be floats" {
+  skip
+  run bash triangle.sh scalene 0.5 0.4 0.6
+
+  [ "$status" -eq 0 ]
+}