walrus 0.1

data/lib/walrus/walrus_grammar/include_directive.rb

@@ -0,0 +1,27 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that the class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class IncludeDirective
+      
+      def compile(options = {})
+        inner, outer = options[:compiler_instance].compile_subtree(subtree)
+        inner = [] if inner.nil?
+        inner.unshift "\# Include (start): #{file_name.to_s}:\n"
+        [inner, outer]
+      end
+      
+    end # class IncludeDirective
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/instance_variable.rb

@@ -0,0 +1,24 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class InstanceVariable
+      
+      def compile(options = {})
+        @lexeme.source_text
+      end
+      
+    end # class InstanceVariable
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/literal.rb

@@ -0,0 +1,24 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class Literal
+      
+      def compile(options = {})
+        @lexeme.source_text
+      end
+      
+    end # class Literal
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/message_expression.rb

@@ -0,0 +1,25 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/lib/walrus/walrus_grammar/message_expression.rb 6701 2007-04-09T14:55:55.352472Z wincent  $
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class MessageExpression
+      
+      def compile(options = {})
+        # simple case        
+        @target.source_text + '.' + @message.source_text
+      end
+      
+    end # class AssignmentExpression
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/multiline_comment.rb

@@ -0,0 +1,54 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class MultilineComment
+      
+      # Multiline comments may containing nested Comments/Multiline comments or normal text, so must compile recursively.
+      # TODO: anchor comments that appear immediately before #def and #block directives to their corresponding methods (for the timebeing should note in the documentation that if you want your comments to appear adjacent to the blocks which follow them then you must put your comments inside the blocks)
+      def compile(options = {})
+        compiled = ''
+        if @content.respond_to? :each
+          @content.each do |item|
+            if item.kind_of? Comment
+              compiled << '# (nested) ' + item.compile 
+            else
+              first = true
+              item.to_s.each do |line|
+                if first
+                  first = false
+                  compiled << '# MultilineComment:' + line.to_s.chomp + "\n"
+                else
+                  compiled << '# MultilineComment (continued):' + line.to_s.chomp + "\n"
+                end
+              end
+            end
+          end
+        else # no nesting, just raw text, but still must check for multiple lines
+          first = true
+          @content.to_s.each do |line|
+            if first
+              first = false
+              compiled << '# MultilineComment:' + line.to_s.chomp + "\n"
+            else
+              compiled << '# MultilineComment (continued):' + line.to_s.chomp + "\n"
+            end
+          end
+        end
+        compiled
+      end
+      
+    end
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/placeholder.rb

@@ -0,0 +1,40 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/lib/walrus/walrus_grammar/placeholder.rb 6721 2007-04-10T16:10:41.583472Z wincent  $
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class Placeholder
+      
+      def compile(options = {})
+        
+        if options[:nest_placeholders] == true
+          method_name = "lookup_and_return_placeholder"     # placeholder nested inside another placeholder
+        else
+          method_name = "lookup_and_accumulate_placeholder" # placeholder used in a literal text stream
+        end
+        
+        if @params == []
+          "#{method_name}(#{@name.to_s.to_sym.inspect})\n"
+        else
+          options = options.clone
+          options[:nest_placeholders] = true
+          params      = (@params.kind_of? Array) ? @params : [@params]
+          param_list  = params.collect { |param| param.compile(options) }.join(', ').chomp
+          "#{method_name}(#{@name.to_s.to_sym.inspect}, #{param_list})\n"
+        end
+        
+      end
+      
+    end # class Placeholder
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/raw_directive.rb

@@ -0,0 +1,42 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class RawDirective
+      
+      # Returns a string containing the compiled (Ruby) version of receiver.
+      def compile(options = {})
+        compiled  = []
+        first     = true
+        @content.to_s.to_source_string.each do |line|
+          newline = ''
+          if line =~ /(\r\n|\r|\n)\z/       # check for literal newline at end of line
+            line.chomp!                     # get rid of it
+            newline = ' + ' + $~[0].dump    # include non-literal newline instead
+          end
+          
+          if first
+            compiled << "accumulate('%s'%s) # RawDirective\n" % [ line, newline ]
+            first = false
+          else
+            compiled << "accumulate('%s'%s) # RawDirective (continued)\n" % [ line, newline ]
+          end
+          
+        end
+        compiled.join
+      end
+      
+    end # class RawDirective
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/raw_text.rb

@@ -0,0 +1,45 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class RawText
+      
+      # Returns a string containing the compiled (Ruby) version of receiver.
+      # If options[:slurping] is true, instructs the receiver to strip the leading carriage return/line feed from the @lexeme prior to emitting the compiled output.
+      def compile(options = {})
+        lexeme = options[:slurping] ? @lexeme.to_s.sub(/\A(\r\n|\r|\n)/, '') : @lexeme.to_s
+        
+        compiled  = ''
+        first     = true
+        lexeme.to_source_string.each do |line|
+          newline = ''
+          if line =~ /(\r\n|\r|\n)\z/       # check for literal newline at end of line
+            line.chomp!                     # get rid of it
+            newline = ' + ' + $~[0].dump    # include non-literal newline instead
+          end
+          
+          if first
+            compiled << "accumulate('%s'%s) # RawText\n" % [ line, newline ]
+            first = false
+          else
+            compiled << "accumulate('%s'%s) # RawText (continued)\n" % [ line, newline ]
+          end
+          
+        end
+        compiled
+      end
+      
+    end # class RawText
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/ruby_directive.rb

@@ -0,0 +1,29 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class RubyDirective
+      
+      # TODO: could make a #rubyecho method that did an "accumulate do" instead of instance_eval
+      def compile(options = {})
+        # possible problem here is that the compiler will indent each line for us, possibly breaking here docs etc
+        # seeing as it is going to be indented anyway, I add some additional indenting here for pretty printing purposes
+        compiled = "instance_eval do # Ruby directive\n"
+        @content.to_s.each { |line| compiled << '  ' + line }
+        compiled << "end\n"
+      end
+      
+    end # class RawDirective
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/ruby_expression.rb

@@ -0,0 +1,31 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/lib/walrus/walrus_grammar/ruby_expression.rb 6701 2007-04-09T14:55:55.352472Z wincent  $
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class RubyExpression
+      
+      # Rather than just compiling Ruby expressions back to text in a generic fashion it is desirable
+      # to compile the pieces separately (for an example, see the AssignmentExpression class) because
+      # this allows us to handle placeholders embedded inside Ruby expressions.
+      #
+      # Nevertheless, at an abstract level we here supply a default compilation method which just
+      # returns the source text, suitable for evaluation. Subclasses can then override this as new
+      # cases are discovered which require piece-by-piece compilation.
+      def compile(options = {})
+        source_text
+      end
+      
+    end # class AssignmentExpression
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/set_directive.rb

@@ -0,0 +1,24 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class SetDirective
+      
+      def compile(options = {})
+        "set_value(%s, instance_eval { %s }) # Set directive \n" % [ @placeholder.to_s.dump, @expression.compile ]
+      end
+      
+    end # class SetDirective
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/silent_directive.rb

@@ -0,0 +1,44 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that RawText class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class SilentDirective
+      
+      def compile(options = {})
+        
+        if @expression.respond_to? :each
+          expression = @expression
+        else
+          expression = [@expression]
+        end
+        
+        # TODO: potentially include line, col and file name info in the comments generated by the compiler
+        
+        compiled  = ''
+        first     = true
+        expression.each do |expr| 
+          if first
+            compiled << "instance_eval { %s } # Silent directive\n" % expr.compile
+            first = false
+          else
+            compiled << "instance_eval { %s } # Silent directive (continued)\n" % expr.compile
+          end
+        end
+        compiled
+        
+      end
+      
+    end # class SilentDirective
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/slurp_directive.rb

@@ -0,0 +1,25 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus/parser.rb' # make sure that the class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class SlurpDirective
+      
+      # The slurp directive produces no meaningful output; but we leave a comment in the compiled template so that the location of the directive is visible in the source.
+      def compile(options = {})
+        "# Slurp directive\n"
+      end
+      
+    end # class SlurpDirective
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus/walrus_grammar/super_directive.rb

@@ -0,0 +1,27 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/lib/walrus/walrus_grammar/super_directive.rb 6707 2007-04-09T18:59:29.617466Z wincent  $
+
+require 'walrus/parser.rb' # make sure that the class has been defined prior to extending it
+
+module Walrus
+  class WalrusGrammar
+    
+    class SuperDirective
+      
+      def compile(options = {})
+        
+        # basic case, no explicit parameters
+        "super # Super directive\n"
+        
+      end
+      
+    end # class SuperDirective
+    
+  end # class WalrusGrammar
+end # Walrus
+

data/lib/walrus.rb

@@ -0,0 +1,64 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'jcode'   # jlength method
+$KCODE  = 'U'     # UTF-8 (necessary for Unicode support)
+
+module Walrus
+  
+  VERSION = '0.1'
+  
+  autoload(:CompileError,                 'walrus/compile_error')
+  autoload(:Compiler,                     'walrus/compiler')
+  autoload(:Grammar,                      'walrus/grammar')
+  autoload(:Parser,                       'walrus/parser')
+  autoload(:NoParameterMarker,            'walrus/no_parameter_marker')
+  autoload(:Template,                     'walrus/template')
+  
+  class Grammar
+    
+    autoload(:AndPredicate,                 'walrus/grammar/and_predicate')
+    autoload(:ArrayResult,                  'walrus/grammar/array_result')
+    autoload(:ContinuationWrapperException, 'walrus/grammar/continuation_wrapper_exception')
+    autoload(:LeftRecursionException,       'walrus/grammar/left_recursion_exception')
+    autoload(:LocationTracking,             'walrus/grammar/location_tracking')
+    autoload(:MatchDataWrapper,             'walrus/grammar/match_data_wrapper')
+    autoload(:Memoizing,                    'walrus/grammar/memoizing')
+    autoload(:MemoizingCache,               'walrus/grammar/memoizing_cache')
+    autoload(:NotPredicate,                 'walrus/grammar/not_predicate')
+    autoload(:Node,                         'walrus/grammar/node')
+    autoload(:ParseError,                   'walrus/grammar/parse_error')
+    autoload(:ParserState,                  'walrus/grammar/parser_state')
+    autoload(:Parslet,                      'walrus/grammar/parslet')
+    autoload(:ParsletChoice,                'walrus/grammar/parslet_choice')
+    autoload(:ParsletCombination,           'walrus/grammar/parslet_combination')
+    autoload(:ParsletCombining,             'walrus/grammar/parslet_combining')
+    autoload(:ParsletMerge,                 'walrus/grammar/parslet_merge')
+    autoload(:ParsletOmission,              'walrus/grammar/parslet_omission')
+    autoload(:ParsletRepetition,            'walrus/grammar/parslet_repetition')
+    autoload(:ParsletRepetitionDefault,     'walrus/grammar/parslet_repetition_default')
+    autoload(:ParsletSequence,              'walrus/grammar/parslet_sequence')
+    autoload(:Predicate,                    'walrus/grammar/predicate')
+    autoload(:ProcParslet,                  'walrus/grammar/proc_parslet')
+    autoload(:RegexpParslet,                'walrus/grammar/regexp_parslet')
+    autoload(:SkippedSubstringException,    'walrus/grammar/skipped_substring_exception')
+    autoload(:StringEnumerator,             'walrus/grammar/string_enumerator')
+    autoload(:StringParslet,                'walrus/grammar/string_parslet')
+    autoload(:StringResult,                 'walrus/grammar/string_result')
+    autoload(:SymbolParslet,                'walrus/grammar/symbol_parslet')
+    
+  end
+  
+end # module Walrus
+
+require 'walrus/additions/module'
+require 'walrus/additions/string'
+require 'walrus/grammar/additions/proc'
+require 'walrus/grammar/additions/regexp'
+require 'walrus/grammar/additions/string'
+require 'walrus/grammar/additions/symbol'

data/spec/acceptance/acceptance_spec.rb

@@ -0,0 +1,97 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/spec/acceptance/acceptance_spec.rb 6739 2007-04-11T17:09:13.916915Z wincent  $
+
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require 'walrus/parser' # ensure that WalrusGrammar is defined before continuing
+require 'mkdtemp'
+
+module Walrus
+  
+  class WalrusGrammar
+    
+    # This spec performs high-level acceptance testing by running Walrus on the sample templates in the subdirectories of the "spec/acceptance/" directory and comparing them with the expected output.
+    describe 'processing test files with Walrus' do
+      
+      # construct an array of absolute paths indicating the location of all testable templates.
+      template_paths = Dir[File.join(File.dirname(__FILE__), '**/*.tmpl')].collect { |template| Pathname.new(template).realpath }
+      
+      # make temporary output dirs for storing compiled templates
+      manually_compiled_templates = Pathname.new(Dir.mkdtemp('/tmp/walrus.acceptance.XXXXXX'))
+      walrus_compiled_templates   = Pathname.new(Dir.mkdtemp('/tmp/walrus.acceptance.XXXXXX'))
+      parser                      = Parser.new
+      search_additions            = "#{ENV['RUBYLIB']}:#{Walrus::SpecHelper::LIBDIR}:#{Walrus::SpecHelper::EXTDIR}"
+      
+      template_paths.each do |path|
+        
+        template        = Template.new(path)
+        compiled        = nil
+        it 'template should compile (source file: #{path})' do
+          compiled      = template.compile
+        end
+        next if compiled.nil? # compiled will be nil if the compilation spec failed
+        
+        expected_output = IO.read(path.to_s.sub(/\.tmpl\z/i, ".expected"))
+        
+        it "actual output should match expected output evaluating dynamically (source file: #{path})" do
+          actual_output = template.fill
+          actual_output.should == expected_output
+        end
+        
+        it "actual output should match expected output running compiled file in subshell (source file: #{path})" do
+          target_path = manually_compiled_templates.join(path.basename(path.extname).to_s + '.rb')
+          File.open(target_path, 'w+') { |file| file.puts compiled }
+          actual_output = `ruby -I#{Walrus::SpecHelper::LIBDIR} -I#{Walrus::SpecHelper::EXTDIR} #{target_path}`
+          actual_output.should == expected_output
+        end
+        
+        it "actual output should match expected output using 'walrus' commandline tool (source file: #{path})" do
+          `env RUBYLIB='#{search_additions}' #{Walrus::SpecHelper::TOOL} fill --output-dir '#{walrus_compiled_templates}' '#{path}'`
+          dir, base = path.split
+          dir   = dir.to_s.sub(/\A\//, '') if dir.absolute? # and always will be absolute
+          base  = base.basename(base.extname).to_s + '.html'
+          actual_output = IO.read(walrus_compiled_templates + dir + base)
+          actual_output.should == expected_output
+        end
+        
+      end
+      
+    end
+    
+    # These templates have a different extension to keep them separate from the other acceptance tests.
+    describe 'processing multiple-interdependent files with Walrus' do
+      
+      template_paths  = Dir[File.join(File.dirname(__FILE__), '**/*.complex')].collect { |template| Pathname.new(template).realpath }
+      output_dir      = Pathname.new(Dir.mkdtemp('/tmp/walrus.acceptance.XXXXXX'))
+      parser          = Parser.new
+      
+      search_additions  = "#{ENV['RUBYLIB']}:#{Walrus::SpecHelper::LIBDIR}:#{Walrus::SpecHelper::EXTDIR}"
+      
+      template_paths.each do |path|
+        it 'should be able to compile all the templates' do
+          `env RUBYLIB='#{search_additions}' #{Walrus::SpecHelper::TOOL} compile --input-extension complex --output-dir '#{output_dir}' '#{path}'`
+        end
+      end
+      
+      template_paths.each do |path|
+        it 'should be able to fill all the templates' do
+          `env RUBYLIB='#{search_additions}' #{Walrus::SpecHelper::TOOL} fill --input-extension complex --output-dir '#{output_dir}' '#{path}'`
+          dir, base = path.split
+          dir   = dir.to_s.sub(/\A\//, '') if dir.absolute? # and always will be absolute
+          base  = base.basename(base.extname).to_s + '.html'
+          actual_output   = IO.read(output_dir + dir + base)
+          expected_output = IO.read(path.to_s.sub(/\.complex\z/i, ".expected"))
+          actual_output.should == expected_output
+        end
+      end
+      
+    end
+    
+  end
+  
+end # module Walrus
+

data/spec/acceptance/block/basic_block.expected

@@ -0,0 +1 @@
+This will be output by default.

data/spec/acceptance/block/basic_block.tmpl

@@ -0,0 +1,3 @@
+#block body
+This will be output by default.
+#end

data/spec/acceptance/block/nested_blocks.expected

@@ -0,0 +1,5 @@
+[This is the header]
+
+Main text...
+
+[This is the footer]

data/spec/acceptance/block/nested_blocks.tmpl

@@ -0,0 +1,11 @@
+#block body
+#block header
+[This is the header]
+#end
+
+Main text...
+
+#block footer
+[This is the footer]
+#end
+#end

data/spec/acceptance/comments/comments_and_text.expected

@@ -0,0 +1,3 @@
+This file contains comments 
+which should not appear in the template output...
+In the final output, this should be the third line...