Add Ruby2.5 runtime to runtimes manifest.

Update documentation with examples.

ansible/files/runtimes.json

@@ -133,6 +133,18 @@
                     "tag": "latest"
                 }
             }
+        ],
+        "ruby": [
+            {
+                "kind": "ruby:2.5",
+                "default": true,
+                "deprecated": false,
+                "image": {
+                    "prefix": "remore",
+                    "name": "openwhisk-runtime-ruby",
+                    "tag": "latest"
+                }
+            }
         ]
     },
     "blackboxes": [

docs/actions-ruby.md

@@ -0,0 +1,87 @@
+<!--
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+-->
+
+## Creating and invoking Ruby actions
+
+The process of creating Ruby actions is similar to that of [other actions](actions.md#the-basics).
+The following sections guide you through creating and invoking a single Ruby action,
+and demonstrate how to bundle multiple Ruby files and third party dependencies.
+
+Ruby actions are executed using Ruby 2.5. To use this runtime, specify the `wsk` CLI parameter
+`--kind ruby:2.5` when creating or updating an action. This is the default when creating an action
+with file that has a `.rb` extension.
+
+An action is simply a top-level Ruby method. For example, create a file called `hello.rb`
+with the following source code:
+
+```ruby
+def main(args)
+  name = args["name"] || "stranger"
+  greeting = "Hello #{name}!"
+  print greeting
+  { "greeting" => greeting }
+end
+```
+
+Ruby actions always consume a Hash and return a Hash.
+The entry method for the action is `main` by default but may be specified explicitly
+when creating the action with the `wsk` CLI using `--main`, as with any other action type.
+
+You can create an OpenWhisk action called `helloRuby` from this function as follows:
+
+```
+wsk action create helloRuby hello.rb
+```
+
+The CLI automatically infers the type of the action from the source file extension.
+For `.rb` source files, the action runs using a Ruby 2.5 runtime.
+
+Action invocation is the same for Ruby actions as it is for [any other action](actions.md#the-basics).
+
+```
+wsk action invoke --result helloRuby --param name World
+```
+
+```json
+{
+  "greeting": "Hello World!"
+}
+```
+
+Find out more about parameters in the [Working with parameters](./parameters.md) section.
+
+### Packaging Ruby actions in zip files
+
+You can package a Ruby action along with other files and dependent packages in a zip file.
+The filename of the source file containing the entry point (e.g., `main`) must be `main.rb`.
+For example, to create an action that includes a second file called `helper.rb`,
+first create an archive containing your source files:
+
+```bash
+zip -r hello_ruby.zip main.rb helper.rb
+```
+
+and then create the action:
+
+```bash
+wsk action create helloRuby --kind ruby:2.5 hello_ruby.zip
+```
+
+A few Ruby gems such as `mechanize` and `jwt` are available in addition to the default and bundled gems.
+You can use arbitrary gem so long as you use zipped actions to package all the dependencies.

docs/actions.md

@@ -54,13 +54,14 @@ the [Docker](docker-actions.md) action or [native binary](docker-actions.md#crea
 paths more suitable. Multiple actions may be composed together to create a longer processing pipeline called a
 [sequence](#creating-action-sequences). A more advanced form of composition is described [here](conductors.md).
 
-* [JavaScript](actions-node.md)
-* [Python](actions-python.md)
+* [Go](actions-go.md)
 * [Java](actions-java.md)
+* [JavaScript](actions-node.md)
 * [PHP](actions-php.md)
+* [Python](actions-python.md)
+* [Ruby](#creating-ruby-actions)
 * [Swift](actions-swift.md)
 * [Docker and native binaries](actions-docker.md)
-* [Go](actions-go.md)
 
 ## The basics
 

docs/parameters.md

@@ -25,7 +25,8 @@ This page outlines how to configure parameters when deploying packages and actio
 
 ### Passing parameters to an action at invoke time
 
-Parameters can be passed to the action when it is invoked. These examples use JavaScript but all the other languages work the same way (see documentation on [Swift actions](./actions.md#creating-swift-actions), [Python actions](./actions.mdcreating-python-actions), [Java actions](./actions.mdcreating-java-actions), [PHP actions](./actions.mdcreating-php-actions), [Docker actions](./actions.mdcreating-docker-actions) or [Go actions](./actions.mdcreating-go-actions) as appropriate for more detailed examples).
+Parameters can be passed to the action when it is invoked. These examples use JavaScript but all [the other
+languages](actions.md#languages-and-runtimes) work the same way.
 
 1. Use parameters in the action. For example, create 'hello.js' file with the following content:
 

tests/src/test/scala/common/rest/WskRest.scala

@@ -322,6 +322,9 @@ class WskRestAction
           case ".php" => {
             ("php:default", FileUtils.readFileToString(new File(artifactFile), StandardCharsets.UTF_8), artifactFile)
           }
+          case ".rb" => {
+            ("ruby:default", FileUtils.readFileToString(new File(artifactFile), StandardCharsets.UTF_8), artifactFile)
+          }
           case _ => ("", "", artifactFile)
         }
       }