utopia 1.9.5 → 1.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7de15ab25d817b448a1c21a6f4d182997f4f05f2
-  data.tar.gz: 312bb8afd81ed6d896023c91b3967e8ecb9e685a
+  metadata.gz: c4aa4a93b7aa926a88cb796ca6f630f058bf9395
+  data.tar.gz: 253a3923fff1dbdd105453f75f46b8d5554b09a6
 SHA512:
-  metadata.gz: 438c588e37cfe3bc2ebf0014cf138bfcee0843a77c31478ca33bb888d6018fe8c1dd38ba62686a77ba357f4d105bd88ca3f8464178c247ba49094794b0e35add
-  data.tar.gz: 1ee534d2c10acc63dacf401dcf3b8c530895f5eef38a2134dc98ccc03e5cc9a9b314c47fc8596e6917235fe77f2e6e64ace21909acab428d1278301e99eef2ef
+  metadata.gz: 8dcfc6ba224e51f0b879c6c28a962737be2e13f52ec776a059916b96683cb84c3b6fcf05fde93951299d443fe12c406f6882936ff73f6851eaed49497f8ca645
+  data.tar.gz: 883e20396120819851979dbebc31a4fbdfc7a0309716cf334ffcd9285a6f4e254ee8d25ff1873b535b3a30529554677484529857ff75942368419daac34847cd

data/.codeclimate.yml

@@ -0,0 +1,3 @@
+exclude_paths:
+- "documentation"
+- "setup"

data/README.md

@@ -18,8 +18,6 @@ So, Utopia exists because it suits my way of thinking about web applications, an
 
 ## Installation
 
-### Local Setup
-
 Install utopia:
 
 	$ gem install utopia
@@ -31,239 +29,9 @@ Create a new site:
 	$ utopia site create
 	$ rake
 
-#### Bower Integration
-
-If you create a site using the utopia generator, it includes a `.bowerrc` configuration which installs components into `public/_static/components`. To install jquery, for example:
-
-	$ bower install jquery
-
-Then add the appropriate `<script>` tags to `pages/_page.xnode`:
-
-	<script src="/_static/components/jquery/dist/jquery.min.js" type="text/javascript"></script>
-
-### Server Setup
-
-Utopia can be used to set up remote sites quickly and easily.
-
-Firstly log into your remote site using `ssh` and install utopia:
-
-	$ ssh remote
-	$ sudo gem install utopia
-
-Then use the utopia command to generate a new remote site:
-
-	$ mkdir /srv/http/www.example.com
-	$ cd /srv/http/www.example.com
-	$ sudo -u http utopia server create
-
-On the local site, you can set up a git remote:
-
-	$ git remote add production ssh://remote/srv/http/www.example.com
-	$ git push --set-upstream production master
-
-When you push to the remote site, `rake deploy` will be run after the code is updated, finally, `rake restart` will be run which ideally should restart the application server.
-
-### Passenger+Nginx Setup
-
-Utopia works well with Passenger+Nginx. Installing Passenger+Nginx is easy:
-
-	$ ssh remote
-	$ sudo gem install passenger
-	$ passenger-install-nginx-module
-
-Then, Nginx is configured like so:
-
-	server {
-		listen 80;
-		server_name www.example.com;
-		root /srv/http/www.example.com/public;
-		passenger_enabled on;
-	}
-
-	server {
-		listen 80;
-		server_name example.com;
-		rewrite ^ http://www.example.com$uri permanent;
-	}
-
-### Arch Linux
-
-Packages for deploying Passenger+Nginx on Arch are available in the AUR. There are issues with the official packages so please avoid them.
-
-- [nginx-mainline-passenger](https://aur.archlinux.org/packages/nginx-mainline-passenger/)
-- [passenger-nginx-module](https://aur.archlinux.org/packages/passenger-nginx-module/)
-
-#### Compression
-
-We suggest [enabling gzip compression](https://zoompf.com/blog/2012/02/lose-the-wait-http-compression):
-
-	gzip on;
-	gzip_vary on;
-	gzip_comp_level 6;
-	gzip_http_version 1.1;
-	gzip_proxied any;
-	gzip_types text/* image/svg+xml application/json application/javascript;
-
 ## Usage
 
-Utopia builds on top of Rack with the following middleware:
-
-- `Utopia::Static`: Serve static files efficiently.
-- `Utopia::Redirection`: Redirect URL patterns and status codes.
-- `Utopia::Localization`: Non-intrusive localization of resources.
-- `Utopia::Controller`: Dynamic behaviour with recursive execution.
-- `Utopia::Content`: XML-style template engine with powerful tag behaviours.
-- `Utopia::Session`: Session storage using an encrypted cookie.
-
-The implementation of Utopia is considered thread-safe and reentrant. However, this does not guarantee that the code YOU write will be so.
-
-### Static
-
-This middleware serves static files using the `mime-types` library. By default, it works with `Rack::Sendfile` and supports `ETag` based caching. Normally, you'd prefer to put static files into `public/_static` but it's also acceptable to put static content into `pages/` if it makes sense.
-
-	use Utopia::Static,
-		# The root path to serve files from:
-		root: "path/to/root",
-		# The mime-types to recognize/serve:
-		types: [:default, :xiph],
-		# Cache-Control header for files:
-		cache_control: 'public, max-age=7200'
-
-### Redirection
-
-A set of flexible URI rewriting middleware which includes support for string mappings, regular expressions and status codes (e.g. 404 errors).
-
-	# String (fast hash lookup) rewriting:
-	use Utopia::Redirection::Rewrite,
-		'/' => '/welcome/index'
-
-	# Redirect directories (e.g. /) to an index file (e.g. /index):
-	use Utopia::Redirection::DirectoryIndex,
-		index: 'index.html'
-	
-	# Redirect (error) status codes to actual pages:
-	use Utopia::Redirection::Errors,
-		404 => '/errors/file-not-found'
-
-### Localization
-
-The localization middleware uses the `Accept-Language` header to guess the preferred locale out of the given options. If a request path maps to a resource, that resource is returned. Otherwise, a localized request is made.
-
-	use Utopia::Localization,
-		:default_locale => 'en',
-		:locales => ['en', 'de', 'ja', 'zh'],
-		:nonlocalized => ['/_static/', '/_cache/']
-
-Somewhere further down the chain, you can localize a resource:
-
-	localization = Utopia::Localization[request]
-	show_welcome(localization.current_locale)
-
-### Controller
-
-A simple recursive controller layer which works in isolation from the view rendering middleware.
-
-	use Utopia::Controller,
-		# The root directory where `controller.rb` files can be found.
-		root: 'path/to/root',
-		# The base class to use for all controllers:
-		base: Utopia::Controller::Base
-		# Whether or not to cache controller classes:
-		cache_controllers: (RACK_ENV == :production),
-
-A controller is a file within the root directory (or subdirectory) with the name `controller.rb`. This code is dynamically loaded into an anonymous class and executed. The default controller has only a single function:
-
-	def passthrough(request, path)
-		# Call one of:
-		
-		# This will cause the middleware to generate a response.
-		# def respond!(response)
-
-		# This will cause the controller to skip the request.
-		# def ignore!
-
-		# Request relative redirect. Respond with a redirect to the given target.
-		# def redirect! (target, status = 302)
-		
-		# Controller relative redirect.
-		# def goto!(target, status = 302)
-		
-		# Respond with an error which indiciates some kind of failure.
-		# def fail!(error = 400, message = nil)
-		
-		# Succeed the request and immediately respond.
-		# def succeed!(status: 200, headers: {}, **options)
-		# options may include content: string or body: Enumerable (as per Rack specifications
-	end
-
-The controller layer can do more complex operations by prepending modules into it.
-
-	prepend Rewrite, Actions
-
-	# Extracts an Integer
-	rewrite.extract_prefix id: Integer do
-		@user = User.find_by_id(@id)
-	end
-
-	on 'edit' do |request, path|
-		if request.post?
-			@user.update_attributes(request[:user])
-		end
-	end
-	
-	otherwise do |request, path|
-		# Executed if no specific named actions were executed.
-		succeed!
-	end
-
-### Content
-
-A tag based content generation system which integrates nicely with HTML5. Supports structures which separate generic page templates from dynamically generated content in an easy and consistent way.
-
-	use Utopia::Content,
-		cache_templates: (RACK_ENV == :production),
-		tags: {
-			'deferred' => Utopia::Tags::Deferred,
-			'override' => Utopia::Tags::Override,
-			'node' => Utopia::Tags::Node,
-			'environment' => Utopia::Tags::Environment.for(RACK_ENV)
-		}
-
-A basic template `create.xnode` looks something like:
-
-	<page>
-		<heading>Create User</heading>
-		<form action="#">
-			<input name="name" />
-			<input type="submit" />
-		</form>
-	</page>
-
-This template would typically be designed with supporting `_page.xnode` and `_heading.xnode` in the same directory or, more typically, somewhere further up the directory hierarchy.
-
-### Session
-
-The session management uses symmetric private key encryption to store data on the client and avoid tampering.
-
-	use Utopia::Session,
-		:expires_after => 3600,
-		:secret => '40 or more random characters for your secret key'
-
-All session data is stored on the client, but it's encrypted with a salt and the secret key. It would be hard for the client to decrypt the data without the secret.
-
-### Testing
-
-Utopia websites include a default set of tests, and associated `rake test` tasks. These specs can test against the actual running website. By default, `simplecov` is included for coverage testing.
-
-	$ rake coverage test
-
-	my website
-		should have an accessible front page
-
-	Finished in 0.44849 seconds (files took 0.15547 seconds to load)
-	1 example, 0 failures
-
-	Coverage report generated for RSpec. 5 / 5 LOC (100.0%) covered.
+There is an excellent documentation wiki included with the source code. Simply clone this repository and `rake documentation`. This documentation wiki is editable, so feel free to submit a PR with improvements.
 
 ## Contributing
 

data/Rakefile

@@ -9,4 +9,9 @@ RSpec::Core::RakeTask.new(:spec) do |task|
 	end
 end
 
+task :documentation do
+	sh('bundle install')
+	sh('cd documentation && rake')
+end
+
 task :default => :spec

data/documentation/pages/wiki/_listing.xnode

@@ -0,0 +1,32 @@
+<?r
+
+case attributes[:rel]
+when "utopia"
+	# Listing src will be relative to the base of utopia:
+	base_path = Utopia::default_root("../")
+when "site"
+	# Listing src is relative to setup/site in utopia:
+	base_path = Utopia::default_root("../setup/site")
+else
+	# Listing src will be relative to the path of the wiki page:
+	base_path = current.node.local_path(controller[:page_path])
+end
+
+if attributes[:src]
+	path = File.join(base_path, attributes[:src])
+	code = File.read(path)
+else
+	code = content
+end
+
+escaped_code = MarkupString.new(code)
+
+escaped_code = escaped_code.gsub(/%%([a-z]+)\{(.*?)\}/) do |match|
+	"<span class=\"#{$1}\">#{$2}</span>"
+end
+
+if lang = (attributes[:lang] || attributes[:brush]) ?>
+	<pre><code class="syntax brush-#{lang}">#{escaped_code}</code></pre>
+<?r else ?>
+	<pre>#{escaped_code}</pre>
+<?r end ?>

data/documentation/pages/wiki/bower-integration/content.md

@@ -0,0 +1,25 @@
+# Bower Integration
+
+Utopia integrates with Bower and provides a rake task to improve deployment of `dist` code.
+
+By default, utopia includes a `.bowerrc` file which installs modules into `lib/components`. This code can then be copied into `public/_components` using `rake bower:update`.
+
+## Installing jQuery
+
+Firstly install jquery using bower:
+
+	$ bower install jquery
+
+Copy the distribution scripts to `public/_components`:
+
+	$ rake bower:update
+
+Then add the appropriate `<script>` tags to `pages/_page.xnode`:
+
+	<script src="/_components/jquery/jquery.min.js" type="text/javascript"></script>
+
+## What does `rake bower:update` do?
+
+This task copies only the contents of the dist directory. This ensures that you only get files intended for distribution. If the bower package doesn't have a `dist` directory, the entire contents is copied.
+
+<listing rel="site" src="tasks/bower.rake" brush="ruby" />

data/documentation/pages/wiki/content.md

@@ -1,12 +1,27 @@
-# Utopia Documentation Wiki
-
-This wiki includes documentation and examples showing how to use Utopia.
-
-- [Development Environment Setup](development-environment-setup/)
-- [Server Setup](server-setup/)
-- [Your first page](your-first-page/)
-
-## Advanced Topics
-
-- [Controller Actions](controller/actions/)
-- [Controller Rewrite](controller/rewrite/)
+# Utopia Documentation Wiki
+
+This wiki includes documentation and examples showing how to use Utopia.
+
+## Introduction Guide
+
+Reading these pages in order will give you an overview of the design of Utopia, how to set it up for local development and how to deploy it.
+
+- [Development Environment Setup](development-environment-setup/)
+- [Server Setup](server-setup/)
+- [Your first page](your-first-page/)
+- [Installing JavaScript Libraries](bower-integration/)
+- [Website Tests](testing/)
+
+## Middleware
+
+- [Static](middleware/static/) — Serve static files efficiently.
+- [Redirection](middleware/redirection/) — Redirect URL patterns and status codes.
+- [Localization](middleware/localization/) — Non-intrusive localization of resources.
+- [Controller](middleware/controller/) — Flexible nested controllers with efficient behaviour. 
+- [Content](middleware/content/) — XML-style template engine with dynamic markup.
+- [Session](middleware/session/) — Session storage using encrypted client-side cookies.
+
+## Controller Layers
+
+- [Controller Actions](controller/actions/)
+- [Controller Rewrite](controller/rewrite/)

data/documentation/pages/wiki/edit.xnode

@@ -1,6 +1,13 @@
 <page>
 	<?r response.do_not_cache! ?>
 	
+	<style type="text/css">
+		
+		form textarea {
+			
+		}
+	</style>
+	
 	<heading>Editing #{self[:page_title].inspect}</heading>
 	<form action="#" method="post">
 		<fieldset>

data/documentation/pages/wiki/middleware/content/content.md

@@ -0,0 +1,27 @@
+# Content
+A tag based content generation system which integrates nicely with HTML5. Supports structures which separate generic page templates from dynamically generated content in an easy and consistent way.
+
+```ruby
+use Utopia::Content,
+	cache_templates: (RACK_ENV == :production),
+	tags: {
+		'deferred' => Utopia::Tags::Deferred,
+		'override' => Utopia::Tags::Override,
+		'node' => Utopia::Tags::Node,
+		'environment' => Utopia::Tags::Environment.for(RACK_ENV)
+	}
+```
+
+A basic template `create.xnode` looks something like:
+
+```trenni
+<page>
+	<heading>Create User</heading>
+	<form action="#">
+		<input name="name" />
+		<input type="submit" />
+	</form>
+</page>
+```
+
+This template would typically be designed with supporting `_page.xnode` and `_heading.xnode` in the same directory or, more typically, somewhere further up the directory hierarchy.

data/documentation/pages/wiki/middleware/controller/content.md

@@ -0,0 +1,62 @@
+# Controller
+
+A simple recursive controller layer which works in isolation from the view rendering middleware.
+
+```ruby
+use Utopia::Controller,
+	# The root directory where `controller.rb` files can be found.
+	root: 'path/to/root',
+	# The base class to use for all controllers:
+	base: Utopia::Controller::Base,
+	# Whether or not to cache controller classes:
+	cache_controllers: (RACK_ENV == :production)
+```
+
+A controller is a file within the root directory (or subdirectory) with the name `controller.rb`. This code is dynamically loaded into an anonymous class and executed. The default controller has only a single function:
+
+```ruby
+def passthrough(request, path)
+	# Call one of:
+	
+	# This will cause the middleware to generate a response.
+	# def respond!(response)
+
+	# This will cause the controller to skip the request.
+	# def ignore!
+
+	# Request relative redirect. Respond with a redirect to the given target.
+	# def redirect! (target, status = 302)
+	
+	# Controller relative redirect.
+	# def goto!(target, status = 302)
+	
+	# Respond with an error which indiciates some kind of failure.
+	# def fail!(error = 400, message = nil)
+	
+	# Succeed the request and immediately respond.
+	# def succeed!(status: 200, headers: {}, **options)
+	# options may include content: string or body: Enumerable (as per Rack specifications
+end
+```
+
+The controller layer can do more complex operations by prepending modules into it.
+
+```ruby
+prepend Rewrite, Actions
+
+# Extracts an Integer
+rewrite.extract_prefix id: Integer do
+	@user = User.find_by_id(@id)
+end
+
+on 'edit' do |request, path|
+	if request.post?
+		@user.update_attributes(request[:user])
+	end
+end
+
+otherwise do |request, path|
+	# Executed if no specific named actions were executed.
+	succeed!
+end
+```

data/documentation/pages/wiki/middleware/localization/content.md

@@ -0,0 +1,17 @@
+# Localization
+
+The localization middleware uses the `Accept-Language` header to guess the preferred locale out of the given options. If a request path maps to a resource, that resource is returned. Otherwise, a localized request is made.
+
+```ruby
+use Utopia::Localization,
+	:default_locale => 'en',
+	:locales => ['en', 'de', 'ja', 'zh'],
+	:nonlocalized => ['/_static/', '/_cache/']
+```
+
+Somewhere further down the chain, you can localize a resource:
+
+```ruby
+localization = Utopia::Localization[request]
+show_welcome(localization.current_locale)
+```

data/documentation/pages/wiki/middleware/redirection/content.md

@@ -0,0 +1,17 @@
+# Redirection
+
+A set of flexible URI rewriting middleware which includes support for string mappings, regular expressions and status codes (e.g. 404 errors).
+
+```ruby
+# String (fast hash lookup) rewriting:
+use Utopia::Redirection::Rewrite,
+	'/' => '/welcome/index'
+
+# Redirect directories (e.g. /) to an index file (e.g. /index):
+use Utopia::Redirection::DirectoryIndex,
+	index: 'index.html'
+
+# Redirect (error) status codes to actual pages:
+use Utopia::Redirection::Errors,
+	404 => '/errors/file-not-found'
+```

data/documentation/pages/wiki/middleware/session/content.md

@@ -0,0 +1,11 @@
+# Session
+
+The session management uses symmetric private key encryption to store data on the client and avoid tampering.
+
+```ruby
+use Utopia::Session,
+	:expires_after => 3600,
+	:secret => '40 or more random characters for your secret key'
+```
+
+All session data is stored on the client, but it's encrypted with a salt and the secret key. It would be hard for the client to decrypt the data without the secret.

data/documentation/pages/wiki/middleware/static/content.md

@@ -0,0 +1,13 @@
+# Static
+
+This middleware serves static files using the `mime-types` library. By default, it works with `Rack::Sendfile` and supports `ETag` based caching. Normally, you'd prefer to put static files into `public/_static` but it's also acceptable to put static content into `pages/` if it makes sense.
+
+```ruby
+use Utopia::Static,
+	# The root path to serve files from:
+	root: "path/to/root",
+	# The mime-types to recognize/serve:
+	types: [:default, :xiph],
+	# Cache-Control header for files:
+	cache_control: 'public, max-age=7200'
+```

data/documentation/pages/wiki/server-setup/content.md

@@ -1,5 +1,42 @@
 # Server Setup
 
+Utopia is designed to make deployment to remote servers easy.
+
+## Deployment
+
+The preferred method of deployment to a production server is via git. The `utopia` command assists with setup of a remote git repository on the server. It will setup a `git` `post-update` hook which will deploy the site correctly and restart passenger for that site.
+
+To setup a server for deployment:
+
+```bash
+$ mkdir /srv/http/www.example.com
+$ cd /srv/http/www.example.com
+$ sudo -u http utopia server create
+```
+
+On your development machine, you should setup the git remote:
+
+```bash
+$ git remote add production ssh://remote/srv/http/www.example.com
+$ git push --set-upstream production master
+```
+
+### Default Environment
+
+Utopia will load `config/environment.yaml` and update `ENV` before executing any code. You can set default environment values using the `utopia` command:
+
+```bash
+$ sudo -u http utopia server environment RACK_ENV=production DATABASE_ENV=production_cluster_primary
+ENV["RACK_ENV"] will default to "production" unless otherwise specified.
+ENV["DATABASE_ENV"] will default to "production_cluster_primary" unless otherwise specified.
+```
+
+To set a value, write `KEY=VALUE`. To unset a key, write `KEY`.
+
+When you run `rake` tasks or spawn a server, the values in `config/environment.yaml` will be the defaults. You can override them by manually specifying them, e.g. `DATABASE_ENV=development rake db:info`.
+
+## Platform
+
 The best deployment platform for Utopia is Linux. Specifically, [Arch Linux](https://www.archlinux.org/) with the following packages:
 
 - [nginx-mainline-passenger](https://aur.archlinux.org/packages/nginx-mainline-passenger/)
@@ -7,7 +44,7 @@ The best deployment platform for Utopia is Linux. Specifically, [Arch Linux](htt
 
 There have been issues with the official packages and thus these packages were developed and tested with Utopia deployment in mind.
 
-## Sample Nginx Configuration
+### Sample Nginx Configuration
 
 Create a configuration file for your site, e.g. `/etc/nginx/sites/www.example.com`:
 
@@ -26,21 +63,14 @@ server {
 }
 ```
 
-## Deployment via Git
+### Sudo Setup
 
-The preferred method of deployment to a production server is via git. The `utopia` command assists with setup of a remote git repository on the server. It will setup a `git` `post-update` hook which will deploy the site correctly and restart passenger for that site.
+Create a file `/etc/sudoers.d/http` with the following contents:
 
-To setup a server for deployment:
-
-```bash
-$ mkdir /srv/http/www.example.com
-$ cd /srv/http/www.example.com
-$ sudo -u http utopia server create
+```sudoers
+# Allow user samuel to check out code as user http using git:
+%wheel ALL=(http) NOPASSWD: ALL
 ```
 
-On your development machine, you should setup the git remote:
+This allows the deploy task to correctly checkout code as user `http`.
 
-```bash
-$ git remote add production ssh://remote/srv/http/www.example.com
-$ git push --set-upstream production master
-```

data/documentation/pages/wiki/testing/content.md

@@ -0,0 +1,15 @@
+# Testing
+
+Utopia websites include a default set of tests, and associated `rake test` tasks. These specs can test against the actual running website. By default, `simplecov` is included for coverage testing.
+
+```bash
+$ rake coverage test
+
+my website
+	should have an accessible front page
+
+Finished in 0.44849 seconds (files took 0.15547 seconds to load)
+1 example, 0 failures
+
+Coverage report generated for RSpec. 5 / 5 LOC (100.0%) covered.
+```

data/lib/utopia/command.rb

@@ -23,6 +23,8 @@ require_relative 'version'
 require 'fileutils'
 require 'find'
 
+require 'yaml/store'
+
 require 'samovar'
 
 module Utopia
@@ -44,6 +46,18 @@ module Utopia
 			
 			module Server
 				ROOT = File.join(BASE, 'server')
+				
+				def self.environment(root)
+					# Setup config/environment.yaml according to specified options:
+					environment_path = File.join(root, 'config/environment.yaml')
+					FileUtils.mkpath File.dirname(environment_path)
+					
+					store = YAML::Store.new(environment_path)
+					
+					store.transaction do
+						yield store
+					end
+				end
 			end
 		end
 		
@@ -61,21 +75,66 @@ module Utopia
 						system("git", "init", "--shared")
 						system("git", "config", "receive.denyCurrentBranch", "ignore")
 						system("git", "config", "core.worktree", destination_root)
-						
-						system("cp", "-r", File.join(Setup::Server::ROOT, 'git', 'hooks'), File.join(destination_root, '.git'))
-						system("cp", "-r", File.join(Setup::Server::ROOT, 'config'), File.join(destination_root))
 					end
 					
+					# Copy git hooks:
+					system("cp", "-r", File.join(Setup::Server::ROOT, 'git', 'hooks'), File.join(destination_root, '.git'))
+					
+					# Print out helpful git remote add message:
 					hostname = `hostname`.chomp
 					puts "Now add the git remote to your local repository:\n\tgit remote add production ssh://#{hostname}#{destination_root}"
 					puts "Then push to it:\n\tgit push --set-upstream production master"
 				end
 			end
 			
+			class Update < Samovar::Command
+				self.description = "Update the git hooks in an existing server repository."
+				
+				def invoke(parent)
+					destination_root = parent.root
+					
+					Dir.chdir(destination_root) do
+						system("git", "config", "receive.denyCurrentBranch", "ignore")
+						system("git", "config", "core.worktree", destination_root)
+					end
+					
+					# Copy git hooks:
+					system("cp", "-r", File.join(Setup::Server::ROOT, 'git', 'hooks'), File.join(destination_root, '.git'))
+				end
+			end
+			
+			class Environment < Samovar::Command
+				self.description = "Update environment variables in config/environment.yaml"
+				
+				many :variables, "A list of environment KEY=VALUE pairs to set."
+				
+				def invoke(parent)
+					return if variables.empty?
+					
+					destination_root = parent.root
+					
+					Setup::Server.environment(destination_root) do |store|
+						variables.each do |variable|
+							key, value = variable.split('=', 2)
+							
+							if value
+								puts "ENV[#{key.inspect}] will default to #{value.inspect} unless otherwise specified."
+								store[key] = value
+							else
+								puts "ENV[#{key.inspect}] will be unset unless otherwise specified."
+								store.delete(key)
+							end
+						end
+					end
+				end
+			end
+			
 			self.description = "Manage server deployments."
 			
 			nested '<command>',
-				'create' => Create
+				'create' => Create,
+				'update' => Update,
+				'environment' => Environment
 			
 			def invoke(parent)
 				@command.invoke(parent)

data/lib/utopia/setup.rb

@@ -56,8 +56,10 @@ module Utopia
 				# Load the YAML environment file:
 				environment = YAML.load_file(environment_path)
 				
-				# Update the process environment:
-				ENV.update(environment)
+				# We update ENV but only when it's not already set to something:
+				ENV.update(environment) do |name, old_value, new_value|
+					old_value
+				end
 			end
 		end
 		

data/lib/utopia/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Utopia
-	VERSION = "1.9.5"
+	VERSION = "1.9.6"
 end

data/setup/server/config/environment.yaml

@@ -1 +1 @@
-RACK_ENV: production
+RACK_ENV=production

data/setup/site/public/_static/site.css

@@ -64,6 +64,14 @@ h1, h2, h3, h4, h5, h6 {
 	color: #4E8DD9;
 }
 
+h1 {
+	margin-bottom: 4rem;
+}
+
+h2 {
+	margin-top: 6rem;
+}
+
 img {
 	border: none;
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: utopia
 version: !ruby/object:Gem::Version
-  version: 1.9.5
+  version: 1.9.6
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-12 00:00:00.000000000 Z
+date: 2016-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trenni
@@ -189,6 +189,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".simplecov"
@@ -214,7 +215,9 @@ files:
 - documentation/pages/errors/file-not-found.xnode
 - documentation/pages/links.yaml
 - documentation/pages/welcome/index.xnode
+- documentation/pages/wiki/_listing.xnode
 - documentation/pages/wiki/_navigation.xnode
+- documentation/pages/wiki/bower-integration/content.md
 - documentation/pages/wiki/content.md
 - documentation/pages/wiki/controller.rb
 - documentation/pages/wiki/controller/actions/content.md
@@ -223,8 +226,15 @@ files:
 - documentation/pages/wiki/development-environment-setup/content.md
 - documentation/pages/wiki/edit.xnode
 - documentation/pages/wiki/links.yaml
+- documentation/pages/wiki/middleware/content/content.md
+- documentation/pages/wiki/middleware/controller/content.md
+- documentation/pages/wiki/middleware/localization/content.md
+- documentation/pages/wiki/middleware/redirection/content.md
+- documentation/pages/wiki/middleware/session/content.md
+- documentation/pages/wiki/middleware/static/content.md
 - documentation/pages/wiki/server-setup/content.md
 - documentation/pages/wiki/show.xnode
+- documentation/pages/wiki/testing/content.md
 - documentation/pages/wiki/your-first-page/content.md
 - documentation/public/_components/jquery-syntax/.sass-cache/040afc1428b286fb3c50151378b349a6149698d3/jquery.syntax.core.sassc
 - documentation/public/_components/jquery-syntax/.sass-cache/098642d80a1682613dca2bba6fd0a3bc9fd2bf04/jquery.syntax.layout.editor.sassc