scribble 1.0.0

data/lib/scribble/version.rb

@@ -0,0 +1,3 @@
+module Scribble
+  VERSION = "1.0.0"
+end

data/scribble.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'scribble/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "scribble"
+  spec.version       = Scribble::VERSION
+  spec.authors       = ["Stefan Kroes"]
+  spec.email         = ["stefan.kroes@lab01.nl"]
+  spec.summary       = "Scribble is a client facing template language similar to Liquid build in Ruby"
+  spec.description   = "Scribble is a client facing template language similar to Liquid. Scribble was written in Ruby and can be used in any Ruby or Ruby on Rails project. It takes a template file, consisting of text and Scribble tags and transforms it into text. Scribble can be used to transform any plain text format like HTML, Markdown, JSON, XML, etc. Client facing means that it is safe to use Scribble to run/evaluate user provided templates."
+  spec.homepage      = "https://github.com/stefankroes/scribble"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "parslet", "~> 1.6"
+end

data/test/all.rb

@@ -0,0 +1,23 @@
+# Parsing
+
+require_relative 'parsing/parsing_test'
+
+# Main components
+
+require_relative 'registry_test'
+require_relative 'template_test'
+require_relative 'errors_test'
+
+# Object registrations
+
+require_relative 'objects/boolean_test'
+require_relative 'objects/fixnum_test'
+require_relative 'objects/nil_test'
+require_relative 'objects/string_test'
+
+# Method registrations
+
+require_relative 'methods/if_test'
+require_relative 'methods/layout_test'
+require_relative 'methods/partial_test'
+require_relative 'methods/times_test'

data/test/errors_test.rb

@@ -0,0 +1,94 @@
+require_relative 'test_helper'
+
+describe Scribble do
+  it 'provides syntax errors' do
+    assert_scribble_raises '{{ + 1 }}',     Scribble::Errors::Syntax, "Unexpected '+' at line 1 column 4, expected '(', 'end', '}}' or a value"
+    assert_scribble_raises '{{ 1 + }}',     Scribble::Errors::Syntax, "Unexpected '}' at line 1 column 8, expected '(' or a value"
+    assert_scribble_raises '{{ 1 + ( ) }}', Scribble::Errors::Syntax, "Unexpected ')' at line 1 column 10, expected '(' or a value"
+    assert_scribble_raises '{{ if',         Scribble::Errors::Syntax, "Unexpected end of template at line 1 column 6, expected '(', '}}' or an operator"
+    assert_scribble_raises '{{ if {{',      Scribble::Errors::Syntax, "Unexpected '{' at line 1 column 7, expected '(', '}}', a value or an operator"
+    assert_scribble_raises '{{ \' }} ',     Scribble::Errors::Syntax, "Unexpected end of template at line 1 column 9; unterminated string"
+  end
+
+  it 'provides syntax errors for inproper block nesting' do
+    assert_scribble_raises '{{ if }}',      Scribble::Errors::Syntax, "Unexpected end of template; unclosed 'if' block at line 1 column 4"
+    assert_scribble_raises '{{ end }}',     Scribble::Errors::Syntax, "Unexpected 'end' at line 1 column 4; no block currently open"
+  end
+
+  it 'provides syntax errors for unexpected split methods' do
+    assert_scribble_raises '{{ if false }}{{ else }}{{ else }}{{ end }}', Scribble::Errors::Syntax, "Unexpected 'else' at line 1 column 28"
+  end
+
+  it 'provides syntax errors for unexpected block methods' do
+    assert_scribble_raises '{{ if if false }}{{ end }}', Scribble::Errors::Syntax, "Unexpected 'if' at line 1 column 7; block methods can't be arguments"
+  end
+
+  it 'provides undefined errors' do
+    assert_scribble_raises '{{ foo }}',         Scribble::Errors::Undefined, "Undefined variable or method 'foo' at line 1 column 4"
+    assert_scribble_raises '{{ partial foo }}', Scribble::Errors::Undefined, "Undefined variable or method 'foo' at line 1 column 12"
+    assert_scribble_raises '{{ foo() }}',       Scribble::Errors::Undefined, "Undefined method 'foo' at line 1 column 4"
+    assert_scribble_raises '{{ foo 1 }}',       Scribble::Errors::Undefined, "Undefined method 'foo' at line 1 column 4"
+  end
+
+  it 'provides arity errors' do
+    Scribble::Registry.reset do
+      Scribble::Registry.for Fixnum do
+        method :qux
+        method :qux, Fixnum, String, [String, 1]
+        method :qux, Fixnum, String, String, String, String, [Fixnum]
+      end
+
+      assert_scribble_raises '{{ partial }}', Scribble::Errors::Arity, "Wrong number of arguments (0 for 1-2) for 'partial' at line 1 column 4"
+      assert_scribble_raises '{{ 0.add }}',   Scribble::Errors::Arity, "Wrong number of arguments (0 for 1) for 'add' at line 1 column 6"
+      assert_scribble_raises '{{ 0.qux 0 }}', Scribble::Errors::Arity, "Wrong number of arguments (1 for 0, 2-3 or 5+) for 'qux' at line 1 column 6"
+    end
+  end
+
+  it 'provides argument errors' do
+    Scribble::Registry.reset do
+      Scribble::Registry.for Fixnum do
+        method :qux, [Fixnum], String
+      end
+
+      assert_scribble_raises '{{ partial 1 }}',   Scribble::Errors::Argument, "Expected string as 1st argument to 'partial', got number at line 1 column 12"
+      assert_scribble_raises '{{ 0.qux 1 }}',     Scribble::Errors::Argument, "Expected string as 2nd argument to 'qux' at line 1 column 6"
+      assert_scribble_raises "{{ 0.qux '', 1 }}", Scribble::Errors::Argument, "Unexpected 2nd argument to 'qux', got number at line 1 column 14"
+    end
+  end
+
+  it 'provides specific argument errors with locations' do
+    assert_scribble_raises "{{ '' * -1 }}",         Scribble::Errors::Argument, "Can't repeat string a negative number of times at line 1 column 7"
+    assert_scribble_raises "{{ ''.truncate(-1) }}", Scribble::Errors::Argument, "Can't truncate string with a negative length at line 1 column 7"
+    assert_scribble_raises "{{ 1 / 0 }}",           Scribble::Errors::Argument, 'Division by zero at line 1 column 6'
+  end
+
+  it 'combines errors generated in nested contexts' do
+    Scribble::Registry.reset do
+      class SomeBlock < Scribble::Block
+        def foo; render; end; register :foo
+        method :bar, Fixnum, returns: 'bar'
+        method :baz, Fixnum, [Fixnum], returns: 'baz'
+      end
+
+      class SomeMethod < Scribble::Method
+        def baz string; 'baz'; end; register :baz, String
+      end
+
+      assert_scribble_raises '{{ foo }}{{ bar }}{{ end }}',      Scribble::Errors::Arity, "Wrong number of arguments (0 for 1) for 'bar' at line 1 column 13"
+      assert_scribble_raises '{{ foo }}{{ baz }}{{ end }}',      Scribble::Errors::Arity, "Wrong number of arguments (0 for 1 or 1+) for 'baz' at line 1 column 13"
+      assert_scribble_raises '{{ foo }}{{ baz true }}{{ end }}', Scribble::Errors::Argument, "Expected string or number as 1st argument to 'baz', got boolean at line 1 column 17"
+    end
+  end
+
+  it 'does not call split methods from a nested context' do
+    Scribble::Registry.reset do
+      class SomeBlock < Scribble::Block
+        register :foo
+        def foo; render; end
+        method :bar, split: true
+      end
+
+      assert_scribble_raises '{{ foo }}{{ if true }}{{ bar }}{{ end }}{{ end }}', Scribble::Errors::Undefined, "Undefined variable or method 'bar' at line 1 column 26"
+    end
+  end
+end

data/test/methods/if_test.rb

@@ -0,0 +1,49 @@
+require_relative '../test_helper'
+
+describe Scribble::Methods::If do
+  it 'renders according if-elsif-else semantics' do
+    assert_scribble_render '{{ if true  }}Foo {{ end }}Bar', 'Foo Bar'
+    assert_scribble_render '{{ if false }}Foo {{ end }}Bar', 'Bar'
+
+    assert_scribble_render '{{ if true  }}Foo {{ else }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if false }}Foo {{ else }}Bar {{ end }}Baz', 'Bar Baz'
+
+    assert_scribble_render '{{ if true  }}Foo {{ elsif true  }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if false }}Foo {{ elsif true  }}Bar {{ end }}Baz', 'Bar Baz'
+    assert_scribble_render '{{ if true  }}Foo {{ elsif false }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if false }}Foo {{ elsif false }}Bar {{ end }}Baz', 'Baz'
+
+    assert_scribble_render '{{ if true  }}Foo {{ elsif true  }}Bar {{ else }}Qux {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if false }}Foo {{ elsif true  }}Bar {{ else }}Qux {{ end }}Baz', 'Bar Baz'
+    assert_scribble_render '{{ if true  }}Foo {{ elsif false }}Bar {{ else }}Qux {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if false }}Foo {{ elsif false }}Bar {{ else }}Qux {{ end }}Baz', 'Qux Baz'
+  end
+
+  it 'casts numbers to booleans' do
+    assert_scribble_render '{{ if 1 }}Foo {{ elsif 1 }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if 0 }}Foo {{ elsif 1 }}Bar {{ end }}Baz', 'Bar Baz'
+    assert_scribble_render '{{ if 1 }}Foo {{ elsif 0 }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if 0 }}Foo {{ elsif 0 }}Bar {{ end }}Baz', 'Baz'
+  end
+
+  it 'casts strings to booleans' do
+    assert_scribble_render '{{ if 1 }}Foo {{ elsif 1 }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if 0 }}Foo {{ elsif 1 }}Bar {{ end }}Baz', 'Bar Baz'
+    assert_scribble_render '{{ if 1 }}Foo {{ elsif 0 }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if 0 }}Foo {{ elsif 0 }}Bar {{ end }}Baz', 'Baz'
+  end
+
+  it 'works with boolean expressions' do
+    assert_scribble_render '{{ if 1 = 1       }}Foo {{ elsif 1 < 2   }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if 3 > 10      }}Foo {{ elsif 5 <= 10 }}Bar {{ end }}Baz', 'Bar Baz'
+    assert_scribble_render '{{ if 5 != 3      }}Foo {{ elsif 1.zero  }}Bar {{ end }}Baz', 'Foo Baz'
+    assert_scribble_render '{{ if (0.nonzero) }}Foo {{ elsif 5 < 0   }}Bar {{ end }}Baz', 'Baz'
+  end
+
+  it 'casts other expressions to booleans' do
+    assert_scribble_render "{{ if 1 + 1  }}Foo {{ elsif 'foo'.replace('foo', '') }}Bar {{ end }}Baz", 'Foo Baz'
+    assert_scribble_render "{{ if 1 - 1  }}Foo {{ elsif 3 * 'foo'                }}Bar {{ end }}Baz", 'Bar Baz'
+    assert_scribble_render "{{ if '   '  }}Foo {{ elsif '     '.strip            }}Bar {{ end }}Baz", 'Foo Baz'
+    assert_scribble_render "{{ if '' * 5 }}Foo {{ elsif 0.abs                    }}Bar {{ end }}Baz", 'Baz'
+  end
+end

data/test/methods/layout_test.rb

@@ -0,0 +1,71 @@
+require_relative '../test_helper'
+
+describe Scribble::Methods::Layout do
+  it 'loads and renders a layout template' do
+    loader = MockLoader.new test: 'Foo {{ content }} Baz'
+    assert_scribble_render "{{ layout 'test' }}Bar{{end}}", 'Foo Bar Baz', template: {loader: loader}
+  end
+
+  it 'evaluates expressions in the template' do
+    loader = MockLoader.new test: "{{ 'Foo' * 2 }} {{ content.repeat(2) }} Baz"
+    assert_scribble_render "{{ layout 'test' }}Bar{{end}}", 'FooFoo BarBar Baz', template: {loader: loader}
+  end
+
+  # Access
+
+  it 'has access to template methods' do
+    loader = MockLoader.new test: 'Foo {{ if true }}{{ content }} {{ end }}Baz'
+    assert_scribble_render "{{ layout 'test' }}Bar{{end}}", 'Foo Bar Baz', template: {loader: loader}
+  end
+
+  it 'has access to template variables' do
+    loader = MockLoader.new test: 'Foo {{ content }} Baz {{ 12 }}'
+    assert_scribble_render "{{ layout 'test' }}Bar{{end}}", 'Foo Bar Baz 12', template: {loader: loader}, variables: {foo: 12}
+  end
+
+  it 'has access to layout variables' do
+    skip # Implement var first
+  end
+
+  # Passing object and nesting
+
+  it 'exposes a second argument as a variable' do
+    loader = MockLoader.new test: '{{ test }} {{ content }}'
+    assert_scribble_render "{{ layout 'test', 'Foo' }}Bar {{end}}Baz", 'Foo Bar Baz', template: {loader: loader}
+  end
+
+  it 'exposes a second argument as a variable when nested' do
+    loader = MockLoader.new foo: "{{ foo }}{{ layout 'bar', content }}{{ foo }}{{ end }}{{ foo }}", bar: '{{ bar }}{{ content }}{{ bar }}'
+    assert_scribble_render "0{{ layout 'foo', 1 }}2{{end}}0", '0121210', template: {loader: loader}
+  end
+
+  # Formats
+
+  it 'adopts context format when no layout format is specified' do
+    loader = MockLoader.new foo: '{{ content }}'
+    assert_scribble_render "{{ layout 'foo' }}FOO{{ end }}", 'FOO', template: {loader: loader, format: :template_format}
+  end
+
+  it "won't need converter to render a layout in template format" do
+    loader = MockLoader.new foo: ['{{ content }}', :template_format]
+    assert_scribble_render "{{ layout 'foo' }}FOO{{ end }}", 'FOO', template: {loader: loader, format: :template_format}
+  end
+
+  it "can't render a layout with a format without suitable converters back and forth" do
+    loader = MockLoader.new foo: ['{{ content }}BAR', :layout_format]
+    c1 = MockConverter.new :layout_format, :template_format
+    c2 = MockConverter.new :template_format, :layout_format
+
+    assert_raises_message 'No suitable converter' do
+      Scribble::Template.new("{{ layout 'foo' }}FOO{{ end }}", loader: loader, format: :template_format, converters: [c1]).render
+    end
+
+    assert_raises_message 'No suitable converter' do
+      Scribble::Template.new("{{ layout 'foo' }}FOO{{ end }}", loader: loader, format: :template_format, converters: [c2]).render
+    end
+
+    assert_scribble_render "{{ layout 'foo' }}FOO{{ end }}", 'layout_format > template_format(template_format > layout_format(FOO)BAR)',
+      template: {loader: loader, format: :template_format, converters: [c1, c2]}
+  end
+
+end

data/test/methods/partial_test.rb

@@ -0,0 +1,85 @@
+require_relative '../test_helper'
+
+describe Scribble::Methods::Partial do
+  it 'loads and renders a partial template' do
+    loader = MockLoader.new test: 'Foo Bar Baz'
+    assert_scribble_render "{{ partial 'test' }}", 'Foo Bar Baz', template: {loader: loader}
+  end
+
+  it 'evaluates expressions in the template' do
+    loader = MockLoader.new test: '{{ 1 + 2 }}'
+    assert_scribble_render "{{ partial 'test' }}", '3', template: {loader: loader}
+  end
+
+  # Access
+
+  it 'has access to template methods' do
+    loader = MockLoader.new test: '{{ if true }}foo{{ else }}bar{{ end }}'
+    assert_scribble_render "{{ partial 'test' }}", 'foo', template: {loader: loader}
+  end
+
+  it 'has access to template variables' do
+    loader = MockLoader.new test: 'foo={{ foo }}, bar={{ bar }}, foo * bar={{ foo * bar }}'
+    assert_scribble_render "{{ partial 'test' }}", 'foo=3, bar=Foo, foo * bar=FooFooFoo', template: {loader: loader}, variables: {foo: 3, bar: 'Foo'}
+  end
+
+  it 'has access to template variables when nested' do
+    loader = MockLoader.new test: "{{ partial 'nested' }}", nested: '{{ foo }}'
+    assert_scribble_render "foo={{ partial 'test' }}", 'foo=3', template: {loader: loader}, variables: {foo: 3}
+  end
+
+  # Passing object
+
+  it 'exposes a second argument as a variable' do
+    loader = MockLoader.new test: '{{ test }}'
+    assert_scribble_render "{{ partial 'test', 'foo' }}", 'foo', template: {loader: loader}, variables: {foo: 3}
+  end
+
+  # Formats
+
+  it 'ignores partial format if no render format is specified' do
+    loader = MockLoader.new foo: ['FOO', :partial_format]
+    assert_scribble_render "{{ partial 'foo' }}", 'FOO', template: {loader: loader}
+  end
+
+  it 'adopts context format when no partial format is specified' do
+    loader = MockLoader.new foo: 'FOO'
+    assert_scribble_render "{{ partial 'foo' }}", 'FOO', template: {loader: loader, format: :template_format}
+  end
+
+  it "can't render a partial with format without a suitable converter" do
+    loader = MockLoader.new foo: ['FOO', :partial_format]
+    assert_raises_message 'No suitable converter' do
+      Scribble::Template.new("{{ partial 'foo' }}", loader: loader, format: :template_format).render
+    end
+  end
+
+  it "won't need converter to render a partial in template format" do
+    loader = MockLoader.new foo: ['FOO', :template_format]
+    assert_scribble_render "{{ partial 'foo' }}", 'FOO', template: {loader: loader, format: :template_format}
+  end
+
+  it "converts a partial with format to the template format using a suitable converter" do
+    loader = MockLoader.new foo: ['FOO', :partial_format]
+    converter = MockConverter.new :partial_format, :template_format
+    assert_scribble_render "{{ partial 'foo' }}", 'partial_format > template_format(FOO)',
+      template: {loader: loader, format: :template_format, converters: [converter]}
+  end
+
+  # Formats and nested partials
+
+  it "won't converted nested partials with the same format" do
+    loader = MockLoader.new test: ["{{ partial 'nested' }}", :partial_format], nested: ['NESTED', :partial_format]
+    converter = MockConverter.new :partial_format, :template_format
+    assert_scribble_render "{{ partial 'test' }}", 'partial_format > template_format(NESTED)',
+      template: {loader: loader, format: :template_format, converters: [converter]}
+  end
+
+  it "converts nested partials" do
+    loader = MockLoader.new test: ["{{ partial 'nested' }}", :partial_format], nested: ['NESTED', :nested_partial_format]
+    c1 = MockConverter.new :partial_format, :template_format
+    c2 = MockConverter.new :nested_partial_format, :partial_format
+    assert_scribble_render "{{ partial 'test' }}", 'partial_format > template_format(nested_partial_format > partial_format(NESTED))',
+      template: {loader: loader, format: :template_format, converters: [c1, c2]}
+  end
+end

data/test/methods/times_test.rb

@@ -0,0 +1,10 @@
+require_relative '../test_helper'
+
+describe Scribble::Methods::Times do
+  it 'repeats a block of content x times' do
+    assert_scribble_render "{{ 0.times }}Foo Bar {{ end }}", ''
+    assert_scribble_render "{{ 1.times }}Foo Bar {{ end }}", 'Foo Bar '
+    assert_scribble_render "{{ 3.times }}Foo Bar {{ end }}", 'Foo Bar Foo Bar Foo Bar '
+    assert_scribble_render "{{ 5.times }}Foo Bar {{ end }}", 'Foo Bar Foo Bar Foo Bar Foo Bar Foo Bar '
+  end
+end

data/test/objects/boolean_test.rb

@@ -0,0 +1,162 @@
+require_relative '../test_helper'
+
+describe 'scribble boolean' do
+  it 'can be used as a literal' do
+    assert_scribble_render '{{ true }}',  'true'
+    assert_scribble_render '{{ false }}', 'false'
+  end
+
+  it 'supports method and operator for logical or' do
+    assert_scribble_render '{{ false.or true }}',  'true'
+    assert_scribble_render '{{ true.or true }}',   'true'
+    assert_scribble_render '{{ false.or false }}', 'false'
+    assert_scribble_render '{{ true.or false }}',  'true'
+    assert_scribble_render '{{ false.or 2 }}',     'true'
+    assert_scribble_render '{{ true.or 2 }}',      'true'
+    assert_scribble_render '{{ false.or 0 }}',     'false'
+    assert_scribble_render '{{ true.or 0 }}',      'true'
+    assert_scribble_render "{{ false.or 'foo' }}", 'true'
+    assert_scribble_render "{{ true.or 'foo' }}",  'true'
+    assert_scribble_render "{{ false.or '' }}",    'false'
+    assert_scribble_render "{{ true.or '' }}",     'true'
+    assert_scribble_render '{{ false | true }}',   'true'
+    assert_scribble_render '{{ true | true }}',    'true'
+    assert_scribble_render '{{ false | false }}',  'false'
+    assert_scribble_render '{{ true | false }}',   'true'
+    assert_scribble_render '{{ false | 2 }}',      'true'
+    assert_scribble_render '{{ true | 2 }}',       'true'
+    assert_scribble_render '{{ false | 0 }}',      'false'
+    assert_scribble_render '{{ true | 0 }}',       'true'
+    assert_scribble_render "{{ false | 'foo' }}",  'true'
+    assert_scribble_render "{{ true | 'foo' }}",   'true'
+    assert_scribble_render "{{ false | '' }}",     'false'
+    assert_scribble_render "{{ true | '' }}",      'true'
+  end
+
+  it 'supports method and operator for logical and' do
+    assert_scribble_render '{{ false.and true }}',  'false'
+    assert_scribble_render '{{ true.and true }}',   'true'
+    assert_scribble_render '{{ false.and false }}', 'false'
+    assert_scribble_render '{{ true.and false }}',  'false'
+    assert_scribble_render '{{ false.and 2 }}',     'false'
+    assert_scribble_render '{{ true.and 2 }}',      'true'
+    assert_scribble_render '{{ false.and 0 }}',     'false'
+    assert_scribble_render '{{ true.and 0 }}',      'false'
+    assert_scribble_render "{{ false.and 'foo' }}", 'false'
+    assert_scribble_render "{{ true.and 'foo' }}",  'true'
+    assert_scribble_render "{{ false.and '' }}",    'false'
+    assert_scribble_render "{{ true.and '' }}",     'false'
+    assert_scribble_render '{{ false & true }}',    'false'
+    assert_scribble_render '{{ true & true }}',     'true'
+    assert_scribble_render '{{ false & false }}',   'false'
+    assert_scribble_render '{{ true & false }}',    'false'
+    assert_scribble_render '{{ false & 2 }}',       'false'
+    assert_scribble_render '{{ true & 2 }}',        'true'
+    assert_scribble_render '{{ false & 0 }}',       'false'
+    assert_scribble_render '{{ true & 0 }}',        'false'
+    assert_scribble_render "{{ false & 'foo' }}",   'false'
+    assert_scribble_render "{{ true & 'foo' }}",    'true'
+    assert_scribble_render "{{ false & '' }}",      'false'
+    assert_scribble_render "{{ true & '' }}",       'false'
+  end
+
+  it 'can equal another boolean' do
+    assert_scribble_render '{{ true.equals true }}',  'true'
+    assert_scribble_render '{{ true.equals false }}', 'false'
+    assert_scribble_render '{{ true = true }}',       'true'
+    assert_scribble_render '{{ true = false }}',      'false'
+  end
+
+  it 'does not equal another type' do
+    assert_scribble_render '{{ true.equals 3 }}',     'false'
+    assert_scribble_render "{{ true.equals 'foo' }}", 'false'
+    assert_scribble_render '{{ true = 3 }}',          'false'
+    assert_scribble_render "{{ true = 'foo' }}",      'false'
+  end
+
+  it 'can differ from another boolean' do
+    assert_scribble_render '{{ true.differs true }}',  'false'
+    assert_scribble_render '{{ true.differs false }}', 'true'
+    assert_scribble_render '{{ true != true }}',       'false'
+    assert_scribble_render '{{ true != false }}',      'true'
+  end
+
+  it 'differs from another type' do
+    assert_scribble_render '{{ true.differs 3 }}',     'true'
+    assert_scribble_render "{{ true.differs 'foo' }}", 'true'
+    assert_scribble_render '{{ true != 3 }}',          'true'
+    assert_scribble_render "{{ true != 'foo' }}",      'true'
+  end
+
+  it 'can not be compared' do
+    assert_scribble_raises "{{ true.greater 'foo' }}"
+    assert_scribble_raises '{{ true.greater 3 }}'
+    assert_scribble_raises '{{ true.greater true }}'
+    assert_scribble_raises "{{ true > 'foo' }}"
+    assert_scribble_raises '{{ true > 3 }}'
+    assert_scribble_raises '{{ true > true }}'
+    assert_scribble_raises "{{ true.less 'foo' }}"
+    assert_scribble_raises '{{ true.less 3 }}'
+    assert_scribble_raises '{{ true.less true }}'
+    assert_scribble_raises "{{ true < 'foo' }}"
+    assert_scribble_raises '{{ true < 3 }}'
+    assert_scribble_raises '{{ true < true }}'
+    assert_scribble_raises "{{ true.greater_or_equal 'foo' }}"
+    assert_scribble_raises '{{ true.greater_or_equal 3 }}'
+    assert_scribble_raises '{{ true.greater_or_equal true }}'
+    assert_scribble_raises "{{ true >= 'foo' }}"
+    assert_scribble_raises '{{ true >= 3 }}'
+    assert_scribble_raises '{{ true >= true }}'
+    assert_scribble_raises "{{ true.less_or_equal 'foo' }}"
+    assert_scribble_raises '{{ true.less_or_equal 3 }}'
+    assert_scribble_raises '{{ true.less_or_equal true }}'
+    assert_scribble_raises "{{ true <= 'foo' }}"
+    assert_scribble_raises '{{ true <= 3 }}'
+    assert_scribble_raises '{{ true <= true }}'
+  end
+
+  it 'does not support calculations' do
+    assert_scribble_raises '{{ true.add 3 }}'
+    assert_scribble_raises "{{ true.add 'foo' }}"
+    assert_scribble_raises '{{ true.add true }}'
+    assert_scribble_raises '{{ true + 3 }}'
+    assert_scribble_raises "{{ true + 'foo' }}"
+    assert_scribble_raises '{{ true + true }}'
+    assert_scribble_raises '{{ true.subtract 3 }}'
+    assert_scribble_raises "{{ true.subtract 'foo' }}"
+    assert_scribble_raises '{{ true.subtract true }}'
+    assert_scribble_raises '{{ true - 3 }}'
+    assert_scribble_raises "{{ true - 'foo' }}"
+    assert_scribble_raises '{{ true - true }}'
+    assert_scribble_raises '{{ true.multiply 3 }}'
+    assert_scribble_raises "{{ true.multiply 'foo' }}"
+    assert_scribble_raises '{{ true.multiply true }}'
+    assert_scribble_raises '{{ true * 3 }}'
+    assert_scribble_raises "{{ true * 'foo' }}"
+    assert_scribble_raises '{{ true * true }}'
+    assert_scribble_raises '{{ true.divide 3 }}'
+    assert_scribble_raises "{{ true.divide 'foo' }}"
+    assert_scribble_raises '{{ true.divide true }}'
+    assert_scribble_raises '{{ true / 3 }}'
+    assert_scribble_raises "{{ true / 'foo' }}"
+    assert_scribble_raises '{{ true / true }}'
+    assert_scribble_raises '{{ true.remainder 3 }}'
+    assert_scribble_raises "{{ true.remainder 'foo' }}"
+    assert_scribble_raises '{{ true.remainder true }}'
+    assert_scribble_raises '{{ true % 3 }}'
+    assert_scribble_raises "{{ true % 'foo' }}"
+    assert_scribble_raises '{{ true % true }}'
+  end
+
+  it 'can not be negated' do
+    assert_scribble_raises '{{ true.negative }}'
+    assert_scribble_raises '{{ -true }}'
+  end
+
+  it 'can be logically negated' do
+    assert_scribble_render '{{ true.not }}',  'false'
+    assert_scribble_render '{{ false.not }}', 'true'
+    assert_scribble_render '{{ !!true }}',    'true'
+    assert_scribble_render '{{ !!!true }}',   'false'
+  end
+end