l_system 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 586b85b2e6a2981b1d5835eedaf62c451eaa51b4cdd7894db564e100ada8c9e0
+  data.tar.gz: efe77e8d01d01759ee5780d9d28bc77c8f0fb355d5f98956ef1304797ded02bb
+SHA512:
+  metadata.gz: 44879d5a4397c4ab0899685fbd33d0b7df1d64c73596cc45cbc39801ae5bc1ec9343435b75bc0170c0cd3d6c6d54dc1b191f5622d2ce26695a9b9187d31438cc
+  data.tar.gz: b8778fe072f57c36eb92a547b38fc594cb2b1619f7d160395a5700c7c2bfc00cf853df9f9b40fe642d60fcdb37adeff9da3607e74793798181bd6697b75a2e79

checksums.yaml.gz.sig

@@ -0,0 +1,2 @@
+Y�Sn��㔎}��{'�Q6R
+e����?8t��.u��~?<hr��M�,U�>��F�^_�طQ3@v�PU�C��c�T~��Va�tq��5X�����~�Fe9�p�K��\8��H�?�-v1�YţZP��;:x��mY��_��}���v���Z2�vi$E�5�$sKi�H�O�)���f�"��^��6WSu�p��mr�q!�9�1]�EEV�$���)bT\��C����~EV�c�,�I��8":ȿD�LeX�;�	kx�z������A5h�F�_H�O��<6|�'ӟ�̥���P�1�ɳ�L.�

data/.simplecov

@@ -0,0 +1,9 @@
+# Simplecov config
+
+SimpleCov.start do
+	add_filter 'spec'
+	add_filter 'integration'
+	add_group "Needing tests" do |file|
+		file.covered_percent < 90
+	end
+end

data/History.md

@@ -0,0 +1,8 @@
+# Release History for l_system
+
+---
+
+## v0.1.0 [2020-02-26] Michael Granger <ged@faeriemud.org>
+
+Initial release.
+

data/README.md

@@ -0,0 +1,232 @@
+# LSystem
+
+home
+: https://hg.sr.ht/~ged/LSystem
+
+code
+: https://hg.sr.ht/~ged/LSystem
+
+github
+: https://github.com/ged/l_system
+
+docs
+: https://deveiate.org/code/l_system
+
+
+## Description
+
+A toolkit for creating and using [Lindenmayer Systems][l-system] (L-systems).
+It consists of a class that allows for declaration of the L-system's grammar,
+and another class that allows for the definition of how the symbols output by a
+grammar should be translated into work.
+
+
+### Examples
+
+Most of these were stolen from [the examples on Wikipedia][l-system], and can be found in the `examples/` directory of the source.
+
+#### Algae
+
+Lindenmayer's original L-system for modelling the growth of algae.
+
+* variables : A B
+* constants : none
+* axiom : A
+* rules : (A → AB), (B → A)
+
+Declare the rules:
+
+    algae = LSystem.declare do
+    
+    	variables :A, :B
+    	axiom 'A'
+    	rules 'A -> AB',
+    	    'B -> A'
+    
+    end
+
+then iterate it 8 times and print out each generation:
+
+    iter = algae.each
+    8.times do |i|
+        puts "n = %d : %s" % [ i, iter.next ]
+    end
+
+This outputs:
+
+    n = 0 : A
+    n = 1 : AB
+    n = 2 : ABA
+    n = 3 : ABAAB
+    n = 4 : ABAABABA
+    n = 5 : ABAABABAABAAB
+    n = 6 : ABAABABAABAABABAABABA
+    n = 7 : ABAABABAABAABABAABABAABAABABAABAAB
+
+
+You can also do more complex tasks with the symbols in each generation. For example, to generate pretty pictures.
+
+#### Barnsley fern
+
+* variables : X F
+* constants : + − [ ]
+* axiom : X
+* rules : (X → F+[[X]-X]-F[-FX]+X), (F → FF)
+* angle : 25°
+
+Declare the rules:
+
+    fern = LSystem.declare do
+    
+      variables 'X', 'F'
+      constants '+', '-', '[', ']'
+      axiom 'X'
+      rules \
+        'X → F+[[X]-X]-F[-FX]+X',
+        'F → FF'
+    
+    end
+
+Then hook them up to a Logo interpreter ([a monkeypatched version][tortoise-patch] of the [Tortoise gem][tortoise-gem]):
+
+    LSystem.run( fern, 8 ) do
+    
+      # The size of the canvas to draw on
+      CANVAS_SIZE = 2000
+    
+      # F: draw forward
+      # X : no-op
+      # -: turn left 25°
+      # +: turn right 25°
+      # [: push position and angle
+      # ]: pop position and angle
+      production_map \
+        'F' => :forward,
+        '-' => :turn_left,
+        '+' => :turn_right,
+        '[' => :save_pos_and_angle,
+        ']' => :restore_pos_and_angle
+    
+      ### Set up some instance variables
+      def initialize( * )
+        super
+        @turtle = nil
+        @positions = []
+      end
+    
+    
+      on_start do |i, _|
+        @turtle = Tortoise::Interpreter.new( CANVAS_SIZE )
+        @turtle.setpos( CANVAS_SIZE / 2, 0 )
+        @turtle.direction = 90
+        @turtle.pd
+      end
+    
+    
+      on_finish do |i, _|
+        File.open( "fern_gn#{i}.png", File::WRONLY|File::TRUNC|File::CREAT, 0644, encoding: 'binary' ) do |fh|
+          fh.write( @turtle.to_png )
+        end
+      end
+    
+    
+      ### Draw a line forward
+      def forward
+        @turtle.fd( 5 )
+      end
+    
+    
+      ### Turn 25° to the left
+      def turn_left
+        @turtle.lt( 25 )
+      end
+    
+    
+      ### Turn 25° to the right
+      def turn_right
+        @turtle.rt( 25 )
+      end
+    
+    
+      ### Save the drawing position and angle
+      def save_pos_and_angle
+        @positions.push([ @turtle.position, @turtle.direction ])
+      end
+    
+    
+      ### Restore the next saved position and angle
+      def restore_pos_and_angle
+        to_restore = @positions.pop or raise IndexError, "Position stack underflow"
+    
+        @turtle.setpos( *to_restore.first )
+        @turtle.direction = to_restore.last
+      end
+    
+    end
+
+This generates a sequence of images, which for generation 8 yields:
+
+![Fern Gen 7](examples/fern_gn7.png)
+
+
+## Prerequisites
+
+* Ruby
+
+
+## Installation
+
+    $ gem install l_system
+
+
+## Contributing
+
+You can check out the current development source with Mercurial via its
+[project page](https://hg.sr.ht/~ged/LSystem). Or if you prefer Git, via
+[its Github mirror](https://github.com/ged/l_system).
+
+After checking out the source, run:
+
+    $ rake setup
+
+This task will install dependencies, and do any other necessary setup for development.
+
+
+## Authors
+
+- Michael Granger <ged@faeriemud.org>
+
+
+## License
+
+Copyright (c) 2020, Michael Granger
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the author/s, nor the names of the project's
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+[l-system]: https://en.wikipedia.org/wiki/L-system
+

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby -S rake
+
+require 'rake'
+require 'rake/deveiate'
+
+EXAMPLE_IMAGES = Rake::FileList[ 'examples/*.png' ]
+
+
+Rake::DevEiate.setup( 'l_system' ) do |project|
+	project.publish_to = 'deveiate:/usr/local/www/public/code'
+end
+
+
+file EXAMPLE_IMAGES
+
+task :docs => EXAMPLE_IMAGES do
+	mkdir_p 'docs/examples/'
+	cp EXAMPLE_IMAGES.to_a, 'docs/examples/'
+end
+
+

data/lib/l_system/production_adapter.rb

@@ -0,0 +1,147 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'loggability'
+
+require 'l_system' unless defined?( LSystem )
+
+
+# An adapter that connects method calls to an LSystem::RulesEngine's
+# generations.
+class LSystem::ProductionAdapter
+	extend Loggability
+
+
+	# Loggability API -- log to the l_system logger
+	log_to :l_system
+
+
+	### Inheritance callback -- add class-instance variables to the +subclass+.
+	def self::inherited( subclass )
+		super
+
+		subclass.instance_variable_set( :@production_map, {} )
+		subclass.instance_variable_set( :@callbacks, {} )
+	end
+
+
+	#
+	# DSL Methods
+	#
+
+	### Declare a Hash of symbols to methods that should be called when one appears
+	### in a generation.
+	def self::production_map( productions={} )
+		unless productions.empty?
+			self.production_map = productions
+		end
+
+		return @production_map
+	end
+
+
+	### Set the Hash of symbols to methods that should be called when one appears in
+	### a generation.
+	def self::production_map=( new_map )
+		@production_map.replace( new_map )
+	end
+
+
+	### Register a callback that will be called at the start of each new generation.
+	### It will be called with the result of the last generation, or +nil+ if this
+	### is the 0th (axiom) generation.
+	def self::on_start( &block )
+		self.log.debug "Declaring on_start callback: %p" % [ block ]
+		define_method( :on_start, &block )
+	end
+
+
+	### Register a callback that will be called to obtain the result of running a
+	### generation. The result of calling the +block+ will be passed to this
+	### generation's #on_finish callback (if there is one), the next generation's
+	### #on_start callback (if there is one and there's successive geneation), and
+	### returned from #run if this was the last generation.
+	def self::result( &block )
+		self.log.debug "Declaring result callback: %p" % [ block ]
+		define_method( :result, &block )
+	end
+
+
+	### Register a callback that will be called at the end of each new generation.
+	### It will be called with the result of the this generation, which will be
+	### +nil+ if no #result callback is declared.
+	def self::on_finish( &block )
+		self.log.debug "Declaring on_finish callback: %p" % [ block ]
+		define_method( :on_finish, &block )
+	end
+
+
+	#
+	# Instance methods
+	#
+
+	### Create a new instance of the ProductionAdapter.
+	def initialize
+		@production_map = self.class.production_map
+	end
+
+
+	######
+	public
+	######
+
+	##
+	# The map of symbols to production methods
+	attr_reader :production_map
+
+
+	### Run productions for each generation produced by the given +rules_engine+ up to
+	### +iterations+ times.
+	def run( rules_engine, iterations )
+		self.log.debug "Running %p for up to %d iterations" % [ rules_engine, iterations ]
+
+		return rules_engine.each.with_index.inject( nil ) do |result, (generation, i)|
+			self.log.debug "Running generation %d" % [ i ]
+			self.on_start( i, result ) if self.respond_to?( :on_start )
+			self.run_generation( generation )
+			result = self.result( i ) if self.respond_to?( :result )
+			self.log.debug "Result [%d] is: %p" % [ i, result ]
+			self.on_finish( i, result ) if self.respond_to?( :on_finish )
+
+			break result if i >= iterations - 1
+			result
+		end
+	end
+
+
+	### Run the specified +generation+ by calling productions for each of its
+	### symbols.
+	def run_generation( generation )
+
+		# Make a new one every time to support self-mutating adapters
+		dispatch_table = self.make_dispatch_table
+
+		generation.each_char do |symbol|
+			callback = dispatch_table[ symbol ]
+
+			unless callback
+				self.log.warn "No production for symbol %p" % [ symbol ]
+				next
+			end
+
+			self.log.debug "%p -> %p" % [ symbol, callback ]
+			callback.call
+		end
+	end
+
+
+	### Return a Hash of symbols to bound Methods to call for their productions from
+	### the current #production_map.
+	def make_dispatch_table
+		return self.class.production_map.each_with_object( {} ) do |(symbol, method_name), hash|
+			hash[ symbol ] = self.method( method_name )
+		end
+	end
+
+end # class LSystem::ProductionAdapter
+

data/lib/l_system/rules_engine.rb

@@ -0,0 +1,185 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'set'
+require 'loggability'
+
+require 'l_system' unless defined?( LSystem )
+
+
+# An engine for iterating over successive applications of the L-System's
+# ruleset to its axiom.
+class LSystem::RulesEngine
+	extend Loggability
+
+
+	# Loggability API -- log to the l_system logger
+	log_to :l_system
+
+
+	### Create a new rules engine for an L-System. If the +block+ is present,
+	### it is called with the new instance as +self+.
+	def initialize( &block )
+		@variables = Set.new
+		@constants = Set.new
+		@axiom = nil
+		@rules = []
+
+		@rules_as_hash = nil
+
+		self.instance_eval( &block ) if block
+	end
+
+
+	######
+	public
+	######
+
+	#
+	# DSL Methods
+	#
+
+	### Get/set the system's variables (the replaceable parts of its alphabet).
+	def variables( *new_values )
+		self.variables = new_values unless new_values.empty?
+		return @variables.dup
+	end
+
+
+	### Set the systems variables to +new_values+.
+	def variables=( new_values )
+		@rules_as_hash = nil
+
+		new_values = Set.new( new_values, &:to_s )
+		unless new_values.disjoint?( self.constants )
+			common_char = (new_values & self.constants).to_a.first
+			raise ArgumentError, "%p is already included in the constant set" % [ common_char ]
+		end
+
+		@variables = new_values
+	end
+
+
+	### Get/set the system's constants (the static parts of its alphabet).
+	def constants( *new_values )
+		self.constants = new_values unless new_values.empty?
+		return @constants.dup
+	end
+
+
+	### Set the systems constants to +new_values+.
+	def constants=( new_values )
+		@rules_as_hash = nil
+
+		new_values = Set.new( new_values, &:to_s )
+		unless new_values.disjoint?( self.variables )
+			common_char = (new_values & self.variables).to_a.first
+			raise ArgumentError, "%p is already included in the variable set" % [ common_char ]
+		end
+
+		@constants = new_values
+	end
+
+
+	### Return the system's variables and constants.
+	def alphabet
+		return @variables | @constants
+	end
+
+
+	### Get/set the axiom of the system.
+	def axiom( new_value=nil )
+		self.axiom = new_value if new_value
+		return @axiom
+	end
+
+
+	### Set the axiom of the system.
+	def axiom=( new_value )
+		@axiom = new_value
+	end
+
+
+	### Get/set the system's rules.
+	def rules( *new_values )
+		self.rules = new_values unless new_values.empty?
+		return @rules
+	end
+
+
+	### Set the system's rules.
+	def rules=( new_values )
+		@rules_as_hash = nil
+		@rules = Array( new_values ).map( &:to_s )
+	end
+
+
+	#
+	# Iteration API
+	#
+
+	### Apply the system's rules to the given +state+ and return the result.
+	def apply_rules( state )
+		rules_hash = self.rules_as_hash
+		return state.each_char.with_object( String.new(encoding: 'utf-8') ) do |char, new_state|
+			new_state << rules_hash[ char ]
+		end
+	end
+
+
+	### Yield each successive generation to the given +block+, or return an
+	### Enumerator that will do so if no block is given.
+	def each( &block )
+		iter = Enumerator.new do |yielder|
+			state = new_state = self.axiom.dup
+
+			begin
+				yielder.yield( new_state )
+				state = new_state
+				new_state = self.apply_rules( state )
+			end until state == new_state
+		end
+
+		return iter unless block
+		return iter.each( &block )
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Return a Hash of tranforms that should be applied to a state during a
+	### generation.
+	def rules_as_hash
+		unless @rules_as_hash
+			@rules_as_hash = self.rules.each_with_object( {} ) do |rule, hash|
+				pred, succ = self.parse_rule( rule )
+				hash[ pred ] = succ
+			end
+
+			self.alphabet.each do |char|
+				@rules_as_hash[ char ] = char unless @rules_as_hash.key?( char )
+			end
+		end
+
+		return @rules_as_hash
+	end
+
+
+	### Return a tuple of the predecessor and successor of the given +rule+.
+	def parse_rule( rule )
+		predecessor, successor = rule.strip.split( /\s*(?:->|→)\s*/, 2 )
+		self.log.debug "Parsed rule: %p -> %p" % [ predecessor, successor ]
+		successor_set = Set.new( successor.chars )
+
+		raise "Invalid rule: predecessor %p is not in the variable set %p" %
+			[ predecessor, self.variables ] unless self.variables.include?( predecessor )
+		raise "Invalid rule: successor %p contains characters not in the alphabet %p" %
+			[ successor, self.alphabet ] unless self.alphabet.superset?( successor_set )
+
+		return predecessor, successor
+	end
+
+end # class LSystem::RulesEngine
+

data/lib/l_system.rb

@@ -0,0 +1,43 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'loggability'
+
+
+# A toolkit for creating and using Lindenmayer Systems.
+module LSystem
+	extend Loggability
+
+	# Package version
+	VERSION = '0.1.0'
+
+	# Version control revision
+	REVISION = %q$Revision$
+
+
+	# Loggability API -- set up a logger for l_system
+	log_as :l_system
+
+
+	autoload :RulesEngine, 'l_system/rules_engine'
+	autoload :ProductionAdapter, 'l_system/production_adapter'
+
+
+	### Declare a new L-System that is configured via the given +block+.
+	def self::declare( &block )
+		return LSystem::RulesEngine.new( &block )
+	end
+
+
+	### Run a +rules_engine+ at most the given number of +iterations+ using the productions
+	### declared in the +block+, which runs in the context of an anonymous
+	### LSystem::ProductionAdapter class.
+	def self::run( rules_engine, iterations=1000, &block )
+		raise LocalJumpError, "no block given" unless block
+
+		adapter = Class.new( LSystem::ProductionAdapter, &block )
+		return adapter.new.run( rules_engine, iterations )
+	end
+
+end # module LSystem
+

data/spec/l_system/production_adapter_spec.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'l_system/production_adapter'
+
+
+RSpec.describe( LSystem::ProductionAdapter ) do
+
+	let( :algae_rules ) do
+		LSystem.declare do
+			variables :A, :B
+			axiom 'A'
+			rules \
+				'A -> AB',
+				'B -> A'
+		end
+	end
+
+
+	describe "subclasses" do
+
+		let( :subclass ) do
+			Class.new( described_class ) do
+
+				def initialize
+					@calls = []
+				end
+
+				attr_reader :calls
+
+				def method_missing( sym, *args )
+					self.calls << sym
+				end
+
+				def respond_to_missing?( sym, include_all )
+					return super if [:on_start, :result, :on_finish].include?( sym )
+					return true
+				end
+
+			end
+		end
+
+
+		it "can declare a method map for its productions" do
+			subclass.production_map \
+				'A' => :do_a_thing,
+				'B' => :do_b_thing
+
+			instance = subclass.new
+			instance.run_generation( 'AABA' )
+
+			expect( instance.calls ).to eq([
+				:do_a_thing,
+				:do_a_thing,
+				:do_b_thing,
+				:do_a_thing,
+			])
+		end
+
+
+		it "handles symbols that don't make good method names" do
+			subclass.production_map \
+				'[' => :push_frame,
+				'A' => :report_depth,
+				']' => :pop_frame
+
+			instance = subclass.new
+			instance.run_generation( 'A[A[[]]A[]]]]' )
+
+			expect( instance.calls ).to eq([
+				:report_depth,
+				:push_frame,
+				:report_depth,
+				:push_frame,
+				:push_frame,
+				:pop_frame,
+				:pop_frame,
+				:report_depth,
+				:push_frame,
+				:pop_frame,
+				:pop_frame,
+				:pop_frame,
+				:pop_frame
+			])
+		end
+
+
+		it "can run a rules engine" do
+			subclass.production_map \
+				'A' => :report_a,
+				'B' => :report_b
+
+			instance = subclass.new
+			instance.run( algae_rules, 4 )
+
+			expect( instance.calls ).to eq([
+				:report_a,
+
+				:report_a,
+				:report_b,
+
+				:report_a,
+				:report_b,
+				:report_a,
+
+				:report_a,
+				:report_b,
+				:report_a,
+				:report_a,
+				:report_b,
+			])
+		end
+
+
+		it "can declare lifecycle callbacks" do
+			subclass.production_map \
+				'A' => :report_a,
+				'B' => :report_b
+			subclass.on_start do |i, previous_result|
+				self.calls << [ :on_start, i, previous_result ]
+			end
+			subclass.result do |i|
+				self.calls << [ :result, i ]
+				"result_#{i}"
+			end
+			subclass.on_finish do |i, result|
+				self.calls << [ :on_finish, i, result ]
+			end
+
+			instance = subclass.new
+			result = instance.run( algae_rules, 4 )
+
+			expect( instance.calls ).to eq([
+				[:on_start, 0, nil],
+				:report_a,
+				[:result, 0],
+				[:on_finish, 0, "result_0"],
+
+				[:on_start, 1, "result_0"],
+				:report_a,
+				:report_b,
+				[:result, 1],
+				[:on_finish, 1, "result_1"],
+
+				[:on_start, 2, "result_1"],
+				:report_a,
+				:report_b,
+				:report_a,
+				[:result, 2],
+				[:on_finish, 2, "result_2"],
+
+				[:on_start, 3, "result_2"],
+				:report_a,
+				:report_b,
+				:report_a,
+				:report_a,
+				:report_b,
+				[:result, 3],
+				[:on_finish, 3, "result_3"],
+			])
+
+			expect( result ).to eq( "result_3" )
+		end
+
+	end
+
+end
+

data/spec/l_system/rules_engine_spec.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'l_system/rules_engine'
+
+
+RSpec.describe( LSystem::RulesEngine ) do
+
+	let( :instance ) { described_class.new }
+
+
+	it "can set the l-system's variables" do
+		instance.variables = [ 'A', 'B' ]
+
+		expect( instance.variables ).to contain_exactly( 'A', 'B' )
+	end
+
+
+	it "can declare the l-system's variables" do
+		instance.variables 'A', 'B'
+
+		expect( instance.variables ).to contain_exactly( 'A', 'B' )
+	end
+
+
+	it "raises if variables are not disjoint with the constants" do
+		instance.variables 'A', 'B'
+		expect {
+			instance.constants '[', 'A', ']'
+		}.to raise_error( ArgumentError, /"A" is already included in the variable set/ )
+	end
+
+
+	it "can set the l-system's constants'" do
+		instance.constants = [ '[', ']' ]
+
+		expect( instance.constants ).to contain_exactly( '[', ']' )
+	end
+
+
+	it "can declare the l-system's constants'" do
+		instance.constants '[', ']'
+
+		expect( instance.constants ).to contain_exactly( '[', ']' )
+	end
+
+
+	it "raises if constants are not disjoint with the variables" do
+		instance.constants '[', 'A', ']'
+		expect {
+			instance.variables 'A', 'B'
+		}.to raise_error( ArgumentError, /"A" is already included in the constant set/ )
+	end
+
+
+	it "knows what its alphabet is" do
+		instance.variables '0', '1'
+		instance.constants '[', ']'
+
+		expect( instance.alphabet ).to contain_exactly( '0', '1', '[', ']' )
+	end
+
+
+	it "can apply its rules to a string" do
+		instance.variables 'A', 'B'
+		instance.rules 'A -> AB', 'B -> A'
+
+		expect( instance.apply_rules('A') ).to eq( 'AB' )
+		expect( instance.apply_rules('AB') ).to eq( 'ABA' )
+		expect( instance.apply_rules('ABA') ).to eq( 'ABAAB' )
+		expect( instance.apply_rules('ABAAB') ).to eq( 'ABAABABA' )
+		expect( instance.apply_rules('ABAABABA') ).to eq( 'ABAABABAABAAB' )
+		expect( instance.apply_rules('ABAABABAABAAB') ).to eq( 'ABAABABAABAABABAABABA' )
+		expect( instance.apply_rules('ABAABABAABAABABAABABA') ).
+			to eq( 'ABAABABAABAABABAABABAABAABABAABAAB' )
+	end
+
+
+	it "can create an enumerator that will yield each successive generation" do
+		instance.variables 'A', 'B'
+		instance.axiom 'A'
+		instance.rules 'A -> AB', 'B -> A'
+
+		result = instance.each
+
+		expect( result ).to be_an( Enumerator )
+		expect( result.next ).to eq( 'A' )
+		expect( result.next ).to eq( 'AB' )
+		expect( result.next ).to eq( 'ABA' )
+		expect( result.next ).to eq( 'ABAAB' )
+		expect( result.next ).to eq( 'ABAABABA' )
+		expect( result.next ).to eq( 'ABAABABAABAAB' )
+		expect( result.next ).to eq( 'ABAABABAABAABABAABABA' )
+		expect( result.next ).to eq( 'ABAABABAABAABABAABABAABAABABAABAAB' )
+	end
+
+end
+

data/spec/l_system_spec.rb

@@ -0,0 +1,61 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require_relative 'spec_helper'
+
+require 'rspec'
+require 'l_system'
+
+RSpec.describe( LSystem ) do
+
+	it "allows an L-System to be declared" do
+		result = described_class.declare {}
+		expect( result ).to be_an( LSystem::RulesEngine )
+	end
+
+
+	it "can run an L-System within the context of one or more productions" do
+		rules = described_class.declare do
+			variables :A, :B
+			axiom 'A'
+			rules 'A -> AB',
+				'B -> A'
+		end
+		result = described_class.run( rules, 8 ) do
+
+			production_map \
+				'A' => :append_A,
+				'B' => :append_B
+
+			on_start do |_generation_number, _previous_result|
+				@output = String.new( encoding: 'utf-8' )
+			end
+
+			result do |_generation_number|
+				@output
+			end
+
+			on_finish do |_generation_number, _result|
+				@output = nil
+			end
+
+
+			def initialize
+				@output = nil
+			end
+
+			def append_A
+				@output << 'A'
+			end
+
+			def append_B
+				@output << 'B'
+			end
+
+		end
+
+		expect( result ).to eq( 'ABAABABAABAABABAABABAABAABABAABAAB' )
+	end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'simplecov' if ENV['COVERAGE']
+
+require 'rspec'
+
+require 'loggability/spechelpers'
+
+
+### Mock with RSpec
+RSpec.configure do |config|
+	config.mock_with( :rspec ) do |mock|
+		mock.syntax = :expect
+	end
+
+	config.disable_monkey_patching!
+	config.example_status_persistence_file_path = "spec/.status"
+	config.filter_run :focus
+	config.filter_run_when_matching :focus
+	config.order = :random
+	config.profile_examples = 5
+	config.run_all_when_everything_filtered = true
+	config.shared_context_metadata_behavior = :apply_to_host_groups
+	# config.warnings = true
+
+	config.include( Loggability::SpecHelpers )
+end
+
+

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: l_system
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Granger
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIENDCCApygAwIBAgIBATANBgkqhkiG9w0BAQsFADAiMSAwHgYDVQQDDBdnZWQv
+  REM9RmFlcmllTVVEL0RDPW9yZzAeFw0xOTEwMDkwMDM2NTdaFw0yMDEwMDgwMDM2
+  NTdaMCIxIDAeBgNVBAMMF2dlZC9EQz1GYWVyaWVNVUQvREM9b3JnMIIBojANBgkq
+  hkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAvyVhkRzvlEs0fe7145BYLfN6njX9ih5H
+  L60U0p0euIurpv84op9CNKF9tx+1WKwyQvQP7qFGuZxkSUuWcP/sFhDXL1lWUuIl
+  M4uHbGCRmOshDrF4dgnBeOvkHr1fIhPlJm5FO+Vew8tSQmlDsosxLUx+VB7DrVFO
+  5PU2AEbf04GGSrmqADGWXeaslaoRdb1fu/0M5qfPTRn5V39sWD9umuDAF9qqil/x
+  Sl6phTvgBrG8GExHbNZpLARd3xrBYLEFsX7RvBn2UPfgsrtvpdXjsHGfpT3IPN+B
+  vQ66lts4alKC69TE5cuKasWBm+16A4aEe3XdZBRNmtOu/g81gvwA7fkJHKllJuaI
+  dXzdHqq+zbGZVSQ7pRYHYomD0IiDe1DbIouFnPWmagaBnGHwXkDT2bKKP+s2v21m
+  ozilJg4aar2okb/RA6VS87o+d7g6LpDDMMQjH4G9OPnJENLdhu8KnPw/ivSVvQw7
+  N2I4L/ZOIe2DIVuYH7aLHfjZDQv/mNgpAgMBAAGjdTBzMAkGA1UdEwQCMAAwCwYD
+  VR0PBAQDAgSwMB0GA1UdDgQWBBRyjf55EbrHagiRLqt5YAd3yb8k4DAcBgNVHREE
+  FTATgRFnZWRARmFlcmllTVVELm9yZzAcBgNVHRIEFTATgRFnZWRARmFlcmllTVVE
+  Lm9yZzANBgkqhkiG9w0BAQsFAAOCAYEAFqsr6o0SvQRgjQVmhbQvExRnCMCoW1yb
+  FJiN7A5RA2Iy2E61OG1Ul5nGmaDmx/PNB/6JIbIV3B9Uq8aTZx4uOjK7r8vMl1/t
+  ZfY7r6HejJfXlcO2m6JDMbpdyEVv916LncBkzZRz6vnnNCx+31f15FKddxujpAFd
+  qpn3JRQY+oj7ZkoccL/IUiDpxQWeS3oOoz9qr2kVTp8R50InZimt79FqCl/1m66W
+  kdOuf+wM3DDx7Rt4IVNHrhGlyfMr7xjKW1Q3gll+pMN1DT6Ajx/t3JDSEg7BnnEW
+  r7AciSO6J4ApUdqyG+coLFlGdtgFTgRHv7ihbQtDI7Z/LV7A4Spn1j2PK3j0Omri
+  kSl1hPVigRytfgdVGiLXzvkkrkgj9EknCaj5UHbac7XvVBrljXj9hsnnqTANaKsg
+  jBZSA+N+xUTgUWpXjjwsLZjzJkhWATJWq+krNXcqpwXo6HsjmdUxoFMt63RBb+sI
+  XrxOxp8o0uOkU7FdLSGsyqJ2LzsR4obN
+  -----END CERTIFICATE-----
+date: 2020-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: loggability
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: tortoise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rake-deveiate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: |-
+  A toolkit for creating and using {Lindenmayer Systems}[https://en.wikipedia.org/wiki/L-system] (L-systems).
+  It consists of a class that allows for declaration of the L-system's grammar,
+  and another class that allows for the definition of how the symbols output by a
+  grammar should be translated into work.
+email:
+- ged@faeriemud.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".simplecov"
+- History.md
+- README.md
+- Rakefile
+- examples/fern_gn7.png
+- lib/l_system.rb
+- lib/l_system/production_adapter.rb
+- lib/l_system/rules_engine.rb
+- spec/l_system/production_adapter_spec.rb
+- spec/l_system/rules_engine_spec.rb
+- spec/l_system_spec.rb
+- spec/spec_helper.rb
+homepage: https://hg.sr.ht/~ged/LSystem
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: A toolkit for creating and using {Lindenmayer Systems}[https://en.wikipedia.org/wiki/L-system]
+  (L-systems).
+test_files: []