trackler 2.0.8.54 → 2.0.8.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a6d856796589e6ec9283fdeea16822bb1d5b28c
-  data.tar.gz: 05deca31a3c2e047dfd71ea9394515cc53d0e29c
+  metadata.gz: 350291aab0beae040bfec2a9a85f1e4faceac732
+  data.tar.gz: 00ecf8962d3f79bfff2872e5909644b808f80b8d
 SHA512:
-  metadata.gz: 7ad433ebb8407e7287226b652fbcc81a83ef4991e19516f4548437e8ee7e84d3c12653c77969e30f30591ca750df623441f0f8706bcc8d1c2b6631ca7b3f41c8
-  data.tar.gz: 995f196fbf184a1358774f0d2a817255afb271bd81a880770a4ae072abc830bf3b6cbc7add90deafe62e6d2efb80b5e44fc79a4d4775bbf3bbd14266e8065129
+  metadata.gz: b3ab8fa14033accfc8470e239b3319b0b62f5d0d7139887792cd4c6f0733c89c8493200ae93b2be108e4b9853a7e9be526f8bfcdd76cb93fd55fb7dd5d4f0810
+  data.tar.gz: b03ed5cb2599463588b8109f49a471fa744cd6447010d287c92f486b0b498419c067bb1599c7e66d503e04626e69e1c5e2cab83225740a97f11410b67ddcff04

data/README.md

@@ -93,6 +93,13 @@ gem build trackler.gemspec
 gem install --local trackler-$VERSION.gem
 gem push trackler-$VERSION.gem
 ```
+## Users
+
+Projects that make use of this gem:
+
+* https://github.com/exercism/exercism.io
+* https://github.com/exercism/x-api
+* https://github.com/sandimetz/99bottles-polyglot
 
 ## License
 

data/common/CONTRIBUTING.md

@@ -41,7 +41,7 @@ themselves. There are other guides about contributing to other parts of the Exer
     * [Pull Request Guidelines](#pull-request-guidelines)
     * [Exercise Versioning](#exercise-versioning)
     * [Anatomy of an Exercise](#anatomy-of-an-exercise)
-    * [config.json](#config-json)
+    * [Track configuration file (config.json)](#track-configuration-file)
     * [Track-Level Linting With Configlet](#track-level-linting-with-configlet)
     * [Git Basics](#git-basics)
         * [Getting the Code](#getting-the-code)
@@ -668,10 +668,11 @@ that the exercise is coherent.
 If you change the test suite, then make sure the reference solution is fixed
 to pass the updated tests.
 
-### config.json
+### Track configuration file
 
-Each language track has a `config.json` file. Important keys are:
+Each language track has a configuration file called `config.json`.
 
+Important keys are:
 * `problems` - actively served via `exercism fetch`
 * `deprecated` - implemented, but aren't served anymore
 * `foregone` - will not be implemented in the track
@@ -690,9 +691,9 @@ is useful. Ignored directories don't get flagged as unimplemented problems.
 A problem might be foregone for a number of reasons, typically because it's a
 bad exercise for the language.
 
-The `config.json` also has an optional `test_pattern` key. This is a regex that
-test filenames will match. If test files contain `/test/`, then this key can be
-deleted.
+Optional keys:
+* `test_pattern` - A (case sensitive) regex pattern that test filenames will match. It is used to determine which files will be visible on a problem's test-suite page on the exercism.io site. The default value used if this key is not present is `test` (note: this is case _insensitve_)
+* `ignore_pattern` - A (case insensitive) regex pattern that will cause files matching it to not be served to the student by `exercism fetch`. The default value used if this key is not present is `example`
 
 ### Track-Level Linting With Configlet
 

data/fixtures/tracks/animal/config.json

@@ -4,6 +4,7 @@
   "repository": "https://github.com/exercism/xanimal",
   "active": true,
   "test_pattern": "a.*animal",
+  "ignore_pattern": "[^_]example",
   "problems": [
     "dog"
   ],

data/fixtures/tracks/animal/exercises/dog/a_test_example_for.animal

@@ -0,0 +1 @@
+example test

data/lib/trackler/implementation.rb

@@ -4,30 +4,30 @@ require_relative 'file_bundle'
 module Trackler
   # Implementation is a language-specific implementation of an exercise.
   class Implementation
-    IGNORE = [
-      Regexp.new("HINTS\.md$"),
-      Regexp.new("example", Regexp::IGNORECASE),
-      Regexp.new("\/\.$"),
-      Regexp.new("/\.meta/")
+    IGNORE_PATTERNS = [
+      "\/HINTS\.md$",
+      "\/\.$",
+      "/\.meta/"
     ]
 
-    attr_reader :track_id, :repo, :problem, :root, :file_bundle
+    attr_reader :track, :problem
     attr_writer :files
-    def initialize(track_id, repo, problem, root)
-      @track_id = track_id
-      @repo = repo
+    def initialize(track, problem)
+      @track = track
       @problem = problem
-      @root = Pathname.new(root)
-      @file_bundle = FileBundle.new(track_directory, IGNORE)
+    end
+
+    def file_bundle
+      @file_bundle ||= FileBundle.new(implementation_dir, regexes_to_ignore)
     end
 
     def exists?
-      File.exist?(track_directory)
+      File.exist?(implementation_dir)
     end
 
     def files
       @files ||= Hash[file_bundle.paths.map {|path|
-        [path.relative_path_from(track_directory).to_s, File.read(path)]
+        [path.relative_path_from(implementation_dir).to_s, File.read(path)]
       }].merge("README.md" => readme)
     end
 
@@ -42,26 +42,28 @@ module Trackler
       @readme ||= assemble_readme
     end
 
-    def exercise_dir
-      if File.exist?(track_dir.join('exercises'))
-        File.join('exercises', problem.slug)
-      else
-        problem.slug
-      end
-    end
-
     def git_url
-      [repo, "tree/master", exercise_dir].join("/")
+      [track.repository, "tree/master", exercise_dir].join("/")
     end
 
     private
 
-    def track_directory
-      @track_directory ||= track_dir.join(exercise_dir)
+    def regexes_to_ignore
+      (IGNORE_PATTERNS + [@track.ignore_pattern]).map do |pattern|
+        Regexp.new(pattern, Regexp::IGNORECASE)
+      end
+    end
+
+    def implementation_dir
+      @implementation_dir ||= track.dir.join(exercise_dir)
     end
 
-    def track_dir
-      @track_dir ||= root.join('tracks', track_id)
+    def exercise_dir
+      if File.exist?(track.dir.join('exercises'))
+        File.join('exercises', problem.slug)
+      else
+        problem.slug
+      end
     end
 
     def assemble_readme
@@ -85,8 +87,8 @@ module Trackler
     def readme_body
       [
         problem.description,
-        implementation_hint,
-        track_hint,
+        implementation_hints,
+        track.hints,
       ].reject(&:empty?).join("\n").strip
     end
 
@@ -101,16 +103,8 @@ It's possible to submit an incomplete solution so you can see how others have co
       README
     end
 
-    def track_hint
-      track_hints_filename = track_dir.join('exercises','TRACK_HINTS.md')
-      unless File.exist?(track_hints_filename)
-        track_hints_filename = track_dir.join('SETUP.md')
-      end
-      read track_hints_filename
-    end
-
-    def implementation_hint
-      read File.join(track_directory, 'HINTS.md')
+    def implementation_hints
+      read File.join(implementation_dir, 'HINTS.md')
     end
 
     def read(f)

data/lib/trackler/implementations.rb

@@ -25,7 +25,7 @@ module Trackler
 
     def all
       @all ||= slugs.map { |slug|
-        Implementation.new(track.id, repo, Problem.new(slug, root, track), root)
+        Implementation.new(track, Problem.new(slug, root, track))
       }
     end
 
@@ -35,7 +35,7 @@ module Trackler
 
     def implementation_map
       hash = Hash.new { |_, k|
-        Implementation.new(track.id, repo, Problem.new(k, root, track), root)
+        Implementation.new(track, Problem.new(k, root, track))
       }
       all.each do |impl|
         hash[impl.problem.slug] = impl

data/lib/trackler/track.rb

@@ -81,6 +81,10 @@ module Trackler
       end
     end
 
+    def ignore_pattern
+      config.fetch('ignore_pattern', 'example')
+    end
+
     def docs(positional_image_path_which_is_deprecated = nil, image_path: nil)
       if positional_image_path_which_is_deprecated
         warn "DEPRECATION WARNING:\ntrack.docs: Positional argument is deprecated, please use keyword argument 'image_path:' instead\neg: track.docs(image_path: #{positional_image_path_which_is_deprecated.inspect})\n"
@@ -107,6 +111,18 @@ module Trackler
       active_slugs + foregone_slugs + deprecated_slugs
     end
 
+    def dir
+      root.join("tracks", id)
+    end
+
+    def hints
+      track_hints_filename = dir.join('exercises', 'TRACK_HINTS.md')
+      unless File.exist?(track_hints_filename)
+        track_hints_filename = dir.join('SETUP.md')
+      end
+      read track_hints_filename
+    end
+
     private
 
     # The slugs for the problems that are currently in the track.
@@ -139,10 +155,6 @@ module Trackler
       formats.max_by { |format| formats.count(format) }
     end
 
-    def dir
-      root.join("tracks", id)
-    end
-
     def config
       @config ||= JSON.parse(File.read(config_filename))
     end
@@ -187,5 +199,13 @@ module Trackler
     def png_icon
       @png_icon ||= Image.new(File.join(dir, "img/icon.png"))
     end
+
+    def read(f)
+      if File.exist?(f)
+        File.read(f)
+      else
+        ""
+      end
+    end
   end
 end

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.54"
+  VERSION = "2.0.8.55"
 end

data/tracks/elixir/config.json

@@ -220,6 +220,15 @@
       "topics": [
       ]
     },
+    {
+      "slug": "tournament",
+      "difficulty": 4,
+      "topics": [
+        "string processing",
+        "sorting",
+        "formatting"
+      ]
+    },
     {
       "slug": "list-ops",
       "difficulty": 4,
@@ -385,6 +394,14 @@
       "topics": [
       ]
     },
+    {
+      "slug": "simple-cipher",
+      "difficulty": 3,
+      "topics": [
+        "string processing",
+        "encryption"
+      ]
+    },
     {
       "slug": "bank-account",
       "difficulty": 7,

data/tracks/elixir/exercises/bracket-push/bracket_push_test.exs

@@ -9,57 +9,72 @@ defmodule BracketPushTest do
   use ExUnit.Case
 
   # @tag :pending
+  test "paired square brackets" do
+    assert BracketPush.check_brackets("[]")
+  end
+
+  @tag :pending
   test "empty string" do
     assert BracketPush.check_brackets("")
   end
 
   @tag :pending
-  test "appropriate bracketing in a set of brackets" do
-    assert BracketPush.check_brackets("{}")
+  test "unpaired brackets" do
+    refute BracketPush.check_brackets("[[")
   end
 
   @tag :pending
-  test "unclosed brackets" do
-    refute BracketPush.check_brackets("{{")
+  test "wrong ordered brackets" do
+    refute BracketPush.check_brackets("}{")
   end
 
   @tag :pending
-  test "more than one pair of brackets" do
-    assert BracketPush.check_brackets("{}[]")
+  test "wrong closing bracket" do
+    refute BracketPush.check_brackets("{]")
   end
 
   @tag :pending
-  test "brackets are out of order" do
-    refute BracketPush.check_brackets("}{")
+  test "paired with whitespace" do
+    assert BracketPush.check_brackets("{ }")
   end
 
   @tag :pending
-  test "nested brackets" do
-    assert BracketPush.check_brackets("{[()]}")
+  test "simple nested brackets" do
+    assert BracketPush.check_brackets("{[]}")
   end
 
   @tag :pending
-  test "unbalanced nested brackets" do
-    refute BracketPush.check_brackets("{[}]")
+  test "several paired brackets" do
+    assert BracketPush.check_brackets("{}[]")
   end
 
   @tag :pending
-  test "bracket closure with deeper nesting" do
+  test "paired and nested brackets" do
+    assert BracketPush.check_brackets("([{}({}[])])")
+  end
+
+  @tag :pending
+  test "unopened closing brackets" do
     refute BracketPush.check_brackets("{[)][]}")
   end
 
   @tag :pending
-  test "bracket closure in a long string of brackets" do
-    assert BracketPush.check_brackets("{[]([()])}")
+  test "unpaired and nested brackets" do
+    refute BracketPush.check_brackets("([{])")
+  end
+
+  @tag :pending
+  test "paired and wrong nested brackets" do
+    refute BracketPush.check_brackets("[({]})")
   end
 
   @tag :pending
-  test "should ignore non-bracket characters" do
-    assert BracketPush.check_brackets("{hello[]([a()])b}c")
+  test "math expression" do
+    assert BracketPush.check_brackets("(((185 + 223.85) * 15) - 543)/2")
   end
 
   @tag :pending
-  test "string with newlines" do
-    assert BracketPush.check_brackets("[]\n{()}\n[(({}))]\n")
+  test "complex latex expression" do
+    assert BracketPush.check_brackets("\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)")
   end
 end

data/tracks/elixir/exercises/saddle-points/example.exs

@@ -1,4 +1,4 @@
-defmodule Matrix do
+defmodule SaddlePoints do
   @doc """
   Parses a string representation of a matrix
   to a list of rows

data/tracks/elixir/exercises/saddle-points/saddle_points.exs

@@ -1,4 +1,4 @@
-defmodule Matrix do
+defmodule SaddlePoints do
   @doc """
   Parses a string representation of a matrix
   to a list of rows

data/tracks/elixir/exercises/saddle-points/saddle_points_test.exs

@@ -10,61 +10,61 @@ defmodule SaddlePointsTest do
 
   # @tag :pending
   test "extract rows" do
-    rows = Matrix.rows("1 2\n10 20")
+    rows = SaddlePoints.rows("1 2\n10 20")
     assert rows == [[1, 2], [10, 20]]
   end
 
   @tag :pending
   test "extract a row" do
-    rows = Matrix.rows("9 7\n8 6")
+    rows = SaddlePoints.rows("9 7\n8 6")
     assert Enum.at(rows, 0) == [9, 7]
   end
 
   @tag :pending
   test "extract other row" do
-    rows = Matrix.rows("9 8 7\n19 18 17")
+    rows = SaddlePoints.rows("9 8 7\n19 18 17")
     assert Enum.at(rows, 1) == [19, 18, 17]
   end
 
   @tag :pending
   test "extract other row again" do
-    rows = Matrix.rows("1 4 9\n16 25 36")
+    rows = SaddlePoints.rows("1 4 9\n16 25 36")
     assert Enum.at(rows, 1) == [16, 25, 36]
   end
 
   @tag :pending
   test "extract a column" do
-    columns = Matrix.columns("1 2 3\n4 5 6\n7 8 9\n8 7 6")
+    columns = SaddlePoints.columns("1 2 3\n4 5 6\n7 8 9\n8 7 6")
     assert Enum.at(columns, 0) == [1, 4, 7, 8]
   end
 
   @tag :pending
   test "extract another column" do
-    columns = Matrix.columns("89 1903 3\n18 3 1\n9 4 800")
+    columns = SaddlePoints.columns("89 1903 3\n18 3 1\n9 4 800")
     assert Enum.at(columns, 1) == [1903, 3, 4]
   end
 
   @tag :pending
   test "no saddle point" do
-    saddle_points = Matrix.saddle_points("2 1\n1 2")
+    saddle_points = SaddlePoints.saddle_points("2 1\n1 2")
     assert saddle_points == []
   end
 
   @tag :pending
   test "a saddle point" do
-    saddle_points = Matrix.saddle_points("1 2\n3 4")
+    saddle_points = SaddlePoints.saddle_points("1 2\n3 4")
     assert saddle_points == [{0, 1}]
   end
 
   @tag :pending
   test "another saddle point" do
-    saddle_points = Matrix.saddle_points("18 3 39 19 91\n38 10 8 77 320\n3 4 8 6 7")
+    saddle_points = SaddlePoints.saddle_points("18 3 39 19 91\n38 10 8 77 320\n3 4 8 6 7")
     assert saddle_points == [{2, 2}]
   end
 
   @tag :pending
   test "multiple saddle points" do
-    saddle_points = Matrix.saddle_points("4 5 4\n3 5 5\n1 5 4")
+    saddle_points = SaddlePoints.saddle_points("4 5 4\n3 5 5\n1 5 4")
     assert saddle_points == [{0, 1}, {1, 1}, {2, 1}]
   end
 end

data/tracks/elixir/exercises/simple-cipher/example.exs

@@ -0,0 +1,80 @@
+defmodule SimpleCipher do
+  @alphabet "abcdefghijklmnopqrstuvwxyz" |> String.graphemes
+  @alphabet_size @alphabet |> length
+
+  for key_char <- @alphabet do
+    shifted_alphabet = Stream.cycle(@alphabet)
+                       |> Stream.drop_while(&(&1 != key_char))
+                       |> Enum.take(@alphabet_size)
+
+    for { plain, cipher } <- Enum.zip(@alphabet, shifted_alphabet) do
+      defp encode_char(unquote(plain), unquote(key_char)), do: unquote(cipher)
+      defp decode_char(unquote(cipher), unquote(key_char)), do: unquote(plain)
+    end
+  end
+
+  defp encode_char(plain, _), do: plain
+  defp decode_char(cipher, _), do: cipher
+
+  defp encode_char({plain, key}), do: encode_char(plain, key)
+  defp decode_char({cipher, key}), do: decode_char(cipher, key)
+
+  @doc """
+  Given a `plaintext` and `key`, encode each character of the `plaintext` by
+  shifting it by the corresponding letter in the alphabet shifted by the number
+  of letters represented by the `key` character, repeating the `key` if it is
+  shorter than the `plaintext`.
+
+  For example, for the letter 'd', the alphabet is rotated to become:
+
+  defghijklmnopqrstuvwxyzabc
+
+  You would encode the `plaintext` by taking the current letter and mapping it
+  to the letter in the same position in this rotated alphabet.
+
+  abcdefghijklmnopqrstuvwxyz
+  defghijklmnopqrstuvwxyzabc
+
+  "a" becomes "d", "t" becomes "w", etc...
+
+  Each letter in the `plaintext` will be encoded with the alphabet of the `key`
+  character in the same position. If the `key` is shorter than the `plaintext`,
+  repeat the `key`.
+
+  Example:
+
+  plaintext = "testing"
+  key = "abc"
+
+  The key should repeat to become the same length as the text, becoming
+  "abcabca". If the key is longer than the text, only use as many letters of it
+  as are necessary.
+  """
+  def encode(plaintext, key) do
+    convert_keystream(plaintext, key, &encode_char/1)
+  end
+
+  @doc """
+  Given a `ciphertext` and `key`, decode each character of the `ciphertext` by
+  finding the corresponding letter in the alphabet shifted by the number of
+  letters represented by the `key` character, repeating the `key` if it is
+  shorter than the `ciphertext`.
+
+  The same rules for key length and shifted alphabets apply as in `encode/2`,
+  but you will go the opposite way, so "d" becomes "a", "w" becomes "t",
+  etc..., depending on how much you shift the alphabet.
+  """
+  def decode(ciphertext, key) do
+    convert_keystream(ciphertext, key, &decode_char/1)
+  end
+
+  defp convert_keystream(text, key, converter) do
+    keystream = key |> String.graphemes |> Stream.cycle
+
+    text
+    |> String.graphemes
+    |> Enum.zip(keystream)
+    |> Enum.map_join(converter)
+  end
+end
+

data/tracks/elixir/exercises/simple-cipher/simple_cipher.exs

@@ -0,0 +1,49 @@
+defmodule SimpleCipher do
+  @doc """
+  Given a `plaintext` and `key`, encode each character of the `plaintext` by
+  shifting it by the corresponding letter in the alphabet shifted by the number
+  of letters represented by the `key` character, repeating the `key` if it is
+  shorter than the `plaintext`.
+
+  For example, for the letter 'd', the alphabet is rotated to become:
+
+  defghijklmnopqrstuvwxyzabc
+
+  You would encode the `plaintext` by taking the current letter and mapping it
+  to the letter in the same position in this rotated alphabet.
+
+  abcdefghijklmnopqrstuvwxyz
+  defghijklmnopqrstuvwxyzabc
+
+  "a" becomes "d", "t" becomes "w", etc...
+
+  Each letter in the `plaintext` will be encoded with the alphabet of the `key`
+  character in the same position. If the `key` is shorter than the `plaintext`,
+  repeat the `key`.
+
+  Example:
+
+  plaintext = "testing"
+  key = "abc"
+
+  The key should repeat to become the same length as the text, becoming
+  "abcabca". If the key is longer than the text, only use as many letters of it
+  as are necessary.
+  """
+  def encode(plaintext, key) do
+  end
+
+  @doc """
+  Given a `ciphertext` and `key`, decode each character of the `ciphertext` by
+  finding the corresponding letter in the alphabet shifted by the number of
+  letters represented by the `key` character, repeating the `key` if it is
+  shorter than the `ciphertext`.
+
+  The same rules for key length and shifted alphabets apply as in `encode/2`,
+  but you will go the opposite way, so "d" becomes "a", "w" becomes "t",
+  etc..., depending on how much you shift the alphabet.
+  """
+  def decode(ciphertext, key) do
+  end
+end
+