trackler 2.0.8.7 → 2.0.8.8

data/tracks/elixir/exercises/all-your-base/all-your-base.exs

@@ -0,0 +1,10 @@
+defmodule AllYourBase do
+  @doc """
+  Given a number in base a, represented as a sequence of digits, converts it to base b,
+  or returns nil if either of the bases are less than 2
+  """
+
+  @spec convert(list, integer, integer) :: list
+  def convert(digits, base_a, base_b) do
+  end
+end

data/tracks/elixir/exercises/all-your-base/example.exs

@@ -0,0 +1,48 @@
+defmodule AllYourBase do
+
+  @doc """
+  Given a number in base a, represented as a sequence of digits, converts it to base b,
+  or returns nil if either of the bases are less than 2
+  """
+
+  @spec convert(list, integer, integer) :: list
+  def convert(digits, base_a, base_b) do
+    cond do
+      base_a > 1 and base_b > 1 and digits !=[] ->
+        do_convert(digits, base_a, base_b)
+      true ->
+        nil
+    end
+  end
+
+  defp do_convert(digits, base_a, base_b) do
+    num = convert_to_num(digits, base_a, 0)
+    case num do
+      nil -> nil
+      0 -> [0]
+      num -> convert_to_digits(num, base_b, [])
+      |> Enum.reverse
+    end
+  end
+
+  defp convert_to_num([head | tail], base_a, accumulator) do
+    cond do
+      head < base_a and head >= 0 ->
+         convert_to_num(tail, base_a, accumulator * base_a + head)
+      true ->
+        nil
+    end
+  end
+
+  defp convert_to_num([], _base_a, accumulator) do
+    accumulator
+  end
+
+  defp convert_to_digits(num, base_b, arr) when num > 0 do
+    convert_to_digits(div(num, base_b), base_b, arr ++ [rem(num, base_b)])
+  end
+
+  defp convert_to_digits(num, _base_b, arr) when num == 0 do
+    arr
+  end
+end

data/tracks/erlang/.gitignore

@@ -6,3 +6,4 @@ bin/configlet
 bin/configlet.exe
 _build/
 rebar.lock
+/build/

data/tracks/erlang/.travis.yml

@@ -6,11 +6,15 @@ otp_release:
 - 19.2
 install:
 - "./_test/bootstrap.sh"
+- rvm install 2.2.5
+- rvm use 2.2.5
 script:
 - configlet .
-- "./_test/check-exercises.escript"
+# - "./_test/check-exercises.escript"
+- "./bin/journey-test.sh"
 cache:
   - apt
+  - cache bundler
   - directories:
     - $HOME/bin
 

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

@@ -0,0 +1,264 @@
+#!/usr/bin/env bash
+
+assert_installed() {
+  local ok=0
+  for executable in $@; do
+    if [[ "`which $executable`" == "" ]]; then
+      echo "Missing executable: $executable"
+      ok=1
+    fi
+  done
+  if [[ "$ok" != "0" ]]; then exit $ok; fi
+}
+
+assert_ruby_installed() {
+  local app_home="$1"
+
+  pushd "${app_home}"
+  local current_ruby_ver=$(ruby --version | egrep --only-matching "[0-9]+\.[0-9]+\.[0-9]+")
+  local expected_rby_ver=$(cat Gemfile | awk -F\' '/ruby /{print $2}')
+  popd
+
+  if [[ "${expected_rby_ver}" != "" && "${current_ruby_ver}" != "${expected_rby_ver}" ]]; then
+    echo "${app_home} requires Ruby ${expected_rby_ver}; current Ruby version is ${current_ruby_ver}."
+    echo -e "Ruby used: `which ruby`.\n"
+    echo "PATH=${PATH}"
+    echo "aborting."
+    exit 1
+  fi
+}
+
+clean() {
+  local build_dir="$1"
+
+  # empty, absolute pathes, or parent references are considered dangerous to
+  # rm -rf against
+  if [[ "${build_dir}" == "" || "${build_dir}" =~ "^/" || "${build_dir}" =~ "\.\." ]]; then
+    echo "Value for build_dir (${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
+
+  for i in $(ls exercises); do
+    pushd exercises/$i
+    rm -rf _build deps rebar.lock
+    popd
+  done
+}
+
+git_clone() {
+  local repo_name="$1"
+  local dest_path="$2"
+
+  git clone "https://github.com/exercism/${repo_name}" "${dest_path}"
+}
+
+make_local_trackler() {
+  local trackler="$1"
+  local xapi_home="$2"
+
+  local xerlang=$(pwd)
+
+  pushd $trackler
+
+  git submodule init -- common
+  git submodule update
+
+  # Bake in local version of xerlang, this is what we are testing.
+  rmdir tracks/erlang
+  mkdir -p tracks/erlang/exercises
+  cp "${xerlang}/config.json" tracks/erlang
+  cp -r "${xerlang}/exercises" tracks/erlang
+
+  # Set 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
+
+  [[ $(which bundler) != "" ]] || gem install bundler
+  bundle install
+  gem build trackler.gemspec
+
+  # Make this the trackler that x-api will use when we build it
+  gem install --local "trackler-${version}.gem"
+  popd
+}
+
+start_x_api() {
+  local xapi_home="$1"
+
+  pushd "$xapi_home"
+
+  gem install bundler
+  bundle install
+  RACK_ENV=development rackup &
+  xapi_pid=$!
+  sleep 5
+
+  echo "x-api is running, pid is ${xapi_pid}."
+
+  popd
+}
+
+download_exercism_cli() {
+  local os="$1"
+  local arch="$2"
+  local exercism_home="$3"
+
+  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_suffix
+  local unzip_command
+  local unzip_from_file_option
+  if [[ ${os} == "windows" ]] ; then
+    download_url_suffix="zip"
+    unzip_command="unzip -d"
+    unzip_from_file_option=""
+  else
+    download_url_suffix="tgz"
+    unzip_command="tar xz -C"
+    unzip_from_file_option="-f"
+  fi
+  local download_url=${CLI_RELEASES}/download/${version}/exercism-${os}-${arch}.${download_url_suffix}
+
+  mkdir -p ${exercism_home}
+  local temp=`mktemp`
+  curl -s --location ${download_url} > ${temp}
+  ${unzip_command} ${exercism_home} ${unzip_from_file_option} ${temp}
+}
+
+configure_exercism_cli() {
+  local exercism_home="$1"
+  local exercism_config_file="$2"
+  local xapi_port=$3
+  local exercism="./exercism --config ${exercism_config_file}"
+
+  mkdir -p "${exercism_home}"
+  pushd "${exercism_home}"
+  $exercism configure --dir="${exercism_home}"
+  $exercism configure --api "http://localhost:${xapi_port}"
+  $exercism debug
+  popd
+}
+
+get_operating_system() {
+  case $(uname) in
+      (Darwin*)
+          echo "mac";;
+      (Linux*)
+          echo "linux";;
+      (Windows*)
+          echo "windows";;
+      (MINGW*)
+          echo "windows";;
+      (*)
+          echo "linux";;
+  esac
+}
+
+get_cpu_architecture() {
+  case $(uname -m) in
+      (*64*)
+          echo 64bit;;
+      (*686*)
+          echo 32bit;;
+      (*386*)
+          echo 32bit;;
+      (*)
+          echo 64bit;;
+  esac
+}
+
+solve_all_exercises() {
+  local exercism_exercises_dir="$1"
+  local exercism_configfile="$2"
+
+  local xerlang=$(pwd)
+  local exercism_cli="./exercism --config ${exercism_config_file}"
+  local exercises=$(ls exercises | sed 's|/||g')
+  local total_exercises=$(echo $exercises | wc -w)
+  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 erlang ${exercise}
+    local module=$(echo $exercise | sed s/-/_/g)
+    cat "${xerlang}/exercises/${exercise}/src/example.erl" \
+      | sed "s/-module(example)./-module(${module})./" \
+      > "${exercism_exercises_dir}/erlang/${exercise}/src/${module}.erl"
+
+    pushd "${exercism_exercises_dir}/erlang/${exercise}"
+    rebar3 eunit
+    popd
+
+    current_exercise_number=$((current_exercise_number + 1))
+  done
+}
+
+main() {
+  cd "${EXECPATH}"
+
+  local xerlang=$(pwd)
+  local build_dir="build"
+  local build_path="${xerlang}/${build_dir}"
+
+  local xapi_home="${build_path}/x-api"
+  local trackler_home="${build_path}/trackler"
+  local exercism_home="${build_path}/exercism"
+
+  local exercism_config_file=".journey-test.exercism.json"
+  local xapi_port=9292
+
+  # fail fast if required tools are missing
+  assert_installed "git" "erl" "rebar3"
+
+  # clean up old cruft
+  clean "${build_dir}"
+
+  # make a version of trackler containing this sources
+  git_clone "x-api" "${xapi_home}"
+  git_clone "trackler" "${trackler_home}"
+  assert_ruby_installed "${trackler_home}"
+  make_local_trackler "${trackler_home}" "${xapi_home}"
+
+  # Fire up the local x-api
+  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_config_file}" "${xapi_port}"
+
+  solve_all_exercises "${exercism_home}" "${exercism_config_file}"
+}
+
+# Show expanded commands
+set -ex
+
+# Determine path of this script as well as the current execution dir
+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

data/tracks/erlang/exercises/allergies/test/allergies_tests.erl

@@ -1,6 +1,6 @@
 -module(allergies_tests).
 
--define(TESTED_MODULE, (sut(accumulate))).
+-define(TESTED_MODULE, (sut(allergies))).
 -define(TEST_VERSION, 1).
 -include("exercism.hrl").
 

data/tracks/erlang/exercises/nucleotide-count/test/{dna_tests.erl → nucleotide_count_tests.erl}

@@ -1,6 +1,6 @@
--module(dna_tests).
+-module(nucleotide_count_tests).
 
--define(TESTED_MODULE, (sut(dna))).
+-define(TESTED_MODULE, (sut(nucleotide_count))).
 -define(TEST_VERSION, 1).
 -include("exercism.hrl").
 

data/tracks/erlang/exercises/parallel-letter-frequency/src/example.erl

@@ -1,4 +1,4 @@
--module( example ).
+-module(example).
 
 -export( [dict/1, test_version/0] ).
 

data/tracks/erlang/exercises/phone-number/test/{phone_tests.erl → phone_number_tests.erl}

@@ -1,6 +1,6 @@
--module(phone_tests).
+-module(phone_number_tests).
 
--define(TESTED_MODULE, (sut(phone))).
+-define(TESTED_MODULE, (sut(phone_number))).
 -define(TEST_VERSION, 1).
 -include("exercism.hrl").
 

data/tracks/erlang/exercises/robot-simulator/src/example.erl

@@ -1,4 +1,4 @@
--module( example ).
+-module(example).
 
 -export([advance/1,
          control/2,

data/tracks/erlang/exercises/scrabble-score/test/scrabble_score_tests.erl

@@ -1,6 +1,6 @@
 -module(scrabble_score_tests).
 
--define(TESTED_MODULE, (sut(scrabble))).
+-define(TESTED_MODULE, (sut(scrabble_score))).
 -define(TEST_VERSION, 1).
 -include("exercism.hrl").
 

data/tracks/erlang/exercises/series/src/example.erl

@@ -1,4 +1,4 @@
--module( example ).
+-module(example).
 
 -export( [from_string/2, test_version/0] ).
 

data/tracks/go/exercises/parallel-letter-frequency/example.go

@@ -1,5 +1,7 @@
 package letter
 
+const testVersion = 1
+
 func ConcurrentFrequency(l []string) FreqMap {
 	switch len(l) {
 	case 0:

data/tracks/go/exercises/parallel-letter-frequency/parallel_letter_frequency_test.go

@@ -5,6 +5,14 @@ import (
 	"testing"
 )
 
+const targetTestVersion = 1
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
 // In the separate file frequency.go, you are given a function, Frequency(),
 // to sequentially count letter frequencies in a single text.
 // Perform this exercise on parallelism using Go concurrency features.

data/tracks/go/exercises/pascals-triangle/example.go

@@ -1,5 +1,7 @@
 package pascal
 
+const testVersion = 1
+
 func Triangle(n int) (t [][]int) {
 	if n < 1 {
 		return

data/tracks/go/exercises/pascals-triangle/pascals_triangle_test.go

@@ -6,6 +6,8 @@ import (
 	"testing"
 )
 
+const targetTestVersion = 1
+
 var t20 = [][]int{
 	{1},
 	{1, 1},
@@ -29,6 +31,12 @@ var t20 = [][]int{
 	{1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1},
 }
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
 func TestTriangle(t *testing.T) {
 	for n := 1; n <= 20; n++ {
 		res := Triangle(n)