Merge remote-tracking branch 'origin/main' into splain

Author: SethTisue

.drone.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: html-proofer
+    versions:
+    - "> 3.15.3"

.github/dependabot.yml

@@ -0,0 +1,32 @@
+name: Build
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.5.8
+          bundler-cache: true
+      - name: Set up coursier
+        uses: laughedelic/coursier-setup@v1
+        with:
+          jvm: adopt:11
+      - name: Run mdoc
+        run: |
+          ./scripts/run-mdoc.sh
+          rm -r /tmp/mdoc-out/
+      - name: Jekyll build
+        run: bundle exec jekyll build
+      - name: HTMLProofer
+        run: |
+          # # Checking for docs.scala-lang/blob/master leads to a chicken and egg problem because of the edit links of new pages.
+          bundle exec htmlproofer ./_site/\
+             --only-4xx\
+             --http-status-ignore "400,401,429"\
+             --empty-alt-ignore\
+             --allow-hash-href\
+             --url-ignore '/https://github.com/scala/docs.scala-lang/blob/master/.*/,/www.oracle.com/'
+

.github/workflows/build.yml

@@ -8,5 +8,4 @@ _site
 vendor/bundle
 .idea/
 /coursier
-/tut-tmp/
 .sass-cache/

.gitignore

@@ -0,0 +1,11 @@
+FROM ruby:2.5
+
+RUN gem install bundler jekyll
+
+WORKDIR /srv/jekyll
+
+COPY Gemfile .
+COPY Gemfile.lock .
+
+RUN bundle install
+

Dockerfile

@@ -45,7 +45,7 @@ GEM
       jekyll (~> 3.0)
     jekyll-watch (2.2.1)
       listen (~> 3.0)
-    kramdown (2.3.0)
+    kramdown (2.3.1)
       rexml
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
@@ -54,20 +54,22 @@ GEM
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     mercenary (0.3.6)
-    mini_portile2 (2.4.0)
-    nokogiri (1.10.10)
-      mini_portile2 (~> 2.4.0)
+    mini_portile2 (2.5.0)
+    nokogiri (1.11.1)
+      mini_portile2 (~> 2.5.0)
+      racc (~> 1.4)
     nokogumbo (2.0.2)
       nokogiri (~> 1.8, >= 1.8.4)
     parallel (1.19.2)
     pathutil (0.16.2)
       forwardable-extended (~> 2.6)
     public_suffix (4.0.5)
+    racc (1.5.2)
     rainbow (3.0.0)
     rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rexml (3.2.4)
+    rexml (3.2.5)
     rouge (3.22.0)
     safe_yaml (1.0.5)
     sass (3.7.4)

Gemfile.lock

@@ -15,7 +15,7 @@ Trejtovi i apstraktne klase mogu imati apstraktne tipove kao članove.
 To znači da konkretne implementacije definišu stvarni tip.
 Slijedi primjer:
 
-```tut
+```scala mdoc
 trait Buffer {
   type T
   val element: T
@@ -26,7 +26,7 @@ U gornjem primjeru smo definisali apstraktni tip `T`.
 On se koristi za opis člana `element`.
 Ovaj trejt možemo naslijediti u apstraktnoj klasi i dodati gornju granicu tipa za `T` da bi ga učinili preciznijim.
 
-```tut
+```scala mdoc
 abstract class SeqBuffer extends Buffer {
   type U
   type T <: Seq[U]
@@ -40,7 +40,7 @@ mora biti podtip `Seq[U]` za neki novi apstraktni tip `U`.
 Trejtovi ili [klase](classes.html) s apstraktnim tip-članovima se često koriste u kombinaciji s instanciranjem anonimnih klasa.
 Radi ilustracije, pogledaćemo program koji radi s sekvencijalnim baferom koji sadrži listu integera:
 
-```tut
+```scala mdoc
 abstract class IntSeqBuffer extends SeqBuffer {
   type U = Int
 }
@@ -61,7 +61,7 @@ Metoda `newIntSeqBuf` koristi anonimnu klasu kao implementaciju  `IntSeqBuf` pos
 Često je moguće pretvoriti apstraktni tip-član u tipski parametar klase i obrnuto.
 Slijedi verzija gornjeg koda koji koristi tipske parametre:
 
-```tut
+```scala mdoc:nest
 abstract class Buffer[+T] {
   val element: T
 }

_ba/tour/abstract-type-members.md

@@ -30,7 +30,7 @@ Redoslijed anotacijskih klauza nije bitan.
 Određene anotacije će uzrokovati pad kompajliranja ako određeni uslovi nisu ispunjeni. 
 Npr, anotacija `@tailrec` osigurava da je metoda [tail-rekurzivna](https://en.wikipedia.org/wiki/Tail_call). Tail-rekurzija može zadržati memorijske zahtjeve konstantnim. 
 Evo kako se koristi na metodi koja izračunava faktorijel:
-```tut
+```scala mdoc
 import scala.annotation.tailrec
 
 def factorial(x: Int): Int = {

_ba/tour/annotations.md

@@ -30,7 +30,7 @@ Izrazi su izjave koje imaju vrijednost.
 ```
 Rezultate izraza možete prikazati pomoću `println`.
 
-```tut
+```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
@@ -41,7 +41,7 @@ println("Hello," + " world!") // Hello, world!
 
 Rezultatima možete dodijeliti naziv pomoću ključne riječi `val`.
 
-```tut
+```scala mdoc
 val x = 1 + 1
 println(x) // 2
 ```
@@ -51,13 +51,13 @@ Referenciranje vrijednosti ne okida njeno ponovno izračunavanje.
 
 Vrijednosti se ne mogu mijenjati.
 
-```tut:fail
+```scala mdoc:fail
 x = 3 // Ovo se ne kompajlira.
 ```
 
 Tipovi vrijednosti mogu biti (automatski) zaključeni, ali možete i eksplicitno navesti tip:
 
-```tut
+```scala mdoc:nest
 val x: Int = 1 + 1
 ```
 
@@ -67,15 +67,15 @@ Primijetite da deklaracija tipa `Int` dolazi nakon identifikatora `x`. Također
 
 Varijable su kao vrijednosti, osim što ih možete promijeniti. Varijable se definišu ključnom riječju `var`.
 
-```tut
+```scala mdoc:nest
 var x = 1 + 1
 x = 3 // Ovo se kompajlira jer je "x" deklarisano s "var" ključnom riječju.
 println(x * x) // 9
 ```
 
 Kao i s vrijednostima, tip možete eksplicitno navesti ako želite:
 
-```tut
+```scala mdoc:nest
 var x: Int = 1 + 1
 ```
 
@@ -86,7 +86,7 @@ Izraze možete kombinovati okružujući ih s `{}`. Ovo se naziva blok.
 
 Rezultat zadnjeg izraza u bloku je rezultat cijelog bloka, također.
 
-```tut
+```scala mdoc
 println({
   val x = 1 + 1
   x + 1
@@ -99,29 +99,29 @@ Funkcije su izrazi koji primaju parametre.
 
 Možete definisati anonimnu funkciju (bez imena) koja vraća cijeli broj plus jedan:
 
-```tut
+```scala mdoc
 (x: Int) => x + 1
 ```
 
 Na lijevoj strani `=>` je lista parametara. Na desnoj strani je izraz koji koristi date parametre.
 
 Funkcije možete i imenovati.
 
-```tut
+```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
 
 Funkcije mogu imati više parametara.
 
-```tut
+```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
 
 Ili bez parametara.
 
-```tut
+```scala mdoc
 val getTheAnswer = () => 42
 println(getTheAnswer()) // 42
 ```
@@ -132,7 +132,7 @@ Metode izgledaju i ponašaju se vrlo slično funkcijama, ali postoji nekoliko ra
 
 Metode se definišu ključnom riječju `def`.  Nakon `def` slijedi naziv, lista parametara, povratni tip, i tijelo.
 
-```tut
+```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
@@ -141,14 +141,14 @@ Primijetite da je povratni tip deklarisan _nakon_ liste parametara i dvotačke `
 
 Metode mogu imati više listi parametara.
 
-```tut
+```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
 
 Ili bez listi parametara ikako.
 
-```tut
+```scala mdoc
 def name: String = System.getProperty("name")
 println("Hello, " + name + "!")
 ```
@@ -158,7 +158,7 @@ Postoje i neke druge razlike, ali zasad, možete misliti o njima kao nečemu sli
 Metode mogu imati višelinijske izraze također.
 
 {% scalafiddle %}
-```tut
+```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
   square.toString
@@ -173,7 +173,7 @@ Zadnjo izraz u tijelu metode je povratna vrijednost metode. (Scala ima ključnu
 
 Klasu možete definisati ključnom riječju `class` praćenom imenom i parametrima konstruktora.
 
-```tut
+```scala mdoc
 class Greeter(prefix: String, suffix: String) {
   def greet(name: String): Unit =
     println(prefix + name + suffix)
@@ -186,7 +186,7 @@ Ne prenosi nikakvu korisnu informaciju.)
 
 Instancu klase možete kreirati pomoću ključne riječi `new`.
 
-```tut
+```scala mdoc
 val greeter = new Greeter("Hello, ", "!")
 greeter.greet("Scala developer") // Hello, Scala developer!
 ```
@@ -198,21 +198,21 @@ Detaljniji pregled klasa biće dat [kasnije](classes.html).
 Scala ima poseban tip klase koji se zove "case" klasa.  
 Po defaultu, case klase su nepromjenjive i porede se po vrijednosti. Možete ih definisati s `case class` ključnim riječima.
 
-```tut
+```scala mdoc
 case class Point(x: Int, y: Int)
 ```
 
 Instancu case klase možete kreirati i bez ključne riječi `new`.
 
-```tut
+```scala mdoc
 val point = Point(1, 2)
 val anotherPoint = Point(1, 2)
 val yetAnotherPoint = Point(2, 2)
 ```
 
 I porede se po vrijednosti.
 
-```tut
+```scala mdoc
 if (point == anotherPoint) {
   println(point + " and " + anotherPoint + " are the same.")
 } else {
@@ -235,7 +235,7 @@ Objasnićemo ih u dubinu [kasnije](case-classes.html).
 Objekti su jedine instance svojih definicija. Možete misliti o njima kao singltonima svoje vlastite klase.
 Objekte možete definisati ključnom riječju `object`.
 
-```tut
+```scala mdoc
 object IdFactory {
   private var counter = 0
   def create(): Int = {
@@ -247,7 +247,7 @@ object IdFactory {
 
 Objektima možete pristupati referenciranjem njihovog imena.
 
-```tut
+```scala mdoc
 val newId: Int = IdFactory.create()
 println(newId) // 1
 val newerId: Int = IdFactory.create()
@@ -262,15 +262,15 @@ Trejtovi su tipovi koji sadrže polja i metode.  Više trejtova se može kombino
 
 Definišu se pomoću `trait` ključne riječi.
 
-```tut
+```scala mdoc:nest
 trait Greeter {
   def greet(name: String): Unit
 }
 ```
 
 Metode trejtova mogu imati defaultnu implementaciju.
 
-```tut
+```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
     println("Hello, " + name + "!")
@@ -279,7 +279,7 @@ trait Greeter {
 
 Možete naslijediti trejtove s `extends` ključnom riječi i redefinisati (override) implementacije s `override` ključnom riječi.
 
-```tut
+```scala mdoc
 class DefaultGreeter extends Greeter
 
 class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {
@@ -306,7 +306,7 @@ Java Virtuelna Mašina traži da se glavna metoda zove `main` i da prima jedan a
 
 Koristeći objekt, možete definisati glavnu metodu ovako:
 
-```tut
+```scala mdoc
 object Main {
   def main(args: Array[String]): Unit =
     println("Hello, Scala developer!")

_ba/tour/basics.md

@@ -13,15 +13,15 @@ previous-page: operators
 _By-name parametri_ (u slobodnom prevodu "po-imenu parametri") se izračunavaju samo kada se koriste. 
 Oni su kontrastu sa _by-value parametrima_ ("po-vrijednosti parametri"). 
 Da bi parametar bio pozivan by-name, dodajte `=>` prije njegovog tipa.
-```tut
+```scala mdoc
 def calculate(input: => Int) = input * 37
 ```
 By-name parametri imaju prednost da se ne izračunavaju ako se ne koriste u tijelu funkcije. 
 U drugu ruku, by-value parametri imaju prednost da se izračunavaju samo jednom.
 
 Ovo je primjer kako bi mogli implementirati while petlju:
 
-```tut
+```scala mdoc
 def whileLoop(condition: => Boolean)(body: => Unit): Unit =
   if (condition) {
     body