trackler 2.0.6.34 → 2.0.6.35

data/tracks/julia/exercises/nucleotide-count/runtests.jl

@@ -0,0 +1,19 @@
+using Base.Test
+
+include("nucleotide-count.jl")
+
+@testset "empty strand" begin
+    @test count_nucleotides("") == Dict('A' => 0, 'C' => 0, 'G' => 0, 'T' => 0)
+end
+
+@testset "strand with repeated nucleotide" begin
+    @test count_nucleotides("GGGGGGG") == Dict('A' => 0, 'C' => 0, 'G' => 7, 'T' => 0)
+end
+
+@testset "strand with multiple nucleotides" begin
+    @test count_nucleotides("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC") == Dict('A' => 20, 'C' => 12, 'G' => 17, 'T' => 21)
+end
+
+@testset "strand with invalid nucleotides" begin
+    @test_throws ErrorException count_nucleotides("AGXXACT")
+end

data/tracks/kotlin/.travis.yml

@@ -3,8 +3,16 @@ language: java
 jdk:
   - oraclejdk8
 
-# http://docs.travis-ci.com/user/migrating-from-legacy
 sudo: false
+cache: bundler
+addons:
+  apt:
+    packages:
+      - tree
+before_install:
+  - rvm install 2.2.5
+  - rvm use 2.2.5
 
 script:
   - bin/unit-tests.sh
+  - bin/journey-test.sh

data/tracks/kotlin/README.md

@@ -1,20 +1,126 @@
-# xKotlin [![Build Status](https://travis-ci.org/exercism/xkotlin.svg?branch=master)](https://travis-ci.org/exercism/xkotlin)
+# xkotlin [![Build Status](https://travis-ci.org/exercism/xkotlin.svg?branch=master)](https://travis-ci.org/exercism/xkotlin)
 
-Exercism problems in Kotlin.
+Source for Exercism Exercises in Kotlin.
 
-## TODO
+## Contributing Guide
 
-_Document how to contribute to the Kotlin track._
+For general information about how to contribute to Exercism, please refer to the [Contributing Guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data).
 
-## Contributing Guide
+## Table of Contents
 
-Please see the [contributing guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md).
+* [Overview](#overview)
+* [Contributing With Minimal Setup](#contributing-with-minimal-setup)
+* [Getting Familiar With the Codebase](#getting-familiar-with-the-codebase)
+  * [The `exercises` Module](#the-exercises-module)
+  * [The Problem Submodules](#the-problem-submodules)
+* [Advanced: Complete Local Setup](#advanced-complete-local-setup)
+  * [Tip: `gradle clean` before `exercism fetch`](#tip-gradle-clean-before-exercism-fetch)
 
-## License
 
-The MIT License (MIT)
+## Overview
+
+This guide covers contributing to the Kotlin track.  If you are new, this guide is for you.
+
+If, at any point, you're having any trouble, pop in the [Gitter exercism/dev room](https://gitter.im/exercism/dev) for help.
+
+## Contributing With Minimal Setup
+
+First things first: by contributing to Exercism, you are making this learning tool that much better and improving our industry as a whole... thank you!!!
+
+To submit a fix for an existing exercise or port an exercise to Kotlin with the least amount of setup:
+
+1. **Ensure you have the basic Java tooling installed:**  JDK 1.8+, an editor and Gradle 2.x.
+
+   (see [exercism.io: Installing Kotlin](http://exercism.io/languages/kotlin/installing))
+-  **Setup a branch on a fork of [exercism/xkotlin](https://github.com/exercism/xkotlin) on your computer.**
+
+   See [GitHub Help: Forking](https://help.github.com/articles/fork-a-repo/).  Use those instructions (in conjunction with [Exercism Contributing Guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md#git-basics)) to:
+   * "fork" a repository on GitHub;
+   - install `git`;
+   - "clone" a copy of your fork;
+   - configure an "upstream remote" (in this case, `exercism/xkotlin`);
+   - create a branch to house your work
+-  **Write the codes.**  Do your work on that branch you just created.
+
+   The [Getting Familiar With the Codebase](#getting-familiar-with-the-codebase) section, below, is an orientation.
+-  **Commit, push and create a pull request.**
+
+   Something like:
+   ```
+   $ git add .
+   $ git commit -m "(An intention-revealing commit message)"
+   $ git push
+   ```
+
+   [Exercism Contributing Guide :: Commit Messages](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md#commit-messages) provides practical advice on crafting meaningful commit messages.
+-  **Verify that your work passes all tests.**  When you create a pull request (PR), GitHub triggers a build on Travis CI.  Your PR will not be merged unless those tests pass.
+
+## Getting Familiar With the Codebase
+
+There are two objectives to the design of this build:
+
+1. when a problem is built from within the xkotlin repo (i.e. when you, the contributor, are developing the exercise), the tests run against the "example" code;
+2. when a problem is built outside the xkotlin repo (when a participant is solving the exercise), the tests run against the "main" code.
+
+This repo is a multi-project gradle build.
+
+### The `exercises` Module
+
+This is the top-level module, contained in the `exercises` directory.  It is a container for the problem sub-modules.
 
-Copyright (c) 2015 Katrina Owen, _@kytrinyx.com
+  * it's `build.gradle` points the "main" sourceset to the example code.
+  * it's `settings.gradle` names each of the subprojects, one for each problem in the set.
+
+### The Problem Submodules
+
+The `exercises` subdirectory contains all of the problem submodules.
+Each problem/submodule is a subdirectory of the same name as its slug.
+
+  * it's `build.gradle` names dependencies required to work that problem.
+
+Each problem/submodule has three source sets:
+
+* `src/test/kotlin/` — a test suite defining the edges of the problem
+* `src/example/kotlin/` — an example solution that passes all the tests
+* `src/main/kotlin/` — starter source files, if required/desired *(this directory usually only has a `.keep` file in it)*.
+
+----
+
+## Advanced: Complete Local Setup
+
+If you are going to make significant contribution(s) to the track, you might find it handy to have a complete local install of exercism on your computer.  This way, you can run the full suite of tests without having to create/update a PR.
+
+The easiest way to achieve this is simply use the `bin/journey-test.sh` script.  However, you may want to perform other tests, depending on what you are doing.  You can do so by duplicating the setup performed by the `bin/journey-test.sh` script.
+
+### Tip: `gradle clean` before `exercism fetch`
+
+If you `exercism fetch` after doing a build, the CLI will fail with the following error message:
+
+```
+$ exercism fetch kotlin bob
+2015/09/06 15:03:21 an internal server error was received.
+Please file a bug report with the contents of 'exercism debug' at: https://github.com/exercism/exercism.io/issues
+```
+
+and if you review the logs of your x-api, you'll find:
+
+```
+127.0.0.1 - - [06/Sep/2015:15:20:56 -0700] "GET /v2/exercises/kotlin/bob HTTP/1.1" 500 514949 0.2138
+2015-09-06 15:21:01 - JSON::GeneratorError - source sequence is illegal/malformed utf-8:
+```
+
+This is because some files generated by the build can't be served from the x-api.  This is by design: the CLI does not serve binaries.  To fix this, simply make sure you do a clean in your `xkotlin` repo before you fetch:
+
+```
+cd ~/workspace/exercism/xkotlin/exercises
+gradle clean
+cd ~/workspace/exercism/exercises
+exercism fetch kotlin bob
+```
+
+
+# License
+
+The MIT License (MIT)
 
-### Kotlin icon
-The Kotlin icon was designed by JetBrains and may be used in its original form.
+Copyright (c) 2014 Katrina Owen, _@kytrinyx.com

data/tracks/kotlin/bin/journey-test.sh

@@ -0,0 +1,279 @@
+#!/usr/bin/env bash
+
+# This script is shared between the Java and Kotlin tracks.  If you make an update to this script on
+# on track, please create a companion PR to merge it in to the other.  Thank you!
+TRACK=kotlin
+TRACK_REPO="x${TRACK}"
+TRACK_SRC_EXT="kt"
+
+on_exit() {
+  echo ">>> on_exit()"
+  if [[ "$xapi_pid" != "" ]] ; then
+    kill $xapi_pid
+    echo "stopped x-api (pid=${xapi_pid})"
+  fi
+  cd $EXECPATH
+  echo "<<< on_exit()"
+}
+
+assert_installed() {
+  local binary=$1
+  echo ">>> assert_installed(binary=\"${binary}\")"
+
+  if [[ "`which $binary`" == "" ]]; then
+    echo "${binary} not found; it is required to perform this test."
+    echo -e "Have you completed the setup instructions at https://github.com/exercism/${TRACK_REPO} ?\n"
+    echo "PATH=${PATH}"
+    echo "aborting."
+    exit 1
+  fi
+  echo "<<< assert_installed()"
+}
+
+assert_ruby_installed() {
+  local ruby_app_home="$1"
+  echo ">>> assert_ruby_installed(ruby_app_home=\"${ruby_app_home}\")"
+
+  pushd "${ruby_app_home}"
+  local current_ruby_ver=`ruby --version | egrep --only-matching "[0-9]+\.[0-9]+\.[0-9]+"`
+  local expected_ruby_ver=`cat Gemfile | awk -F\' '/ruby /{print $2}'`
+  popd
+  if [[ "${expected_ruby_ver}" != "" && "${current_ruby_ver}" != "${expected_ruby_ver}" ]]; then
+    echo "${ruby_app_home} requires Ruby ${expected_ruby_ver}; current Ruby version is ${current_ruby_ver}."
+    echo -e "Ruby used: `which ruby`.\n"
+    echo -e "Have you completed the setup instructions at https://github.com/exercism/${TRACK_REPO} ?\n"
+    echo "PATH=${PATH}"
+    echo "aborting."
+    exit 1
+  fi
+  echo "<<< assert_ruby_installed()"
+}
+
+clean() {
+  local build_dir="$1"
+  echo ">>> clean(build_dir=\"${build_dir}\")"
+
+  # empty, absolute path, or parent reference are considered dangerous to rm -rf against.
+  if [[ "${build_dir}" == "" || ${build_dir} =~ ^/ || ${build_dir} =~ \.\. ]] ; then
+    echo "Value for build_dir looks dangerous.  Aborting."
+    exit 1
+  fi
+
+  local build_path=$( pwd )/${build_dir}
+  if [[ -d "${build_path}" ]] ; then
+    echo "Cleaning journey script build output directory (${build_path})."
+    rm -rf "${build_path}"
+  fi
+  cd exercises
+  gradle clean
+  cd ..
+  echo "<<< clean()"
+}
+
+get_operating_system() {
+  case $(uname) in
+      (Darwin*)
+          echo "mac";;
+      (Linux*)
+          echo "linux";;
+      (Windows*)
+          echo "windows";;
+      (*)
+          echo "linux";;
+  esac
+}
+
+get_cpu_architecture() {
+  case $(uname -m) in
+      (*64*)
+          echo 64bit;;
+      (*686*)
+          echo 32bit;;
+      (*386*)
+          echo 32bit;;
+      (*)
+          echo 64bit;;
+  esac
+}
+
+download_exercism_cli() {
+  local os="$1"
+  local arch="$2"
+  local exercism_home="$3"
+  echo ">>> download_exercism_cli(os=\"${os}\", arch=\"${arch}\", exercism_home=\"${exercism_home}\")"
+
+  local CLI_RELEASES=https://github.com/exercism/cli/releases
+
+  local latest=${CLI_RELEASES}/latest
+  # "curl..." :: HTTP 302 headers, including "Location" -- URL to redirect to.
+  # "awk..." :: pluck last path segment from "Location" (i.e. the version number)
+  local version="$(curl --head --silent ${latest} | awk -v FS=/ '/Location:/{print $NF}' | tr -d '\r')"
+  local download_url=${CLI_RELEASES}/download/${version}/exercism-${os}-${arch}.tgz
+
+  mkdir -p ${exercism_home}
+  curl -s --location ${download_url} | tar xz -C ${exercism_home}
+  echo "<<< download_exercism_cli()"
+}
+
+git_clone() {
+  local repo_name="$1"
+  local dest_path="$2"
+  echo ">>> git_clone(repo_name=\"${repo_name}\", dest_path=\"${dest_path}\")"
+
+  git clone https://github.com/exercism/${repo_name} ${dest_path}
+
+  echo "<<< git_clone()"
+}
+
+make_local_trackler() {
+  local trackler="$1"
+  local xapi_home="$2"
+  echo ">>> make_local_trackler(trackler=\"${trackler}\", xapi_home=\"${xapi_home}\")"
+
+  local track_root=$( pwd )
+  pushd ${trackler}
+  git submodule init -- common
+  git submodule update
+
+  # Bake in local copy of this track; this is what we are testing.
+  rmdir tracks/${TRACK}
+  mkdir -p tracks/${TRACK}/exercises
+  cp ${track_root}/config.json tracks/${TRACK}
+  cp -r ${track_root}/exercises tracks/${TRACK}
+
+  # Set the version to that expected by x-api
+  version=$( grep -m 1 'trackler' ${xapi_home}/Gemfile.lock | sed 's/.*(//' | sed 's/)//' )
+  echo "module Trackler VERSION = \"${version}\" end" > lib/trackler/version.rb
+
+  gem install bundler
+  bundle install
+  gem build trackler.gemspec
+
+  # Make *this* the gem that x-api uses when we build x-api.
+  gem install --local trackler-*.gem
+
+  popd > /dev/null
+  echo "<<< make_local_trackler()"
+}
+
+start_x_api() {
+  local xapi_home="$1"
+  echo ">>> start_x_api(xapi_home=\"${xapi_home}\")"
+
+  pushd $xapi_home
+
+  gem install bundler
+  bundle install
+  RACK_ENV=development rackup &
+  xapi_pid=$!
+  sleep 5
+
+  echo "x-api is running (pid=${xapi_pid})."
+
+  popd > /dev/null
+  echo "<<< start_x_api()"
+}
+
+configure_exercism_cli() {
+  local exercism_home="$1"
+  local exercism_configfile="$2"
+  local xapi_port=$3
+  echo ">>> configure_exercism_cli(exercism_home=\"${exercism_home}\", exercism_configfile=\"${exercism_configfile}\", xapi_port=${xapi_port})"
+  local exercism="./exercism --config ${exercism_configfile}"
+
+  mkdir -p "${exercism_home}"
+  pushd "${exercism_home}"
+  $exercism configure --dir="${exercism_home}"
+  $exercism configure --api http://localhost:${xapi_port}
+  $exercism debug
+  popd
+
+  echo "<<< configure_exercism_cli()"
+}
+
+solve_all_exercises() {
+  local exercism_exercises_dir="$1"
+  local exercism_configfile="$2"
+  echo ">>> solve_all_exercises(exercism_exercises_dir=\"${exercism_exercises_dir}\", exercism_configfile=\"${exercism_configfile}\")"
+
+  local track_root=$( pwd )
+  local exercism_cli="./exercism --config ${exercism_configfile}"
+  local exercises=`cat config.json | jq '.exercises[] .slug' --raw-output`
+  local total_exercises=`cat config.json | jq '.exercises | length'`
+  local current_exercise_number=1
+  local tempfile="${TMPDIR:-/tmp}/journey-test.sh-unignore_all_tests.txt"
+
+  pushd ${exercism_exercises_dir}
+  for exercise in $exercises; do
+    echo -e "\n\n"
+    echo "=================================================="
+    echo "${current_exercise_number} of ${total_exercises} -- ${exercise}"
+    echo "=================================================="
+
+    ${exercism_cli} fetch ${TRACK} $exercise
+    cp -R -H ${track_root}/exercises/${exercise}/src/example/${TRACK}/* ${exercism_exercises_dir}/${TRACK}/${exercise}/src/main/${TRACK}/
+
+    pushd ${exercism_exercises_dir}/${TRACK}/${exercise}
+    # Ensure we run all the tests (as delivered, all but the first is @Ignore'd)
+    for testfile in `find . -name "*Test.${TRACK_SRC_EXT}"`; do
+      sed 's/@Ignore//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
+    done
+    gradle test
+    popd
+
+    current_exercise_number=$((current_exercise_number + 1))
+  done
+  popd
+}
+
+main() {
+  # all functions assume current working directory is repository root.
+  cd "${SCRIPTPATH}/.."
+
+  local track_root=$( pwd )
+  local build_dir="build"
+  local build_path="${track_root}/${build_dir}"
+
+  local xapi_home="${build_path}/x-api"
+  local trackler_home="${build_path}/trackler"
+  local exercism_home="${build_path}/exercism"
+
+  local exercism_configfile=".journey-test.exercism.json"
+  local xapi_port=9292
+
+  assert_installed "gradle"
+  assert_installed "jq"
+
+  clean "${build_dir}"
+
+  # Make a local version of trackler that includes the source from this repo.
+  git_clone "x-api" "${xapi_home}"
+  git_clone "trackler" "${trackler_home}"
+  assert_ruby_installed "${trackler_home}"
+  make_local_trackler "${trackler_home}" "${xapi_home}"
+
+  # Stand-up a local instance of x-api so we can fetch the exercises through it.
+  assert_ruby_installed "${xapi_home}"
+  start_x_api "${xapi_home}"
+
+  # Create a CLI install and config just for this build; this script does not use your CLI install.
+  download_exercism_cli $(get_operating_system) $(get_cpu_architecture) "${exercism_home}"
+  configure_exercism_cli "${exercism_home}" "${exercism_configfile}" "${xapi_port}"
+
+  solve_all_exercises "${exercism_home}" "${exercism_configfile}"
+}
+
+##########################################################################
+# Execution begins here...
+
+# If any command fails, fail the script.
+set -ex
+SCRIPTPATH=$( pushd `dirname $0` > /dev/null && pwd && popd > /dev/null )
+EXECPATH=$( pwd )
+# Make output easier to read in CI
+TERM=dumb
+
+xapi_pid=""
+trap on_exit EXIT
+main
+