calyx 0.20.0 → 0.21.0

data/docs/assets/logos/calyx-flower-1.svg

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-    <svg width="400px"
-         height="400px"
-         version="1.1"
-         xmlns="http://www.w3.org/2000/svg"
-         xmlns:xlink="http://www.w3.org/1999/xlink">
-      <defs>
-        <symbol id="petals">
-          <ellipse cx="200" cy="120" rx="37" ry="80" /><ellipse cx="200" cy="280" rx="37" ry="80" /><ellipse cx="280" cy="200" rx="80" ry="37" /><ellipse cx="120" cy="200" rx="80" ry="37" />
-        </symbol>
-        <symbol id="corolla">
-          <use xlink:href="#petals" />
-          <use xlink:href="#petals" transform="rotate(22.5 200 200)" />
-          <use xlink:href="#petals" transform="rotate(45 200 200)" />
-          <use xlink:href="#petals" transform="rotate(-22.5 200 200)" />
-        </symbol>
-      </defs>
-      <use xlink:href="#corolla" fill="#1BDE81" stroke="#2F5E52" stroke-width="16"/>
-      <use xlink:href="#corolla" fill="#76FABB" stroke="#2F5E52" stroke-width="18" transform="scale(0.80 0.80) translate(50 50)" />
-      <use xlink:href="#corolla" fill="#218764" stroke="#2F5E52" stroke-width="5" transform="scale(0.40 0.40) translate(300 300)" />
-    </svg>
-  

data/docs/assets/logos/calyx-flower-2.svg

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-    <svg width="400px"
-         height="400px"
-         version="1.1"
-         xmlns="http://www.w3.org/2000/svg"
-         xmlns:xlink="http://www.w3.org/1999/xlink">
-      <defs>
-        <symbol id="petals">
-          <ellipse cx="200" cy="120" rx="25" ry="80" /><ellipse cx="200" cy="280" rx="25" ry="80" /><ellipse cx="280" cy="200" rx="80" ry="25" /><ellipse cx="120" cy="200" rx="80" ry="25" />
-        </symbol>
-        <symbol id="corolla">
-          <use xlink:href="#petals" />
-          <use xlink:href="#petals" transform="rotate(22.5 200 200)" />
-          <use xlink:href="#petals" transform="rotate(45 200 200)" />
-          <use xlink:href="#petals" transform="rotate(-22.5 200 200)" />
-        </symbol>
-      </defs>
-      <use xlink:href="#corolla" fill="#1BDE81" stroke="#218764" stroke-width="10"/>
-      <use xlink:href="#corolla" fill="#76FABB" stroke="#1BDE81" stroke-width="18" transform="scale(0.80 0.80) translate(50 50)" />
-      <use xlink:href="#corolla" fill="#218764" stroke="#76FABB" stroke-width="15" transform="scale(0.40 0.40) translate(300 300)" />
-    </svg>

data/docs/content/documentation.html

@@ -1,20 +0,0 @@
----
-title: Documentation
-layout: page
-permalink: /docs/
----
-
-<div class="row">
-{% for section in site.data.docs %}
-  <div class="col">
-    <div class="menu">
-      <h2 class="menu-label"><a href="{{ section.permalink }}">{{ section.title }}</a></h2>
-      <ul class="menu-list">
-      {% for doc_page in section.pages %}
-        <li><a href="{{ doc_page.permalink }}">{{ doc_page.title }}</a></li>
-      {% endfor %}
-      </ul>
-    </div>
-  </div>
-{% endfor %}
-</div>

data/docs/content/examples.html

@@ -1,12 +0,0 @@
----
-title: Examples
-layout: page
-permalink: /examples/
----
-
-{% for example in site.data.examples %}
-<div class="card">
-  <h2><a href="{{ example.permalink }}">{{ example.title }}</a></h2>
-  <p>{{ example.description }}</p>
-</div>
-{% endfor %}

data/docs/content/examples/any-gradient.md

@@ -1,32 +0,0 @@
----
-layout: default
-title: Examples
-layout: page
-permalink: /examples/any-gradient
----
-
-# Examples
-
-The best way to get started quickly is to install the gem and run the examples locally.
-
-## Any Gradient
-
-Requires Roda and Rack to be available.
-
-```
-gem install roda
-```
-
-Demonstrates how to use Calyx to construct SVG graphics. **Any Gradient** generates a rectangle with a linear gradient of random colours.
-
-Run as a web server and preview the output in a browser (`http://localhost:9292`):
-
-```
-ruby examples/any_gradient.rb
-```
-
-Or generate SVG files via a command line pipe:
-
-```
-ruby examples/any_gradient > gradient1.xml
-```

data/docs/content/examples/faker.md

@@ -1,16 +0,0 @@
----
-layout: default
-title: Examples
-layout: page
-permalink: /examples/faker
----
-
-## Faker
-
-[Faker](https://github.com/stympy/faker) is a popular library for generating fake names and associated sample data like internet addresses, company names and locations.
-
-This example demonstrates how to use Calyx to reproduce the same functionality using custom lists defined in a YAML configuration file.
-
-```
-ruby examples/faker.rb
-```

data/docs/content/examples/tiny-woodland-bot.md

@@ -1,24 +0,0 @@
----
-layout: default
-title: Examples
-layout: page
-permalink: /examples/tiny-woodland-bot
----
-
-## Tiny Woodland Bot
-
-Requires the Twitter client gem and API access configured for a specific Twitter handle.
-
-```
-gem install twitter
-```
-
-Demonstrates how to use Calyx to make a minimal Twitter bot that periodically posts unique tweets. See [@tiny_woodland on Twitter](https://twitter.com/tiny_woodland) and the [writeup here](http://maetl.net/notes/storyboard/tiny-woodlands).
-
-```
-TWITTER_CONSUMER_KEY=XXX-XXX
-TWITTER_CONSUMER_SECRET=XXX-XXX
-TWITTER_ACCESS_TOKEN=XXX-XXX
-TWITTER_CONSUMER_SECRET=XXX-XXX
-ruby examples/tiny_woodland_bot.rb
-```

data/docs/content/guides/context.md

@@ -1,45 +0,0 @@
----
-layout: page
-title: Context
-permalink: /guides/context
----
-
-j,jnnnnnnjjj
-
-## Constructing rules
-
-To achieve particular effects, structured repetition of grammar rules can be extremely useful, but these sets of rules can be boring and error-prone to write by hand.
-
-```ruby
-row "{point}{point}{point}{point}{point}{point}{point}{point}{point}{point}{point}{point}"
-```
-
-An easier
-
-```ruby
-row (0..12).map { "{point}" }.join
-```
-
-## Injecting rules
-
-Sometimes it’s useful to calculate template expansions outside of Calyx and inject them where they’re needed, rather than rely on the hard-coded rules defined in grammar classes and object instances.
-
-The `#generate` method accepts an optional context map parameter which can be used to dynamically combine rules with an existing grammar during the generation process. This feature is generally used like a traditional template engine to substitute individual values that aren’t known ahead of time.
-
-The context map is a hash, with the keys being symbols defining the rules and the values being template expansion strings.
-
-The following example demonstrates how a field returned from a database query could be injected into a grammar to produce a randomized welcome message for users of an app.
-
-```ruby
-greeting = Calyx::Grammar.new do
-  start 'Hi {username}', 'Welcome back {username}', 'Hola {username}'
-end
-
-user = User.find(id: user_id)
-
-context = {
-  username: user.name
-}
-
-greeting.generate(context)
-```

data/docs/content/guides/expressions.md

@@ -1,175 +0,0 @@
----
-layout: page
-title: Template Expressions
-permalink: /guides/expressions
----
-
-# Template Expressions
-
-Dot-notation is supported in template expressions, allowing you to call any available method on the `String` object returned from a rule. Formatting methods can be chained arbitrarily and will execute in the same way as they would in native Ruby code.
-
-```ruby
-greeting = Calyx::Grammar.new do
-  start '{hello.capitalize} there.', 'Why, {hello} there.'
-  hello 'hello', 'hi'
-end
-
-4.times { greeting.generate }
-# => "Hello there."
-# => "Hi there."
-# => "Why, hello there."
-# => "Why, hi there."
-```
-
-You can also extend the grammar with custom modifiers that provide useful formatting functions.
-
-### Filters
-
-Filters accept an input string and return the transformed output:
-
-```ruby
-greeting = Calyx::Grammar.new do
-  filter :shoutycaps do |input|
-    input.upcase
-  end
-
-  start '{hello.shoutycaps} there.', 'Why, {hello.shoutycaps} there.'
-  hello 'hello', 'hi'
-end
-
-4.times { greeting.generate }
-# => "HELLO there."
-# => "HI there."
-# => "Why, HELLO there."
-# => "Why, HI there."
-```
-
-### Mappings
-
-The mapping shortcut allows you to specify a map of regex patterns pointing to their resulting substitution strings:
-
-```ruby
-green_bottle = Calyx::Grammar.new do
-  mapping :pluralize, /(.+)/ => '\\1s'
-  start 'One green {bottle}.', 'Two green {bottle.pluralize}.'
-  bottle 'bottle'
-end
-
-2.times { green_bottle.generate }
-# => "One green bottle."
-# => "Two green bottles."
-```
-
-### Modifier Mixins
-
-In order to use more intricate rewriting and formatting methods in a modifier chain, you can add methods to a module and embed it in a grammar using the `modifier` classmethod.
-
-Modifier methods accept a single argument representing the input string from the previous step in the expression chain and must return a string, representing the modified output.
-
-```ruby
-module FullStop
-  def full_stop(input)
-    input << '.'
-  end
-end
-
-hello = Calyx::Grammar.new do
-  modifier FullStop
-  start '{hello.capitalize.full_stop}'
-  hello 'hello'
-end
-
-hello.generate
-# => "Hello."
-```
-
-To share custom modifiers across multiple grammars, you can include the module in `Calyx::Modifiers`. This will make the methods available to all subsequent instances:
-
-```ruby
-module FullStop
-  def full_stop(input)
-    input << '.'
-  end
-end
-
-class Calyx::Modifiers
-  include FullStop
-end
-```
-
-### Monkeypatching String
-
-Alternatively, you can combine methods from existing Gems that monkeypatch `String`:
-
-```ruby
-require 'indefinite_article'
-
-module FullStop
-  def full_stop
-    self << '.'
-  end
-end
-
-class String
-  include FullStop
-end
-
-noun_articles = Calyx::Grammar.new do
-  start '{fruit.with_indefinite_article.capitalize.full_stop}'
-  fruit 'apple', 'orange', 'banana', 'pear'
-end
-
-4.times { noun_articles.generate }
-# => "An apple."
-# => "An orange."
-# => "A banana."
-# => "A pear."
-```
-
-### Memoized Rules
-
-Rule expansions can be ‘memoized’ so that multiple references to the same rule return the same value. This is useful for picking a noun from a list and reusing it in multiple places within a text.
-
-The `@` sigil is used to mark memoized rules. This evaluates the rule and stores it in memory the first time it’s referenced. All subsequent references to the memoized rule use the same stored value.
-
-```ruby
-# Without memoization
-grammar = Calyx::Grammar.new do
-  start '{name} <{name.downcase}>'
-  name 'Daenerys', 'Tyrion', 'Jon'
-end
-
-3.times { grammar.generate }
-# => Daenerys <jon>
-# => Tyrion <daenerys>
-# => Jon <tyrion>
-
-# With memoization
-grammar = Calyx::Grammar.new do
-  start '{@name} <{@name.downcase}>'
-  name 'Daenerys', 'Tyrion', 'Jon'
-end
-
-3.times { grammar.generate }
-# => Tyrion <tyrion>
-# => Daenerys <daenerys>
-# => Jon <jon>
-```
-
-Note that the memoization symbol can only be used on the right hand side of a production rule.
-
-### Unique Rules
-
-Rule expansions can be marked as ‘unique’, meaning that multiple references to the same rule always return a different value. This is useful for situations where the same result appearing twice would appear awkward and messy.
-
-Unique rules are marked by the `$` sigil.
-
-```ruby
-grammar = Calyx::Grammar.new do
-  start "{$medal}, {$medal}, {$medal}"
-  medal 'Gold', 'Silver', 'Bronze'
-end
-
-grammar.generate
-# => Silver, Bronze, Gold
-```

data/docs/content/guides/features.md

@@ -1,50 +0,0 @@
----
-layout: docs
-title: Features documented in README
----
-
-## Template Expressions
-
-Basic rule substitution uses single curly brackets as delimiters for template expressions:
-
-```ruby
-fruit = Calyx::Grammar.new do
-  start '{colour} {fruit}'
-  colour 'red', 'green', 'yellow'
-  fruit 'apple', 'pear', 'tomato'
-end
-
-6.times { fruit.generate }
-# => "yellow pear"
-# => "red apple"
-# => "green tomato"
-# => "red pear"
-# => "yellow tomato"
-# => "green apple"
-```
-
-## The start symbol
-
-By convention, the `start` rule specifies the default starting point for generating the final text. You can start from any other named rule by passing it explicitly to the generate method.
-
-```ruby
-class HelloWorld < Calyx::Grammar
-  hello 'Hello world!'
-end
-
-hello = HelloWorld.new
-hello.generate(:hello)
-```
-
-## Block Constructors
-
-As an alternative to subclassing, you can also construct rules unique to an instance by passing a block when initializing the class:
-
-```ruby
-hello = Calyx::Grammar.new do
-  start '{greeting} world.'
-  greeting 'Hello', 'Hi', 'Hey', 'Yo'
-end
-
-hello.generate
-```

data/docs/content/guides/formats.md

@@ -1,37 +0,0 @@
----
-layout: default
-title: File Formats
-permalink: /guides/formats
----
-
-# File Formats
-
-In addition to defining grammars in pure Ruby, you can load them from external JSON and YAML files:
-
-```ruby
-hello = Calyx::Grammar.load('hello.yml')
-hello.generate
-```
-
-The format requires a flat map with keys representing the left-hand side named symbols and the values representing the right hand side substitution rules.
-
-In JSON:
-
-```json
-{
-  "start": "{greeting} world.",
-  "greeting": ["Hello", "Hi", "Hey", "Yo"]
-}
-```
-
-In YAML:
-
-```yaml
----
-start: "{greeting} world."
-greeting:
-  - Hello
-  - Hi
-  - Hey
-  - Yo
-```