trackler 2.2.1.33 → 2.2.1.34

data/tracks/csharp/exercises/clock/Example.cs

@@ -1,27 +1,30 @@
+using System;
+
 public struct Clock
 {
-    private readonly int hours;
-    private readonly int minutes;
-
     public Clock(int hours, int minutes = 0)
     {
-        this.hours = Mod((hours * 60 + minutes) / 60.0, 24);
-        this.minutes = Mod(minutes, 60);
+        Hours = Mod((hours * 60 + minutes) / 60.0, 24);
+        Minutes = Mod(minutes, 60);
     }
+    
+    public int Hours { get; }
+
+    public int Minutes { get; }
 
     public Clock Add(int minutesToAdd)
     {
-        return new Clock(hours, minutes + minutesToAdd);
+        return new Clock(Hours, Minutes + minutesToAdd);
     }
 
     public Clock Subtract(int minutesToSubtract)
     {
-        return new Clock(hours, minutes - minutesToSubtract);
+        return new Clock(Hours, Minutes - minutesToSubtract);
     }
 
     public override string ToString()
     {
-        return $"{hours:00}:{minutes:00}";
+        return $"{Hours:00}:{Minutes:00}";
     }
 
     private static int Mod(double x, double y)

data/tracks/csharp/generators/Exercises/Clock.cs

@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using Generators.Input;
+using Generators.Output;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class Clock : Exercise
+    {
+        private const string paramClock1 = "clock1";
+        private const string paramClock2 = "clock2";
+        private const string paramHour = "hour";
+        private const string paramMinute = "minute";
+
+        private const string propertyCreate = "create";
+        private const string propertyEqual = "equal";
+        private const string propertyEquals = "equals";
+        private const string propertyToString = "to_string";
+
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                if (canonicalDataCase.Property != propertyEqual)
+                {
+                    canonicalDataCase.ConstructorInput = new Dictionary<string, object>
+                    {
+                        [paramHour] = canonicalDataCase.Input[paramHour],
+                        [paramMinute] = canonicalDataCase.Input[paramMinute]
+                    };
+                }
+                else
+                {
+                    canonicalDataCase.ConstructorInput = ((JObject)canonicalDataCase.Input[paramClock1]).ToObject<Dictionary<string, object>>();
+                    canonicalDataCase.Input.Remove(paramClock1);
+
+                    var result = ((JObject)canonicalDataCase.Input[paramClock2]).ToObject<Dictionary<string, object>>();
+                    canonicalDataCase.Input[paramClock2] = new UnescapedValue($"new Clock({result[paramHour]}, {result[paramMinute]})");
+                }
+
+                if (canonicalDataCase.Property == propertyCreate)
+                {
+                    canonicalDataCase.Property = propertyToString;
+                }
+                else if (canonicalDataCase.Property == propertyEqual)
+                {
+                    canonicalDataCase.Property = propertyEquals;
+                }
+            }
+        }
+
+        protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
+        {
+            if (testMethodBody.CanonicalDataCase.Property == propertyEquals)
+            {
+                return base.RenderTestMethodBodyAssert(testMethodBody);
+            }
+            else if (testMethodBody.CanonicalDataCase.Property != propertyToString)
+            {
+                return RenderConsistencyToAssert(testMethodBody);
+            }
+            else
+            {
+                return base.RenderTestMethodBodyAssert(testMethodBody);
+            }
+        }
+
+        private static string RenderConsistencyToAssert(TestMethodBody testMethodBody)
+        {
+            var template = $"Assert.Equal({{{{ ExpectedParameter }}}}, {{{{ TestedValue }}}}.ToString());";
+
+            return TemplateRenderer.RenderInline(template, testMethodBody.AssertTemplateParameters);
+        }
+    }
+}

data/tracks/csharp/generators/Output/FormattingExtensions.cs

@@ -9,7 +9,6 @@ public static string EscapeSpecialCharacters(this string s)
                 .Replace("\t", "\\t")
                 .Replace("\r", "\\r")
                 .Replace("\"", "\\\"");
-                
 
         public static string Quote(this string s) => $"\"{s}\"";
     }

data/tracks/csharp/generators/Program.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.IO;
 using CommandLine;
 using Generators.Input;
@@ -18,7 +19,7 @@ public static int Main(string[] args)
                     .WithParsed(RegenerateTestClasses);
                 return 0;
             }
-            catch (Exception exception)
+            catch (Exception exception) when (!Debugger.IsAttached)
             {
                 Log.Error(exception, "Exception occured: {Message}", exception.Message);
                 return 1;

data/tracks/haskell/config.json

@@ -58,6 +58,16 @@
       "topics": [
       ]
     },
+    {
+      "uuid": "6eba4eac-8395-4ad6-ac21-3651a11ab4b4",
+      "slug": "collatz-conjecture",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "Maybe"
+      ]
+    },
     {
       "uuid": "85d77b8e-9b87-4d02-9fba-81f843bd66f1",
       "slug": "rna-transcription",

data/tracks/haskell/exercises/collatz-conjecture/README.md

@@ -0,0 +1,87 @@
+# Collatz Conjecture
+
+The Collatz Conjecture or 3x+1 problem can be summarized as follows:
+
+Take any positive integer n. If n is even, divide n by 2 to get n / 2. If n is
+odd, multiply n by 3 and add 1 to get 3n + 1. Repeat the process indefinitely.
+The conjecture states that no matter which number you start with, you will
+always reach 1 eventually.
+
+Given a number n, return the number of steps required to reach 1.
+
+## Examples
+Starting with n = 12, the steps would be as follows:
+
+0. 12
+1. 6
+2. 3
+3. 10
+4. 5
+5. 16
+6. 8
+7. 4
+8. 2
+9. 1
+
+Resulting in 9 steps. So for input n = 12, the return value would be 9.
+
+
+
+## Getting Started
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/haskell).
+
+## Running the tests
+
+To run the test suite, execute the following command:
+
+```bash
+stack test
+```
+
+#### If you get an error message like this...
+
+```
+No .cabal file found in directory
+```
+
+You are probably running an old stack version and need
+to upgrade it.
+
+#### Otherwise, if you get an error message like this...
+
+```
+No compiler found, expected minor version match with...
+Try running "stack setup" to install the correct GHC...
+```
+
+Just do as it says and it will download and install
+the correct compiler version:
+
+```bash
+stack setup
+```
+
+## Running *GHCi*
+
+If you want to play with your solution in GHCi, just run the command:
+
+```bash
+stack ghci
+```
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/haskell](https://github.com/exercism/haskell) repository on
+GitHub is the home for all of the Haskell exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue.  We'll do our best to help you!
+
+## Source
+
+An unsolved problem in mathematics named after mathematician Lothar Collatz [https://en.wikipedia.org/wiki/3x_%2B_1_problem](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/haskell/exercises/collatz-conjecture/examples/success-standard/package.yaml

@@ -0,0 +1,16 @@
+name: collatz-conjecture
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: CollatzConjecture
+  source-dirs: src
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - collatz-conjecture
+      - hspec

data/tracks/haskell/exercises/collatz-conjecture/examples/success-standard/src/CollatzConjecture.hs

@@ -0,0 +1,9 @@
+module CollatzConjecture (collatz) where
+
+collatzHelper :: Integer -> Integer -> Maybe Integer
+collatzHelper t x | x == 1    = Just t
+                  | even x    = collatzHelper (t+1) (x `div` 2)
+                  | otherwise = collatzHelper (t+1) (x*3 + 1)
+
+collatz :: Integer -> Maybe Integer
+collatz x = if x <= 0 then Nothing else collatzHelper 0 x

data/tracks/haskell/exercises/collatz-conjecture/package.yaml

@@ -0,0 +1,20 @@
+name: collatz-conjecture
+version: 1.1.1.1
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: CollatzConjecture
+  source-dirs: src
+  dependencies:
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - collatz-conjecture
+      - hspec

data/tracks/haskell/exercises/collatz-conjecture/src/CollatzConjecture.hs

@@ -0,0 +1,4 @@
+module CollatzConjecture (collatz) where
+
+collatz :: Integer -> Maybe Integer
+collatz = error "You need to implement this function."

data/tracks/haskell/exercises/collatz-conjecture/stack.yaml

@@ -0,0 +1 @@
+resolver: lts-8.21

data/tracks/haskell/exercises/collatz-conjecture/test/Tests.hs

@@ -0,0 +1,52 @@
+{-# OPTIONS_GHC -fno-warn-type-defaults #-}
+{-# LANGUAGE RecordWildCards #-}
+
+import Data.Foldable     (for_)
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import CollatzConjecture (collatz)
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = describe "collatz" $ for_ cases test
+  where
+
+    test Case{..} = it description assertion
+      where
+        assertion = collatz number `shouldBe` expected
+
+
+data Case = Case { description :: String
+                 , number      :: Integer
+                 , expected    :: Maybe Integer
+                 }
+
+cases :: [Case]
+cases = [ Case { description = "zero steps for one"
+               , number      = 1
+               , expected    = Just 0
+               }
+        , Case { description = "divide if even"
+               , number      = 16
+               , expected    = Just 4
+               }
+        , Case { description = "even and odd steps"
+               , number      = 12
+               , expected    = Just 9
+               }
+        , Case { description = "Large number of even and odd steps"
+               , number      = 1000000
+               , expected    = Just 152
+               }
+        , Case { description = "zero is an error"
+               , number      = 0
+               , expected    = Nothing
+               }
+        , Case { description = "negative value is an error"
+               , number      = -15
+               , expected    = Nothing
+               }
+        ]

data/tracks/idris/docs/SNIPPET.txt

@@ -0,0 +1,10 @@
+module EvenOdd
+
+data Even : Nat -> Type where
+  EZ : Even Z
+  ES : Even n -> Even (S (S n))
+
+total
+ee : Even n -> Even m -> Even (n + m)
+ee EZ m     = m
+ee (ES n) m = ES (ee n m)

data/tracks/rust/README.md

@@ -5,10 +5,91 @@
 
 Exercism exercises in Rust
 
-## Contributing Guide
+## Contributing
 
-Please see the [contributing guide](https://github.com/exercism/docs/tree/master/contributing-to-language-tracks)
+Thank you so much for contributing! :tada:
 
+Please read about how to [get involved in a track](https://github.com/exercism/docs/tree/master/contributing-to-language-tracks). Be sure to read the Exercism [Code of Conduct](https://github.com/exercism/exercism.io/blob/master/CODE_OF_CONDUCT.md).
+
+We welcome pull requests of all kinds. No contribution is too small.
+
+We encourage contributions that provide fixes and improvements to existing exercises. Please note that this track's exercises must conform to the Exercism-wide standards described in the [documentation](https://github.com/exercism/docs/tree/master/language-tracks/exercises). If you're unsure about how to make a change, then go ahead and open a GitHub issue, and we'll discuss it.
+
+## Exercise Tests
+
+At the most basic level, Exercism is all about the tests. You can read more about how we think about test suites in [the Exercism documentation](https://github.com/exercism/docs/blob/master/language-tracks/exercises/anatomy/test-suites.md).
+
+Test files should use the following format:
+
+```
+extern crate exercise_name;
+
+use exercise_name::*;
+
+#[test]
+fn test_descriptive_name() {
+    assert_eq!(exercise_function(1), 1);
+}
+
+#[test]
+#[ignore]
+fn test_second_and_past_tests_ignored() {
+    assert_ne!(exercise_function(1), 2);
+}
+```
+
+## Opening an Issue
+
+If you plan to make significant or breaking changes, please open an issue so we can discuss it first. If this is a discussion that is relevant to more than just the Rust track, please open an issue in [exercism/discussions](https://github.com/exercism/discussions/issues).
+
+## Submitting a Pull Request
+
+Pull requests should be focused on a single exercise, issue, or conceptually cohesive change. Please refer to Exercism's [pull request guidelines](https://github.com/exercism/docs/blob/master/contributing/pull-request-guidelines.md).
+
+Please follow the coding standards for Rust.  [rustfmt](https://github.com/nrc/rustfmt) may help with this
+and can be installed with `cargo install rustfmt`.
+
+### Verifying your Change
+
+Before submitting your pull request, you'll want to verify the changes in two ways:
+
+* Run all the tests for the Rust exercises
+* Run an Exercism-specific linter to verify the track
+
+All the tests for Rust exercises can be run from the top level of the repo with `_test/check-exercises.sh`. If you are on a Windows machine, there are additional [Windows-specific instructions](_test/WINDOWS_README.md) for running this.
+
+For the Exercism-specific linting, please see [the documentation](https://github.com/exercism/docs/blob/master/language-tracks/configuration/linting.md).
+
+## Contributing a New Exercise
+
+Please see the documentation about [adding new exercises](https://github.com/exercism/docs/blob/master/you-can-help/make-up-new-exercises.md).
+
+Note that:
+
+- Each exercise must stand on its own. Do not reference files outside the exercise directory. They will not be included when the user fetches the exercise.
+
+- Exercises must conform to the Exercism-wide standards described in [the documentation](https://github.com/exercism/docs/tree/master/language-tracks/exercises).
+
+- Each exercise should have:
+
+      exercises/exercise-name/
+                              tests/exercise-name.rs  <- a test suite
+                              src/lib.rs              <- an empty file or with exercise stubs
+                              example.rs              <- example solution that satisfies tests
+                              Cargo.toml              <- with version equal to exercise defintion
+                              Cargo.lock              <- Auto generated
+                              README.md               <- Instructions for the exercise (see notes below)
+
+- The stub file and test suite should use only the Rust core libraries. `Cargo.toml` should not list any external dependencies as we don't want to make the student assume required crates. If an `example.rs` uses external crates, include `Cargo-example.toml` so that `_tests/check-exercises.sh` can compile with these when testing.
+
+- If porting an existing exercise from problem-specifications that has a `canonical-data.json` file, use the version in `canonical-data.json` for that exercise as your `Cargo.toml` version.  Otherwise, use "0.0.0".
+
+- An exercise may contain `.meta/hints.md`.  This is optional and will appear after the normal exercise
+  instructions if present.  Rust is different in many ways from other languages.  This is a place where the differences required for Rust are explained.  If it is a large change, you may want to call this out as a comment at the top of `src/lib.rs`, so the user recognises to read this section before starting.
+
+- `README.md` may be [regenerated](https://github.com/exercism/docs/blob/master/maintaining-a-track/regenerating-exercise-readmes.md) from Exercism data. The generator will use the `description.md` from the exercise directory in the [problem-specifications repository](https://github.com/exercism/problem-specifications/tree/master/exercises), then any hints in `.meta/hints.md`, then the [Rust-specific instructions](https://github.com/exercism/rust/blob/master/config/exercise-readme-insert.md). The `## Source` section comes from the `metadata.yml` in the same directory.  Convention is that the description of the source remains text and the link is both name and hyperlink of the markdown link.
+
+- Be sure to add the exercise to an appropriate place in the `config.json` file.  The position in the file determines the order exercises are sent.   Generate a unique UUID for the exercise.  Current difficuly levels in use are 1, 4, 7 and 10.
 
 ## Rust icon
 The Rust Logo is created by the Mozilla Corporation, and has been released under the [Creative Commons Attribution 4.0 International license](https://creativecommons.org/licenses/by/4.0/).