update docs

Author: t-bltg

docs/src/contributing.md

@@ -201,9 +201,11 @@ Navigate to the repo site (https://github.com/JuliaPlots/Plots.jl) and click the
 
 #### Set up the git remote
 
-Navigate to the local repo.  Note: I'm assuming that you do development in your Julia directory, and using Mac/Linux.  Adjust as needed.
+Navigate to the local repo.
+Note: I'm assuming that you do development in your Julia directory, and using Mac/Linux.
+Adjust as needed.
 
-```
+```bash
 cd ~/.julia/v0.5/Plots
 git remote add forked git@github.com:user123/Plots.jl.git
 ```
@@ -214,7 +216,7 @@ After running these commands, `git remote -v` should show two remotes: `origin`
 
 If you're just starting work on a new feature:
 
-```
+```bash
 git fetch origin
 git checkout master
 git merge --ff-only origin/master
@@ -228,7 +230,7 @@ The first three lines are meant to ensure you start from the main repo's master
 
 If you have an ongoing development branch (say, `user123-dev`) which you'd prefer to use (and which has previously been merged into master!) then you can get that up to date with:
 
-```
+```bash
 git fetch origin
 git checkout user123-dev
 git merge --ff-only origin/master
@@ -239,7 +241,7 @@ We update our local copy of origin, checkout the dev branch, then attempt to "fa
 
 #### Write code, and format
 
-Power up your favorite editor (maybe [Juno](https://junolab.org/)?) and make some code changes to the repo.
+Power up your favorite editor (maybe [Juno](https://junolab.org)?) and make some code changes to the repo.
 
 Format your changes (code style consistency) using:
 ```bash
@@ -250,12 +252,15 @@ $ julia -e 'using Runic; exit(Runic.main(ARGS))' -- --inplace .
 
 After applying changes, you'll want to "commit" or save a snapshot of all the changes you made.  After committing, you can "push" those changes to your forked repo on Github:
 
-```
+```bash
 git add src/my_new_file.jl
 git commit -am "my commit message"
 git push forked user123-dev
 ```
 
+`Plots` has some [pre-commit](https://pre-commit.com) hooks configuration set in order to enhance code quality.
+One can run the `pre-commit` checks using `pre-commit run --all-files`, they should be automatically ran when using `git commit` if installed.
+
 The first line is optional, and is used when adding new files to the repo.  The `-a` means "commit all my changes", and the `-m` lets you write a note about the commit (you should always do this, and hopefully make it descriptive).
 
 #### Submit a PR
@@ -268,7 +273,7 @@ Make sure the "base" branch is JuliaPlots `master` and the "compare" branch is `
 
 After all of this, you will likely want to go back to using `master` (or possibly using a tagged release, once your feature is tagged).  To clean up:
 
-```
+```bash
 git fetch origin
 git checkout master
 git merge --ff-only origin/master
@@ -311,7 +316,7 @@ From the Julia REPL, run `Pkg.test(name="Plots")`.  This will try to plot the te
 
 After the reference images have been updated, navigate to PlotReferenceImages and push the changes to Github:
 
-```
+```bash
 cd ~/.julia/v0.5/PlotReferenceImages
 git add Plots/*
 git commit -am "a useful message"

docs/src/ecosystem.md

@@ -73,8 +73,6 @@ In a paper, Tupper presents a method for graphing two-dimensional implicit equat
 
 ![](https://camo.githubusercontent.com/950ef704a0601ed9429addb35e6b7246ca5da149/687474703a2f2f692e696d6775722e636f6d2f4c4368547a43312e706e67)
 
-
-
 ## [ControlSystems](https://github.com/JuliaControl/ControlSystems.jl)
 
 A control systems design toolbox for Julia.  This toolbox works similar to that of other major computer-aided control systems design (CACSD) toolboxes. Systems can be created in either a transfer function or a state space representation. These systems can then be combined into larger architectures, simulated in both time and frequency domain, and analyzed for stability/performance properties.

docs/src/output.md

@@ -1,20 +1,16 @@
-
 # [Output](@id output)
 
-
 **A Plot is only displayed when returned** (a semicolon will suppress the return), or if explicitly displayed with `display(plt)`, `gui()`, or by adding `show = true` to your plot command.
 
 
 !!! tip
     You can have MATLAB-like interactive behavior by setting the default value: default(show = true)
 
 ### Standalone window
-
 Calling `gui(plt)` will open a standalone window.  `gui()`, like `plot!(...)`, applies to the "current" Plot.  Returning a Plot object to the REPL is like calling `gui(plt)`.
 
 
 ### Jupyter / IJulia
-
 Plots are shown inline when returned to a cell.  The default output format is `svg` for backends that support it.
 This can be changed by the `html_output_format` attribute, with alias `fmt`:
 
@@ -23,12 +19,10 @@ plot(rand(10), fmt = :png)
 ```
 
 ### Juno / Atom
-
 Plots are shown in the Atom PlotPane when possible, either when returned to the console or to an inline code block. At any time, the plot can be opened in a standalone window using the `gui()` command.
 The PlotPane can be disabled in Juno's settings.
 
 ### savefig / format
-
 Plots support 2 different versions per save-command.
 Command `savefig` chooses file type automatically based on the file extension.
 
@@ -48,15 +42,13 @@ png(plot_ref, filename_string) # save the fig referenced by plot_ref as png with
 ```
 
 #### File formats supported by most graphical backends
-
  - png (default output format for `savefig`, if no file extension is given)
  - svg
  - PDF
 
 When not using `savefig`, the default output format depends on the environment (e.g., when using IJulia/Jupyter).
 
 #### Supported output file formats
-
 Note:   not all backends support every output file format !
 A simple table showing which format is supported by which backend
 

docs/src/recipes.md

@@ -3,7 +3,6 @@ using Plots; gr()
 PlotsBase.reset_defaults()
 ```
 
-
 # [Recipes](@id recipes)
 
 Recipes are a way of defining visualizations in your own packages and code, without having to depend on Plots. The functionality relies on [RecipesBase](https://github.com/JuliaPlots/Plots.jl/tree/v2/RecipesBase), a super lightweight but powerful package which allows users to create advanced plotting logic without Plots.  The `@recipe` macro in RecipesBase will add a method definition for `RecipesBase.apply_recipe`.  Plots adds to and calls this same function, and so your package and Plots can communicate without ever knowing about the other.  Magic!
@@ -37,17 +36,13 @@ If `MyVec` was a subtype of AbstractVector, there would not be anything to do...
 
 Afterwards, all plot commands which work for vectors will also work for your datatype.
 
-
 ### Series Recipes
-
 Lets quickly discuss a mainstay of data visualization: the histogram.  Hadley Wickham has explored the nature of histograms as part of his [Layered Grammar of Graphics](https://vita.had.co.nz/papers/layered-grammar.pdf).  In it, he discusses how a histogram is really nothing more than a bar graph which has its data pre-binned.  This is true, and it can be taken further.  A bar-graph is really an extension of a step-graph, in which zeros are interwoven among the x-values.  A step-graph is really nothing more than a path (line) which can travel only horizontally or vertically.  Of course, a similar decomposition could be had by treating the bars as filled polygons.
 
 The point to be had is that a graphics package need only be able to draw lines and polygons, and they can support drawing a histogram.  The path from data to histogram is normally very complicated, but we can avoid the complexity and define a recipe to convert it to its subcomponents.  In a few lines of readable code, we can implement a key statistical visualization.  See the [tutorial on series recipes](https://github.com/tbreloff/ExamplePlots.jl/tree/master/notebooks/series_recipes.ipynb) for a better understanding of how you might use them.
 
 
-
 ## Recipe Types
-
 Above we described `Type recipes` and `Series Recipes`. In total there are four main types of recipes in Plots (listed in the order they are processed):
 
 - User Recipes

docs/src/tutorial.md

@@ -4,15 +4,13 @@ PlotsBase.reset_defaults()
 ```
 
 # [Tutorial](@id tutorial)
-
 This is a guide for getting you up and running with Plots.jl. Its main goal is
 to introduce you to the terminology used in the package, how to use Plots.jl in
 common use cases, and put you in a position to easily understand the rest of
 the manual. It is recommended that the code examples be followed inside
 the REPL or an interactive notebook.
 
 ## Basic Plotting: Line Plots
-
 After you have installed Plots.jl via `Pkg.add("Plots")`, the first step is to
 initialize the package. Depending on your computer, this will take a few seconds:
 
@@ -182,7 +180,6 @@ Note that `y3` is being plotted as a dotted line. This is distinct from a
 scatter plot of the data.
 
 ### Logarithmic Scale Plots
-
 Sometimes data needs to be plotted across orders of magnitude. The attributes
 `xscale` and `yscale` can be set to `:log10` in this case. They can also be
 set to `:identity` to keep them linear-scale.
@@ -205,7 +202,6 @@ More information about attributes can be found in the
 [Attributes](@ref attributes) section of the Manual.
 
 ### LaTeX Equation Strings
-
 Plots.jl works with LaTeXStrings.jl, a package that allows the user to type
 LaTeX equations in string literals. To install this, type in
 `Pkg.add("LaTeXStrings")`. The easiest way to use it is to prepend `L` to a
@@ -285,7 +281,6 @@ ylabel!("y")
 ```
 
 ## [Plotting Backends](@id plotting-backends)
-
 Plots.jl is a plotting metapackage: it's an interface over many different plotting libraries.
 What Plots.jl is actually doing is interpreting your commands and then
 generating the plots using another plotting library, called the **backend**.
@@ -344,7 +339,6 @@ For more information on backends, see the [backends page](@ref backends).
 For examples of plots from the various backends, see the Examples section.
 
 ## Plotting in Scripts
-
 At the start of the tutorial, we recommended following along the code examples
 in an interactive session for the following reason: try adding those same
 plotting commands to a script. Now call the script... and the plot doesn't
@@ -366,7 +360,6 @@ Finally, if we have a plot object `p`, we can type `display(p)` to
 display the plot.
 
 ## Combining Multiple Plots as Subplots
-
 We can combine multiple plots together as subplots using **layouts**.
 There are many methods for doing this, and we will show two simple methods
 for generating simple layouts. More advanced layouts are shown in the
@@ -413,7 +406,6 @@ individual plots, while the attribute `legend=false` in the final `plot`
 call is applied to all of the subplots.
 
 ## Plot Recipes and Recipe Libraries
-
 You now know all of the basic terminology of Plots.jl and can roam the
 documentation freely to become a plotting master. However, there is one
 thing left: **recipes**. Plotting recipes are extensions to the Plots.jl
@@ -442,7 +434,6 @@ Besides recipes, StatsPlots.jl also provides a specialized macro `@df` from plot
 directly from data tables.
 
 ### Using User Recipes
-
 A user recipe says how to interpret plotting commands on a new data type.
 In this case, StatsPlots.jl has a macro `@df` which allows you to plot
 a `DataFrame` directly by using the column names. Let's build a `DataFrame`
@@ -472,7 +463,6 @@ There's not much you have to do here: all of the commands from before
 ```
 
 ### Using a Type Recipe
-
 In addition, StatsPlots.jl extends Distributions.jl by adding a type recipe
 for its distribution types, so they can be directly interpreted as plotting
 data:
@@ -486,7 +476,6 @@ Type recipes are a very convenient way to plot a specialized type which
 requires no more intervention!
 
 ### Using Plot Recipes
-
 StatsPlots.jl adds the `marginhist` multiplot via a plot recipe. For our data,
 we will pull in the famous `iris` dataset from RDatasets:
 
@@ -507,7 +496,6 @@ Thus a plot recipe is not just a series, but also something like a new
 `plot` command.
 
 ### Using Series Recipes
-
 StatsPlots.jl also introduces new series recipes. The key is that you don't have
 to do anything differently. After `using StatsPlots`, you can simply use those
 new series recipes as though they were built into the plotting libraries. Let's
@@ -525,7 +513,6 @@ boxplot!(["Series 1" "Series 2" "Series 3" "Series 4"], y, legend=false)
 ```
 
 ## Additional Addons To Try
-
 Given the easy extendability of Plots.jl, there are many other things you can
 try. Here's a short list of very usable addons to check out: