rasti-web 2.1.0 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 250a8b04a93b51665f10b49206453b490ffc83c81b8684ca466d4259ea23e75a
-  data.tar.gz: 9c32ed8ab0506cb4a4b407bb50fa6f12dc19bafc457e05181f18ba16ad9c5032
+  metadata.gz: 1541343e4a1c27d8f1679115b89a127f4821f586d33d42e6b2f8233b888f31c5
+  data.tar.gz: 212b77d8585d2838f6c04c88398630ea8262285d951e3d491e7761d09242bc90
 SHA512:
-  metadata.gz: f30ddbfed0f369d8eb9bcabe5e43b2a9891b9a53d3be55bbe3b4d492cf1724984e25b6a1ca91285879bedc14b8ec691525a345bf62dff48cc72f2d47eab80a8f
-  data.tar.gz: 120e466b7433332064adcc6ebfaf8cfc337433221954fddeb867a91cc801e53e8856a1b00a331c6867a1845d3c248f9febe1ac24a4e1864d3cd08ec511d3326d
+  metadata.gz: 144031ae6422daf22ced72d427f131f234ff5fa4ee7fbfa61d09082ec2bab7ded8bc06911a33046e19b4277acad99753e63a3a18b666785f3c6f4d73b4e02925
+  data.tar.gz: 84f51ba02b4f959a0cad86d11986ee55bc977650fb3641df87a5d86b14aebbc36a63def74a801867af89eb604ac4e49f32a671f671a85b0b3f140cd9324c08ef

data/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+    branches: [ '**' ]
+  pull_request:
+    branches: [ '**' ]
+
+jobs:
+  test:
+
+    name: Tests
+    runs-on: ubuntu-20.04
+    strategy:
+      matrix:
+        ruby-version: ['2.3', '2.4', '2.5', '2.6', '2.7', '3.0', '3.1', '3.2', 'jruby-9.2.9.0']
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Run tests
+      run: bundle exec rake

data/README.md

@@ -1,11 +1,26 @@
 # Rasti::Web
 
 [![Gem Version](https://badge.fury.io/rb/rasti-web.svg)](https://rubygems.org/gems/rasti-web)
-[![Build Status](https://travis-ci.org/gabynaiman/rasti-web.svg?branch=master)](https://travis-ci.org/gabynaiman/rasti-web)
-[![Coverage Status](https://coveralls.io/repos/gabynaiman/rasti-web/badge.svg?branch=master)](https://coveralls.io/r/gabynaiman/rasti-web?branch=master)
-[![Code Climate](https://codeclimate.com/github/gabynaiman/rasti-web.svg)](https://codeclimate.com/github/gabynaiman/rasti-web)
+[![CI](https://github.com/gabynaiman/rasti-web/actions/workflows/ci.yml/badge.svg)](https://github.com/gabynaiman/rasti-web/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/github/gabynaiman/rasti-web/badge.svg?branch=master)](https://coveralls.io/github/gabynaiman/rasti-web?branch=master)
 
-Web blocks to build robust applications
+**Rasti::Web** is a lightweight, modular web framework built on top of [Rack](https://github.com/rack/rack). It provides essential building blocks for creating robust web applications without imposing too much structure.
+
+## Key Features
+
+- **Simplicity**: Minimalist and easy-to-understand API
+- **Flexibility**: Direct access to Rack primitives for full control over the request/response cycle
+- **Powerful rendering**: Support for multiple formats (HTML, JSON, JavaScript, CSS, files, etc.)
+- **Advanced routing**: Static, parameterized, optional, and wildcard routes
+- **Template system**: ERB integration for views, layouts, and partials
+- **Error handling**: Hooks system and rescue_from for exception management
+
+## Use Cases
+
+- Building REST APIs
+- Full web applications
+- Microservices
+- Applications requiring fine-grained control over the request/response cycle
 
 ## Installation
 
@@ -23,36 +38,206 @@ Or install it yourself as:
 
 ## Usage
 
+### Application
+
+#### Basic definition
+
+```ruby
+class WebApp < Rasti::Web::Application
+
+  get '/' do |request, response, render|
+    render.html 'Welcome'
+  end
+
+end
+```
+
+#### Middleware
+
+```ruby
+class WebApp < Rasti::Web::Application
+
+  use Rack::Session::Cookie, secret: 'my_secret'
+  use SomeCustomMiddleware
+
+  get '/private' do |request, response, render|
+    render.html 'Private content'
+  end
+
+end
+```
+
+#### Mounting sub-applications
+
+```ruby
+class ApiApp < Rasti::Web::Application
+  get '/resource/:id' do |request, response, render|
+    render.json id: request.params['id'].to_i
+  end
+end
+
+class WebApp < Rasti::Web::Application
+  map '/api', ApiApp
+  
+  get '/' do |request, response, render|
+    render.html 'Home'
+  end
+end
+```
+
+#### Custom not_found handler
+
+```ruby
+class WebApp < Rasti::Web::Application
+
+  get '/' do |request, response, render|
+    render.html 'Home'
+  end
+
+  not_found do |request, response, render|
+    render.status 404, 'Page not found'
+  end
+
+end
+```
+
+#### Listing routes
+
+```ruby
+WebApp.all_routes
+# => {'GET' => ['/'], 'POST' => ['/users']}
+```
+
 ### Routing
 
+#### HTTP Verbs
+
+Rasti::Web supports all standard HTTP verbs:
+
 ```ruby
-# app.rb
 class WebApp < Rasti::Web::Application
 
-  use SomeMiddleware
+  get '/resources' do |request, response, render|
+    render.json resources: Resource.all
+  end
 
-  get '/hello' do |request, response, render|
-    render.text 'world'
+  post '/resources' do |request, response, render|
+    resource = Resource.create(request.params)
+    render.json resource, 201
   end
 
-  put '/users/:id', UsersController >> :update
+  put '/resources/:id' do |request, response, render|
+    resource = Resource.update(request.params[:id], request.params)
+    render.json resource
+  end
+
+  patch '/resources/:id' do |request, response, render|
+    resource = Resource.patch(request.params[:id], request.params)
+    render.json resource
+  end
+
+  delete '/resources/:id' do |request, response, render|
+    Resource.delete(request.params[:id])
+    render.status 204
+  end
+
+  head '/resources/:id' do |request, response, render|
+    render.status Resource.exists?(request.params[:id]) ? 200 : 404
+  end
+
+  options '/resources' do |request, response, render|
+    render.status 200, 'Allow' => 'GET, POST, OPTIONS'
+  end
 
 end
+```
 
-# configu.ru
-require_relative 'app'
-run WebApp
+#### Static routes
+
+```ruby
+get '/about' do |request, response, render|
+  render.html 'About page'
+end
+```
+
+#### Parameterized routes
+
+```ruby
+get '/users/:id' do |request, response, render|
+  user = User.find(request.params[:id])
+  render.json user
+end
+
+get '/posts/:post_id/comments/:id' do |request, response, render|
+  comment = Comment.find(request.params[:id], post_id: request.params[:post_id])
+  render.json comment
+end
+```
+
+#### Optional parameters
+
+```ruby
+# Matches: /resource, /resource/123, /resource/123/edit
+get '/:resource(/:id(/:action))' do |request, response, render|
+  render.json(
+    resource: request.params[:resource],
+    id: request.params[:id],
+    action: request.params[:action]
+  )
+end
+```
+
+#### Wildcard routes
+
+```ruby
+# Wildcard at the beginning: /*/files/download
+get '/*/files/download' do |request, response, render|
+  path = request.params[:wildcard]  # "users/documents"
+  render.file File.join(path, 'file.zip')
+end
+
+# Wildcard in the middle: /files/*/download
+get '/files/*/download' do |request, response, render|
+  path = request.params[:wildcard]
+  render.file File.join('files', path, 'download.zip')
+end
+
+# Wildcard at the end: /files/*
+get '/files/*' do |request, response, render|
+  path = request.params[:wildcard]
+  render.file File.join('files', path)
+end
+
+# Wildcard with parameters: /files/*/download/:id
+get '/files/*/download/:id' do |request, response, render|
+  render.json(
+    path: request.params[:wildcard],
+    id: request.params[:id]
+  )
+end
 ```
 
 ### Controllers
 
+#### Basic controller
+
 ```ruby
 class UsersController < Rasti::Web::Controller
 
+  def index
+    users = User.all
+    render.view 'users/list', users: users
+  end
+
+  def show
+    user = User.find(params[:id])
+    render.view 'users/show', user: user
+  end
+
   def update
     user = User.find(params[:id])
     if user.update_attributes(params[:user])
-      render.view 'users/list', users: User.all
+      render.view 'users/show', user: user
     else
       render.view 'users/edit', user: user
     end
@@ -61,36 +246,505 @@ class UsersController < Rasti::Web::Controller
 end
 ```
 
-### Hooks
+#### Using controllers in routes
+
+```ruby
+class WebApp < Rasti::Web::Application
+
+  get '/users', UsersController >> :index
+  get '/users/:id', UsersController >> :show
+  put '/users/:id', UsersController >> :update
+
+end
+```
+
+#### Hooks
+
+##### Before hooks
 
 ```ruby
 class UsersController < Rasti::Web::Controller
 
+  # Runs before all actions
   before_action do |action_name|
+    authenticate_user!
+  end
+
+  # Runs before a specific action
+  before_action :update do
+    verify_permissions!
   end
 
-  before_action :action_name do
+  def update
+    # action code
   end
 
+end
+```
+
+##### After hooks
+
+```ruby
+class UsersController < Rasti::Web::Controller
+
+  # Runs after all actions
   after_action do |action_name|
+    log_action(action_name)
   end
 
-  after_action :action_name do
+  # Runs after a specific action
+  after_action :create do
+    send_notification
+  end
+
+  def create
+    # action code
   end
 
 end
 ```
 
-### Error handling
+#### Error handling
 
 ```ruby
 class UsersController < Rasti::Web::Controller
 
-  rescue_from StandardError do |ex|
-    render.status 500, 'Unexpected error'
+  # Catch a specific exception
+  rescue_from UserNotFound do |ex|
+    render.status 404, ex.message
+  end
+
+  # Catch by class hierarchy (catches IOError and its subclasses like EOFError)
+  rescue_from IOError do |ex|
+    render.status 500, ex.message
+  end
+
+  # Multiple rescue_from
+  rescue_from ValidationError do |ex|
+    render.json({errors: ex.errors}, 422)
   end
 
+  rescue_from AuthenticationError do |ex|
+    render.status 401, 'Unauthorized'
+  end
+
+  def show
+    user = User.find(params[:id])  # may raise UserNotFound
+    render.json user
+  end
+
+end
+```
+
+### Endpoints
+
+Endpoints can be blocks or controller actions:
+
+```ruby
+# Endpoint as a block
+endpoint = Rasti::Web::Endpoint.new do |request, response, render|
+  render.text 'Hello world'
 end
+
+# Endpoint from a controller
+endpoint = UsersController.action :index
+
+# Endpoints are Rack-compatible
+status, headers, response = endpoint.call(env)
+```
+
+### Request
+
+#### Accessing parameters
+
+```ruby
+get '/search' do |request, response, render|
+  # Route parameters
+  user_id = request.params[:user_id]
+  
+  # Query string parameters (?q=ruby&page=1)
+  query = request.params['q']
+  page = request.params[:page]
+  
+  # Parameters are accessible with strings or symbols
+  render.json query: query, page: page
+end
+```
+
+#### Form parameters
+
+```ruby
+post '/users' do |request, response, render|
+  # Form parameters (POST/PUT)
+  name = request.params[:name]
+  email = request.params['email']
+  
+  user = User.create(name: name, email: email)
+  render.json user
+end
+```
+
+#### JSON body parameters
+
+```ruby
+post '/api/users' do |request, response, render|
+  # Content-Type: application/json automatically parsed
+  if request.json?
+    user = User.create(request.params)
+    render.json user, 201
+  else
+    render.status 400, 'Expected JSON content type'
+  end
+end
+```
+
+### Rendering
+
+The `render` object provides multiple methods for different response formats:
+
+#### Status codes
+
+```ruby
+# Status code only
+render.status 404
+
+# Status code and body
+render.status 500, 'Internal server error'
+
+# Status code and headers
+render.status 201, 'Content-Type' => 'application/json'
+
+# Status code, body and headers
+render.status 403, 'Forbidden', 'Content-Type' => 'text/html'
+```
+
+#### Text
+
+```ruby
+# Plain text
+render.text 'Hello world'
+
+# With status code
+render.text 'Not found', 404
+
+# With headers
+render.text 'Encoded text', 'Content-Encoding' => 'gzip'
+
+# With status code and headers
+render.text 'Error', 500, 'Content-Encoding' => 'gzip'
+```
+
+#### HTML
+
+```ruby
+# Basic HTML
+render.html '<h1>Welcome</h1>'
+
+# With status code
+render.html '<h1>Error</h1>', 500
+
+# With headers
+render.html '<p>Content</p>', 'Content-Encoding' => 'gzip'
+
+# With status code and headers
+render.html '<h1>Not found</h1>', 404, 'Custom-Header' => 'value'
+```
+
+#### JSON
+
+```ruby
+# Object serialized to JSON
+render.json id: 123, name: 'John'
+
+# Direct JSON string
+render.json '{"x":1,"y":2}'
+
+# With status code
+render.json {error: 'Invalid'}, 422
+
+# With headers
+render.json {data: []}, 'Content-Encoding' => 'gzip'
+
+# With status code and headers
+render.json {error: 'Invalid'}, 422, 'X-Error-Code' => 'VAL001'
+```
+
+#### JavaScript
+
+```ruby
+# JavaScript code
+render.js 'alert("hello");'
+
+# With status code
+render.js 'console.log("loaded");', 206
+
+# With headers
+render.js 'alert("hello");', 'Content-Encoding' => 'gzip'
+
+# With status code and headers
+render.js 'alert("hello");', 206, 'Cache-Control' => 'no-cache'
+```
+
+#### CSS
+
+```ruby
+# CSS code
+render.css 'body{margin:0}'
+
+# With status code
+render.css 'body{margin:0}', 206
+
+# With headers
+render.css 'body{margin:0}', 'Content-Encoding' => 'gzip'
+
+# With status code and headers
+render.css 'body{margin:0}', 206, 'Cache-Control' => 'public'
+```
+
+#### File downloads
+
+```ruby
+# File download
+render.file '/path/to/file.zip'
+# Content-Type and Content-Disposition are set automatically
+
+# With status code
+render.file '/path/to/file.pdf', 206
+
+# With custom headers
+render.file '/path/to/file.zip', 'Content-Disposition' => 'attachment; filename=custom.zip'
+
+# With status code and headers
+render.file '/path/to/file.zip', 206, 'Content-Disposition' => 'attachment; filename=custom.zip'
+```
+
+#### Data with headers
+
+```ruby
+# Data without Content-Type
+render.data 'Raw content'
+
+# With status code
+render.data 'Content', 206
+
+# With headers (useful with Rasti::Web::Headers.for_file)
+render.data file_content, Rasti::Web::Headers.for_file('document.txt')
+
+# With status code and headers
+render.data content, 206, Rasti::Web::Headers.for_file('file.txt')
+```
+
+### Templates
+
+Rasti::Web uses ERB for templates. By default, it looks for templates in `views/`.
+
+#### Configuring views directory
+
+```ruby
+# Configure template directory (default: 'views')
+Rasti::Web::Template.template_path = '/path/to/templates'
+```
+
+#### Partials
+
+Partials are templates without layout:
+
+```ruby
+# views/users/_user_info.erb
+<h1><%= title %></h1>
+<div><%= text %></div>
+
+# In your endpoint/controller:
+render.partial 'users/user_info', title: 'Welcome', text: 'Hello world'
+# => <h1>Welcome</h1><div>Hello world</div>
+```
+
+#### Layouts
+
+```ruby
+# views/layout.erb
+<html><body><%= yield %></body></html>
+
+# Layout with content
+render.layout { 'Page content' }
+# => <html><body>Page content</body></html>
+
+# Empty layout
+render.layout
+# => <html><body></body></html>
+```
+
+#### Custom layouts
+
+```ruby
+# views/custom_layout.erb
+<html><body class="custom"><%= yield %></body></html>
+
+# Use custom layout
+render.layout('custom_layout') { 'Page content' }
+# => <html><body class="custom">Page content</body></html>
+```
+
+#### Views
+
+Views combine a template with a layout:
+
+```ruby
+# views/users/profile.erb
+<h1><%= title %></h1>
+<div><%= text %></div>
+
+# views/layout.erb
+<html><body><%= yield %></body></html>
+
+# With default layout (layout.erb)
+render.view 'users/profile', title: 'Welcome', text: 'Hello world'
+# => <html><body><h1>Welcome</h1><div>Hello world</div></body></html>
+
+# With custom layout
+render.view 'users/profile', {title: 'Welcome', text: 'Hello'}, 'custom_layout'
+```
+
+#### Context methods and local variables
+
+```ruby
+# Module with context methods
+module ViewHelpers
+  def format_date(date)
+    date.strftime('%Y-%m-%d')
+  end
+end
+
+# views/posts/show.erb using context method
+<h1><%= format_date(post.created_at) %></h1>
+
+# Render with context
+class PostContext
+  include ViewHelpers
+end
+
+render.partial 'posts/show', PostContext.new, post: post
+
+# Or use local variables directly
+render.partial 'posts/show', title: 'My Post', text: 'Content'
+```
+
+## Advanced Usage
+
+### Complete example
+
+```ruby
+# app.rb
+class AuthController < Rasti::Web::Controller
+  
+  def login
+    user = User.authenticate(params[:email], params[:password])
+    if user
+      session[:user_id] = user.id
+      render.json user
+    else
+      render.status 401, 'Invalid credentials'
+    end
+  rescue AuthenticationError => ex
+    render.status 401, ex.message
+  end
+
+end
+
+class UsersController < Rasti::Web::Controller
+
+  before_action do |action_name|
+    authenticate_user!
+  end
+
+  rescue_from UserNotFound do |ex|
+    render.status 404, ex.message
+  end
+
+  def index
+    users = User.all
+    render.view 'users/index', users: users
+  end
+
+  def show
+    user = User.find(params[:id])
+    render.view 'users/show', user: user
+  end
+
+  private
+
+  def authenticate_user!
+    unless session[:user_id]
+      render.status 401, 'Unauthorized'
+    end
+  end
+
+end
+
+class WebApp < Rasti::Web::Application
+
+  use Rack::Session::Cookie, secret: ENV['SESSION_SECRET']
+
+  # Public routes
+  post '/login', AuthController >> :login
+
+  # Protected routes
+  get '/users', UsersController >> :index
+  get '/users/:id', UsersController >> :show
+
+  # API mount
+  map '/api', ApiApp
+
+  # Custom not found
+  not_found do |request, response, render|
+    render.view '404', path: request.path_info
+  end
+
+end
+
+# config.ru
+require_relative 'app'
+run WebApp
+```
+
+## Running Tests
+
+Run all tests:
+
+```bash
+rake spec
+# or simply
+rake
+```
+
+Run tests from a specific directory:
+
+```bash
+DIR=spec/web rake spec
+```
+
+Run a specific test file:
+
+```bash
+TEST=spec/endpoint_spec.rb rake spec
+```
+
+Run tests from a specific line in a file:
+
+```bash
+TEST=spec/endpoint_spec.rb:45 rake spec
+```
+
+Run tests matching a name pattern:
+
+```bash
+NAME=render rake spec
+```
+
+You can combine options:
+
+```bash
+DIR=spec/web NAME=controller rake spec
 ```
 
 ## Contributing

data/lib/rasti/web/request.rb

@@ -7,7 +7,7 @@ module Rasti
           hash.update self.GET
           hash.update self.POST
           hash.update env[ROUTE_PARAMS] if env.key? ROUTE_PARAMS
-          hash.update JSON.parse(body_text) if json? && body_text
+          hash.update JSON.parse(body_text) if json? && body_text && !body_text.empty?
         end
       end
 

data/lib/rasti/web/template.rb

@@ -4,7 +4,7 @@ module Rasti
 
       def self.render(template, context=nil, locals={}, &block)
         files = Web.template_engines.map { |e| File.join Web.views_path, "#{template}.#{e}" }
-        template_file = files.detect { |f| File.exists? f }
+        template_file = files.detect { |f| File.exist? f }
 
         raise "Missing template #{template} [#{files.join(', ')}]" unless template_file
 

data/lib/rasti/web/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module Web
-    VERSION = '2.1.0'
+    VERSION = '2.1.2'
   end
 end

data/rasti-web.gemspec

@@ -26,12 +26,12 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'content-type', '~> 0.0'
   spec.add_dependency 'class_ancestry_sort', '~> 0.1'
 
-  spec.add_development_dependency 'rake', '~> 11.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
   spec.add_development_dependency 'minitest-colorin', '~> 0.1'
   spec.add_development_dependency 'minitest-line', '~> 0.6'
   spec.add_development_dependency 'simplecov', '~> 0.12'
   spec.add_development_dependency 'coveralls', '~> 0.8'
-  spec.add_development_dependency 'pry-nav', '~> 0.2'
+  spec.add_development_dependency 'pry-nav', '~> 1.0'
   spec.add_development_dependency 'rack-test', '~> 0.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-web
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.2
 platform: ruby
 authors:
 - Gabriel Naiman
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-08 00:00:00.000000000 Z
+date: 2026-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -204,14 +204,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
@@ -234,10 +234,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".coveralls.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".ruby-gemset"
 - ".ruby-version"
-- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -277,7 +277,7 @@ homepage: https://github.com/gabynaiman/rasti-web
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -292,8 +292,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.9
+signing_key:
 specification_version: 4
 summary: Web blocks to build robust applications
 test_files:

data/.travis.yml

@@ -1,20 +0,0 @@
-language: ruby
-
-rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - 2.3
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
-  - jruby-9.2.9.0
-  - ruby-head
-  - jruby-head
-
-matrix:
-  fast_finish: true
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head