Merge pull request #19 from tobyhodges/code_blocks

Code blocks

Author: mr-c

_episodes/02-1st-example.md

@@ -17,20 +17,22 @@ The simplest "hello world" program.  This accepts one input parameter, writes a
 
 
 *1st-tool.cwl*
-```
+~~~
 {% include cwl/1st-tool.cwl %}
-```
+~~~
+{: .source}
 
 Use a YAML object in a separate file to describe the input of a run:
 
 *echo-job.yml*
-```
+~~~
 {% include cwl/echo-job.yml %}
-```
+~~~
+{: .source}
 
 Now invoke `cwl-runner` with the tool wrapper and the input object on the command line:
 
-```
+~~~
 $ cwl-runner 1st-tool.cwl echo-job.yml
 [job 1st-tool.cwl] /tmp/tmpmM5S_1$ echo \
     'Hello world!'
@@ -39,36 +41,41 @@ Hello world!
 {}
 Final process status is success
 
-```
+~~~
+{: .output}
 
 What's going on here?  Let's break it down:
 
-```
+~~~
 cwlVersion: v1.0
 class: CommandLineTool
-```
+~~~
+{: .source}
 
 The `cwlVersion` field indicates the version of the CWL spec used by the document.  The `class` field indicates this document describes a command line tool.
 
-```
+~~~
 baseCommand: echo
-```
+~~~
+{: .source}
 
 The `baseCommand` provides the name of program that will actually run (`echo`)
 
-```
+~~~
 inputs:
   message:
     type: string
       inputBinding:
         position: 1
-```
+~~~
+{: .source}
 
 The `inputs` section describes the inputs of the tool.  This is a list of input parameters and each parameter includes an identifier, a data type, and optionally an `inputBinding` which describes how this input parameter should appear on the command line.  In this example, the `position` field indicates where it should appear on the command line.
 
-```
+~~~
 outputs: []
-```
+~~~
+{: .source}
 
 This tool has no formal output, so the `outputs` section is an empty list.
 

_episodes/03-input.md

@@ -34,17 +34,18 @@ types and appearing on the command line in different ways:
 
 *inp-job.yml*
 
-```
+~~~
 {% include cwl/inp-job.yml %}
-```
+~~~
+{: .source}
 
 Notice that "example_file", as a `File` type, must be provided as an
 object with the fields `class: File` and `path`.
 
 Next, create a whale.txt and invoke `cwl-runner` with the tool wrapper and the
 input object on the command line:
 
-```
+~~~
 $ touch whale.txt
 $ cwl-runner inp.cwl inp-job.yml
 [job inp.cwl] /tmp/tmpzrSnfX$ echo \
@@ -57,7 +58,8 @@ $ cwl-runner inp.cwl inp-job.yml
 [job inp.cwl] completed success
 {}
 Final process status is success
-```
+~~~
+{: .output}
 > ## Where did those `/tmp` paths come from?
 >
 > The CWL reference runner (cwltool) and other runners create temporary
@@ -71,54 +73,58 @@ input parameter should be appear on the tool's command line.  If
 `inputBinding` is missing, the parameter does not appear on the command
 line.  Let's look at each example in detail.
 
-```
+~~~
 example_flag:
   type: boolean
   inputBinding:
     position: 1
     prefix: -f
-```
+~~~
+{: .source}
 
 Boolean types are treated as a flag.  If the input parameter
 "example_flag" is "true", then `prefix` will be added to the
 command line.  If false, no flag is added.
 
-```
+~~~
 example_string:
   type: string
   inputBinding:
     position: 3
     prefix: --example-string
-```
+~~~
+{: .source}
 
 String types appear on the command line as literal values.  The `prefix`
 is optional, if provided, it appears as a separate argument on the
 command line before the parameter .  In the example above, this is
 rendered as `--example-string hello`.
 
-```
+~~~
 example_int:
   type: int
   inputBinding:
     position: 2
     prefix: -i
     separate: false
-```
+~~~
+{: .source}
 
 Integer (and floating point) types appear on the command line with
 decimal text representation.  When the option `separate` is false (the
 default value is true), the prefix and value are combined into a single
 argument.  In the example above, this is rendered as `-i42`.
 
 
-```
+~~~
 example_file:
   type: File?
   inputBinding:
     prefix: --file=
     separate: false
     position: 4
-```
+~~~
+{: .source}
 
 File types appear on the command line as the path to the file.  When the
 parameter type ends with a question mark `?` it indicates that the

_episodes/04-output.md

@@ -25,20 +25,22 @@ themselves, or come from examining the content of those files.
 
 *tar.cwl*
 
-```
+~~~
 {% include cwl/tar.cwl %}
-```
+~~~
+{: .source}
 
 *tar-job.yml*
 
-```
+~~~
 {% include cwl/tar-job.yml %}
-```
+~~~
+{: .source}
 
 Next, create a tar file for the example and invoke `cwl-runner` with the tool
 wrapper and the input object on the command line:
 
-```
+~~~
 $ touch hello.txt && tar -cvf hello.tar hello.txt
 $ cwl-runner tar.cwl tar-job.yml
 [job tar.cwl] /tmp/tmpqOeawQ$ tar \
@@ -47,29 +49,31 @@ $ cwl-runner tar.cwl tar-job.yml
 [job tar.cwl] completed success
 {
     "example_out": {
-        "checksum": "sha1$da39a3ee5e6b4b0d3255bfef95601890afd80709", 
-        "basename": "hello.txt", 
-        "nameroot": "hello", 
-        "nameext": ".txt", 
-        "location": "file:///home/me/cwl/user_guide/hello.txt", 
-        "path": "/home/me/cwl/user_guide/hello.txt", 
-        "class": "File", 
+        "checksum": "sha1$da39a3ee5e6b4b0d3255bfef95601890afd80709",
+        "basename": "hello.txt",
+        "nameroot": "hello",
+        "nameext": ".txt",
+        "location": "file:///home/me/cwl/user_guide/hello.txt",
+        "path": "/home/me/cwl/user_guide/hello.txt",
+        "class": "File",
         "size": 0
     }
 }
 Final process status is success
-```
+~~~
+{: .output}
 
 The field `outputBinding` describes how to to set the value of each
 output parameter.
 
-```
+~~~
 outputs:
   example_out:
     type: File
     outputBinding:
       glob: hello.txt
-```
+~~~
+{: .source}
 
 The `glob` field consists of the name of a file in the output directory.
 If you don't know name of the file in advance, you can use a wildcard pattern like `*.txt`.

_episodes/05-stdout.md

@@ -16,20 +16,22 @@ stdout` on the corresponding output parameter.
 
 *stdout.cwl*
 
-```
+~~~
 {% include cwl/stdout.cwl %}
-```
+~~~
+{: .source}
 
 *echo-job.yml*
 
-```
+~~~
 {% include cwl/echo-job.yml %}
-```
+~~~
+{: .source}
 
 Now invoke `cwl-runner` providing the tool wrapper and the input object
 on the command line:
 
-```
+~~~
 $ cwl-runner stdout.cwl echo-job.yml
 [job stdout.cwl] /tmp/tmpE0gTz7$ echo \
     'Hello world!' > /tmp/tmpE0gTz7/output.txt
@@ -48,4 +50,5 @@ $ cwl-runner stdout.cwl echo-job.yml
 }
 Final process status is success
 
-```
+~~~
+{: .output}

_episodes/06-params.md

@@ -18,20 +18,22 @@ fields.
 
 *tar-param.cwl*
 
-```
+~~~
 {% include cwl/tar-param.cwl %}
-```
+~~~
+{: .source}
 
 *tar-param-job.yml*
 
-```
+~~~
 {% include cwl/tar-param-job.yml %}
-```
+~~~
+{: .source}
 
 Create your input files and invoke `cwl-runner` with the tool wrapper and the
 input object on the command line:
 
-```
+~~~
 $ rm hello.tar || true && touch goodbye.txt && tar -cvf hello.tar goodbye.txt
 $ cwl-runner tar-param.cwl tar-param-job.yml
 [job tar-param.cwl] /tmp/tmpwH4ouT$ tar \
@@ -41,29 +43,31 @@ $ cwl-runner tar-param.cwl tar-param-job.yml
 [job tar-param.cwl] completed success
 {
     "example_out": {
-        "checksum": "sha1$da39a3ee5e6b4b0d3255bfef95601890afd80709", 
-        "basename": "goodbye.txt", 
-        "nameroot": "goodbye", 
-        "nameext": ".txt", 
-        "location": "file:///home/me/cwl/user_guide/goodbye.txt", 
-        "path": "/home/me/cwl/user_guide/goodbye.txt", 
-        "class": "File", 
+        "checksum": "sha1$da39a3ee5e6b4b0d3255bfef95601890afd80709",
+        "basename": "goodbye.txt",
+        "nameroot": "goodbye",
+        "nameext": ".txt",
+        "location": "file:///home/me/cwl/user_guide/goodbye.txt",
+        "path": "/home/me/cwl/user_guide/goodbye.txt",
+        "class": "File",
         "size": 0
     }
 }
 Final process status is success
-```
+~~~
+{: .output}
 
 Certain fields permit parameter references which are enclosed in `$(...)`.
 These are evaluated and replaced with value being referenced.
 
-```
+~~~
 outputs:
   example_out:
     type: File
     outputBinding:
       glob: $(inputs.extractfile)
-```
+~~~
+{: .source}
 
 References are written using a subset of Javascript syntax.  In this
 example, `$(inputs.extractfile)`, `$(inputs["extractfile"])`, and

_episodes/07-containers.md

@@ -26,20 +26,22 @@ This example runs a simple Node.js script inside a Docker container.
 
 *docker.cwl*
 
-```
+~~~
 {% include cwl/docker.cwl %}
-```
+~~~
+{: .source}
 
 *docker-job.yml*
 
-```
+~~~
 {% include cwl/docker-job.yml %}
-```
+~~~
+{: .source}
 
 Provide a "hello.js" and invoke `cwl-runner` providing the tool wrapper and the
 input object on the command line:
 
-```
+~~~
 $ echo "console.log(\"Hello World\");" > hello.js
 $ cwl-runner docker.cwl docker-job.yml
 [job docker.cwl] /tmp/tmpgugLND$ docker \
@@ -61,7 +63,8 @@ Hello World
 [job docker.cwl] completed success
 {}
 Final process status is success
-```
+~~~
+{: .output}
 
 Notice the CWL runner has constructed a Docker command line to run the
 script.  One of the responsibilities of the CWL runner is to adjust the paths of