utopia 2.14.0 → 2.16.2

data/spec/utopia/static_spec.rb

@@ -1,49 +0,0 @@
-#!/usr/bin/env rspec
-# frozen_string_literal: true
-
-# Copyright, 2014, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-require 'rack'
-require 'rack/test'
-
-require 'utopia/static'
-
-module Utopia::StaticSpec
-	describe Utopia::Static do
-		include Rack::Test::Methods
-		
-		let(:app) {Rack::Builder.parse_file(File.expand_path('../static_spec.ru', __FILE__)).first}
-		
-		it "should give the correct mime type" do
-			get "/test.txt"
-			
-			expect(last_response.header['Content-Type']).to be == 'text/plain'
-		end
-		
-		it "should return partial content" do
-			get "/test.txt", {}, 'HTTP_RANGE' => 'bytes=1-4'
-			
-			expect(last_response.status).to be == 206 
-			expect(last_response.content_length).to be == 4
-			expect(last_response.body).to be == "ello"
-		end
-	end
-end

data/spec/utopia/static_spec.ru

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-use Utopia::Static, root: File.expand_path('static_spec', __dir__)
-
-run lambda {|env| [404, {}, []]}

data/spec/utopia/static_spec/test.txt

@@ -1 +0,0 @@
-Hello World!

data/utopia.gemspec

@@ -1,52 +0,0 @@
-
-require_relative 'lib/utopia/version'
-
-Gem::Specification.new do |spec|
-	spec.name          = 'utopia'
-	spec.version       = Utopia::VERSION
-	spec.authors       = ['Samuel Williams']
-	spec.email         = ['samuel.williams@oriontransfer.co.nz']
-	spec.description   = <<-EOF
-		Utopia is a website generation framework which provides a robust set of tools
-		to build highly complex dynamic websites. It uses the filesystem heavily for
-		content and provides frameworks for interacting with files and directories as
-		structure representing the website.
-	EOF
-	spec.summary       = %q{Utopia is a framework for building dynamic content-driven websites.}
-	spec.homepage      = 'https://github.com/ioquatix/utopia'
-	spec.license       = "MIT"
-	
-	spec.files         = `git ls-files`.split($/)
-	spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-	spec.require_paths = ['lib']
-	
-	spec.required_ruby_version = '~> 2.5'
-	
-	spec.add_dependency 'trenni', '~> 3.0'
-	spec.add_dependency 'mime-types', '~> 3.0'
-	spec.add_dependency 'msgpack'
-	
-	spec.add_dependency 'samovar', '~> 2.1'
-	spec.add_dependency 'console', '~> 1.0'
-	spec.add_dependency 'variant', '~> 0.1'
-	
-	spec.add_dependency 'rack', '~> 2.2'
-	
-	spec.add_dependency 'http-accept', '~> 2.1'
-	
-	spec.add_dependency 'mail', '~> 2.6'
-	
-	spec.add_dependency 'concurrent-ruby', '~> 1.0'
-	
-	spec.add_development_dependency 'bake'
-	
-	spec.add_development_dependency 'falcon'
-	spec.add_development_dependency 'async-rspec'
-	spec.add_development_dependency 'async-websocket'
-	
-	spec.add_development_dependency 'covered'
-	spec.add_development_dependency 'bundler'
-	spec.add_development_dependency 'rspec', '~> 3.6'
-	spec.add_development_dependency 'bake-bundler'
-end

data/wiki/Gemfile

@@ -1,9 +0,0 @@
-
-source "https://rubygems.org"
-
-group :preload do
-	gem "falcon"
-	gem "utopia-wiki"
-end
-
-gem "utopia", path: "../"

data/wiki/config.ru

@@ -1,7 +0,0 @@
-
-require 'utopia/setup'
-UTOPIA ||= Utopia.setup
-
-require 'utopia/wiki'
-
-Utopia::Wiki.call(self)

data/wiki/pages/development-environment-setup/index.md

@@ -1,16 +0,0 @@
-# Development Environment Setup
-
-Utopia is built on Ruby and Rack. Therefore, Ruby (suggested 2.0+) should be installed and working. Then, simply run:
-
-```bash
-$ gem install utopia
-```
-
-To install all required dependencies.
-
-Utopia and it's dependencies are built on Linux and Mac by default, and therefore compatibility with Windows is not guaranteed.
-
-## Atom Integration
-
-Utopia uses [Trenni](https://github.com/ioquatix/trenni) for templates and it has a syntax slightly different from ERB. However, there is a [package for Atom](https://atom.io/packages/language-trenni) which provides accurate syntax highlighting.
-

data/wiki/pages/faq/links.yaml

@@ -1,2 +0,0 @@
-index:
-  title: FAQ

data/wiki/pages/faq/what-is-xnode/index.md

@@ -1,37 +0,0 @@
-# What is `.xnode`?
-
-Xnodes are the files on disk which are used as part of Utopia's content/view layer. Xnode templates are designed to maximise the ratio of content to markup. They improve separation of concerns and semantic organisation because repeated markup can be reused easily.
-
-Here is a example of a blog post:
-
-```xml
-<content:entry title="My day as a fish">
-	<p>It was not very exciting</p>
-</content:entry>
-```
-
-The `Utopia::Content` middleware is built on top of the [Trenni](https://github.com/ioquatix/trenni) template language which uses two-phase evaluation.
-
-## Phase 1: Evaluation
-
-Trenni processes the view content by evaluation `#{expressions}` and `<?r statements ?>`. This generates an output buffer. The output buffer should contain valid markup (i.e. balanced tags, no invalid characters).
-
-## Phase 2: Markup
-
-Once the template is evaluated to text, it is parsed again into an event stream which is used to generate the final output. The event stream contains things like "open tag", "attribute", "close tag", and so on, and these are fed into the `Utopia::Content` middleware which generates the actual content. Tags without namespaces are output verbatim, while tags with namespaces invoke the tag lookup machinery. This uses the tag name to invoke further behaviour, e.g. inserting more content. Here is a simple example of a basic page:
-
-```xml
-<content:page>
-	<content:heading>Welcome to my page</content:heading>
-
-	<p>This page is so awesome</p>
-</content:page>
-```
-
-In order to render this, you will need two additional files, `_page.xnode` and `_heading.xnode`. As a short example, `_heading.xnode` might look like this:
-
-```xml
-<h1><utopia:content/></h1>
-```
-
-When the parser encounters `<content:heading>...` in the main page, it would evaluate the above template. `<utopia:content/>` is a special tag that evaluates to the content that the parent tag provided, so in this case: `"Welcome to my page"`.  Thus, the final output is `<h1>Welcome to my page</h1>`.

data/wiki/pages/faq/what-is-xnode/links.yaml

@@ -1,2 +0,0 @@
-index:
-  title: "What is .xnode?"

data/wiki/pages/index.md

@@ -1,35 +0,0 @@
-# Utopia
-
-Utopia is a content management system built on top of Ruby. It makes creating, deploying and updating content-driven websites easy.
-
-## 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/)
-  - [What is `.xnode`?](faq/what-is-xnode/)
-- [Installing JavaScript Libraries](javascript/)
-- [Website Tests](testing/)
-- [Updating Your Site](updating-utopia/)
-
-## Middleware
-
-The following are Rack Middleware which provide the core of Utopia.
-
-- [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. 
-  - [Controller Actions](middleware/controller/actions/) — Invoke named actions.
-  - [Controller Rewrite](middleware/controller/rewrite/) — Pattern match requests.
-- [Content](middleware/content/) — XML-style template engine with dynamic markup.
-- [Session](middleware/session/) — Session storage using encrypted client-side cookies.
-
-## Examples
-
-Here are some open-source sites built on Utopia.
-
-- [www.codeotaku.com](http://www.codeotaku.com) ([source](https://github.com/ioquatix/www.codeotaku.com)) — Personal website, blog.
-- Financier ([source](https://github.com/ioquatix/financier)) — Small business management platform, invoicing.

data/wiki/pages/javascript/index.md

@@ -1,77 +0,0 @@
-# Installing JavaScript Libraries
-
-Utopia integrates with Yarn and provides a [bake task](https://github.com/ioquatix/bake) to simplify deployment packages distributed using `yarn` that implement the `dist` sub-directory convention.
-
-By default, utopia includes a `.yarnrc` file which installs modules into `lib/components`. This code can then be copied into `public/_components` using `bake utopia:yarn:update`.
-
-## Installing Yarn
-
-If you don't already have yarn installed, make sure you have npm installed and then run the following command:
-
-```bash
-$ sudo npm install -g yarn
-```
-
-## Installing jQuery
-
-Firstly, ensure your project has a `package.json` file:
-
-```bash
-$ yarn init
-```
-
-Then install jquery using `yarn`:
-
-```bash
-$ yarn install jquery
-```
-
-Copy the distribution scripts to `public/_components`:
-
-```bash
-$ bundle exec bake utopia:yarn:update
-```
-
-Then add the appropriate `<script>` tags to `pages/_page.xnode`:
-
-```html
-<script type="text/javascript" src="/_components/jquery/jquery.min.js"></script>
-```
-
-## Using JavaScript
-
-You can use JavaScript by embedding it directly into your HTML, or by creating a JavaScript source file and referencing that.
-
-### Embedding Code
-
-In your HTML view:
-
-```trenni
-<html>
-  <body>
-    <script type="text/javascript">
-      //<![CDATA[
-      console.log("Hello World")
-      //]]>
-    </script>
-  </body>
-</html>
-```
-
-### External Script
-
-In `script.js`:
-
-```javascript
-console.log("Hello World")
-```
-
-In your HTML view:
-
-```trenni
-<html>
-  <body>
-    <script type="text/javascript" src="script.js"></script>
-  </body>
-</html>
-```

data/wiki/pages/javascript/links.yaml

@@ -1,2 +0,0 @@
-index:
-  title: JavaScript

data/wiki/pages/links.yaml

@@ -1,2 +0,0 @@
-index:
-  title: Wiki

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

@@ -1,21 +0,0 @@
-# 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)
-```
-
-A basic template `create.xnode` looks something like:
-
-```trenni
-<content:page>
-	<content:heading>Create User</content:heading>
-	<form action="#">
-		<input name="name" />
-		<input type="submit" />
-	</form>
-</content: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/wiki/pages/middleware/controller/actions/index.md

@@ -1,76 +0,0 @@
-# Controller::Actions
-
-Actions let you match path patterns in your controller and execute code. In your `controller.rb` simply add:
-
-```ruby
-prepend Actions
-```
-
-If you are adding multiple things, like rewriting, they should come earlier in the chain, e.g:
-
-```ruby
-prepend Rewrite, Actions
-```
-
-A simple CRUD controller might look like:
-
-```ruby
-prepend Actions
-
-on 'index' do
-	@users = User.all
-end
-
-on 'new' do |request|
-	@user = User.new
-	
-	if request.post?
-		@user.update_attributes(request.params['user'])
-		
-		redirect! "index"
-	end
-end
-
-on 'edit' do |request|
-	@user = User.find(request.params['id'])
-	
-	if request.post?
-		@user.update_attributes(request.params['user'])
-		
-		redirect! "index"
-	end
-end
-
-on 'delete' do |request|
-	User.find(request.params['id']).destroy
-	
-	redirect! "index"
-end
-```
-	
-## Path Matching
-
-Path matching works from right to left, and `'**'` is a greedy operator. Controllers are invoked with a path relative to the controller's `URI_PATH`, so all lookups are relative to the controller.
-
-<dl>
-	<dt><code class="language-ruby">"*"</code></dt>
-	<dd>Match a single path element</dd>
-	<dt><code class="language-ruby">"**"</code></dt>
-	<dd>Match all remaining path elements</dd>
-	<dt><code class="language-ruby">String</code></dt>
-	<dd>Match a named path component, e.g. <code class="language-ruby">"edit"</code>.</dd>
-	<dt><code class="language-ruby">Symbol</code></dt>
-	<dd>Equivalent to <code class="language-ruby">["**", symbol.to_s]</code>, e.g. <code class="language-ruby">:logout</code>.</dd>
-</dl>
-
-## Otherwise Matching
-
-If no action was matched, it is sometimes useful to perform some specific behaviour. You can specify this by using the otherwise handler:
-
-```ruby
-otherwise do |request, path|
-	fail! :teapot
-end
-```
-
-If you are doing this to perform some kind of rewriting, it may be preferable to use the [Rewrite](../rewrite/) controller layer.

data/wiki/pages/middleware/controller/index.md

@@ -1,62 +0,0 @@
-# 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
-```