RubyGems - trackler - Versions diffs - 2.2.1.22 → 2.2.1.23 - Mend

trackler 2.2.1.22 → 2.2.1.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (471) hide show

data/tracks/fsharp/docs/INSTALLATION.md CHANGED Viewed

@@ -1,53 +1,22 @@
-#### Mac
+### Installing .NET Core
-Install [Xamarin Studio](http://xamarin.com/download).
+The F# track is built on top of the [.NET Core](https://www.microsoft.com/net/core/platform) platform, which runs on Windows, Linux and macOS. To build .NET Core projects, you can use the .NET Core Command Line Interface (CLI). This CLI is part of the .NET Core SDK, which you can install by following the [installation instructions](https://www.microsoft.com/net/download/core). Note: the F# track requires SDK version 2.0 or greater.
-While Xamarin is most known for creating iOS and Android applications, it's still a perfect IDE to create F# console
-or library projects which is all that's needed for Exercism.
+After completing the installation, you can verify if the CLI was installed succesfully by running this command in a terminal:
-Once installed and running, you can validate the installation by starting Xamarin creating a new solution. On the left hand side select .NET, and on the right hand side select Library. Library should have a little button-shapped drop down box to it's right that says C#. Click it and you'll see you can also choose F#.
+```bash
+dotnet --version
+```
-<img alt="Xamarin New Projct" src="http://x.exercism.io/v3/tracks/fsharp/docs/img/xamarin-fsharp.jpg" style="width:100%; height: 100%;">
+It the output is a version greater than or equal to `2.0.0`, the .NET Core SDK has been installed succesfully.
-#### Linux
-The [F# Foundation](http://fsharp.org/) has detailed instructions on different options to install F# on [Linux](http://fsharp.org/use/linux/).
+### Using an IDE
-#### In Browser
-You can also create and share F# scripts in your browser at [Try F#](http://www.tryfsharp.org/Create). Silverlight plugin is required.
+If you want a more full-featured editing experience, you probably want to to use an IDE. These are the most popular IDE's that support building .NET Core projects:
-Can also try it out at [.NET Fiddle](https://dotnetfiddle.net/) which has the option of letting you bring in [NuGet](https://www.nuget.org/) packages.
-#### Windows
-Install [Visual Studio Express for Windows Desktop](http://www.visualstudio.com/downloads/download-visual-studio-vs#d-express-windows-desktop).
-Install the [F# tools for Visual Studio](http://www.microsoft.com/en-us/download/details.aspx?id=41654).
-You can either start by creating your own project for working with the Exercism problems or if you have a **paid version** of Visual Studio you can download a Visual Studio solution that is already set up to work on the problems in as many languages as Visual Studio supports.
-![Solution Explorer](/img/setup/visualstudio/SolutionExplorer.png)
-The following instructions are for using the Visual Studio template with a **paid version** of Visual Studio.
-By default, Visual Studio does not allow you to organize F# files by folder. This is a problem because Exercism fetches the exercises to sub-folders. To get around this, install the Visual [F# Power Tools extension](http://fsprojects.github.io/VisualFSharpPowerTools/) which enables folder organization and makes writing F# code much easier in Visual Studio.
-1. Download the [Exercism.io Visual Studio Template](https://github.com/rprouse/Exercism.VisualStudio) from GitHub by clicking the Download Zip button on the page.
-2. Unzip the template into your exercises directory, for example `C:\src\exercises`
-2. Install the [Exercism CLI](http://exercism.io/cli)
-3. Open a command prompt to your exercise directory
-4. Add your API key to exercism `exercism configure --key=YOUR_API_KEY`
-5. Configure your source directory in exercism `exercism configure --dir=C:\src\exercises`
-6. [Fetch your first exercise](http://exercism.io/how-it-works/newbie) `exercism fetch fsharp`
-7. Open the Exercism solution in Visual Studio
-8. Expand the Exercism.FSharp project
-9. Right click on the project and select **F# Power Tools | New Folder**. Enter the name for the **existing** exercise folder.
-10. Right click on the folder and select **Add | Existing item...** and select the problem files in the folder.
-11. Get coding...
-The NUnit NuGet package is included in the project, so you will not need to install it.
-Install the [NUnit Visual Studio Test Adapter](https://visualstudiogallery.msdn.microsoft.com/6ab922d0-21c0-4f06-ab5f-4ecd1fe7175d). This will allow you to run the tests from within Visual Studio. If you have ReSharper installed, you can also [run the tests using ReSharper](https://www.jetbrains.com/resharper/features/unit_testing.html).
-![Test Explorer](/img/setup/visualstudio/TestExplorer.png)
-You can also run the tests from the command line by installing [NUnit 3.0.x](http://www.nunit.org/). See the instructions for C#.
+* [Visual Studio 2017](https://www.visualstudio.com/downloads/) (version 15.3.1 and higher)
+* [Visual Studio Code](https://code.visualstudio.com/download) with the [Ionide-fsharp extension](https://marketplace.visualstudio.com/items?itemName=Ionide.Ionide-fsharp)
+* [Visual Studio for Mac](https://www.visualstudio.com/vs/visual-studio-mac/) (still in beta)
+* [Project Rider](https://www.jetbrains.com/rider/download/)
+Note: as the .NET Core project format differs significantly from earlier versions, older IDE's (like Visual Studio 2015 and Xamarin Studio) are not supported.

data/tracks/fsharp/docs/TESTS.md CHANGED Viewed

@@ -1,34 +1,21 @@
 ## Running Tests
-### Windows
-After installing Visual Studio Express for Windows Desktop and the F# tools run Visual Studio and it will display a start screen.
+To run the tests, execute the following command:
-Click on "New Project" and you should see an entry for Visual F# and click on "Class Library".
+```bash
+dotnet test
+```
-![New Project](http://x.exercism.io/v3/tracks/fsharp/docs/img/newProject.png)
+## Solving the exercise
-Install [NUnit](http://nunit.org/index.php?p=download) via NuGet package manager with the NUnit.Console package. This will add the reference to the project.
+Solving an exercise means making all its tests pass. By default, only one test (the first one) is executed when you run the tests. This is intentional, as it allows you to focus on just making that one test pass. Once it passes, you can enable the next test by removing `Skip = "Remove to run test"` from the test's `[<Fact>]` or `[<Theory>]` attribute. When all tests have been enabled and your implementation makes them all pass, you'll have solved the exercise!
-![NuGet Package Manager](http://x.exercism.io/v3/tracks/fsharp/docs/img/manageNugetPackages.png)
+To help you get started, each exercise comes with a stub implementation file. You can use this file as a starting point for building your solution. Feel free to remove or change this file if you think it is the right thing to do.
-![Installing NUnit](http://x.exercism.io/v3/tracks/fsharp/docs/img/installingNunit.png)
+## Using packages
-Drag and drop the test file of your chosen exercise into the project in Visual Studio. You can create your own Example file (or drag and drop the one included) and give the exercise a try.
+You should be able to solve most exercises without using any external packages. However, for the exercises where you do want to use an external package, you can add it to your project by running the following command:
-Compile the project (Build -> Build Solution or F7) to generate the DLL file.
-If you installed the NUnit runner through NuGet, the runner will be located in the ```\packages\NUnit.Console(version number)\tools``` folder where your project is.
-If you installed NUnit manually the runner will be in the ```Program Files (x86)\NUnit(version number)\bin``` folder.
-Once you have been able to compile the code it will create a DLL in the ```\bin\Debug``` folder of your project. In the NUnit runner, select "Open Project" and select the DLL that was created from compiling. This will load all the tests and allow you to run them.
-Now you can have fun learning F# and run your code against the tests!
-### Mac
-Xamarin Studio also ships with NUnit. From the new project dialog, just select an NUnit class library.
-<img alt="Xamarin NUnit" src=" http://x.exercism.io/v3/tracks/fsharp/docs/img/xamarin-fsharp-nunit.jpg" style="height: 100%; width: 100%;" />
-From here you can write NUnit tests right away. To run the tests open the `Unit Tests` pad within
-Xamarin (View -> Pads -> Unit Tests).
+```bash
+dotnet add package <package-name>
+```