ciat 0.4.8

data/lib/ciat/crate.rb

@@ -0,0 +1,58 @@
+class CIAT::Crate #:nodoc:all
+  attr_reader :test_file
+  attr_reader :stub
+  attr_reader :output_folder
+    
+  def initialize(test_file, output_folder)
+    @test_file = test_file
+    @output_folder = output_folder
+  end
+  
+  def stub
+    test_file.gsub(File.extname(test_file), "")
+  end
+
+  def filename(*modifiers)
+    File.join(output_folder, [stub, *modifiers].compact.join("_"))
+  end
+  
+  def read_test_file
+    File.readlines(test_file)
+  end  
+  
+  def process_test_file #:nodoc:
+    elements = empty_elements_hash
+    split_test_file.each do |name, contents|
+      elements[name] = CIAT::TestElement.new(name, filename(name), contents)
+    end
+    elements
+  end
+  
+  def split_test_file #:nodoc:
+    tag = :description
+    content = ""
+    raw_elements = {}
+    read_test_file.each do |line|
+      if line =~ /^==== ((\w|\s)+?)\W*$/
+        raw_elements[tag] = content
+        tag = $1.gsub(" ", "_").to_sym
+        content = ""
+      else
+        content += line
+      end
+    end
+    raw_elements[tag] = content
+    raw_elements
+  end
+  
+  #
+  # Helpers
+  #
+  private
+  
+  def empty_elements_hash
+    Hash.new do |hash, name|
+      hash[name] = CIAT::TestElement.new(name, filename(name), nil)
+    end
+  end
+end

data/lib/ciat/differs/html_differ.rb

@@ -0,0 +1,20 @@
+module CIAT
+  module Differs
+    # Module for implementing the diff between two files.
+    # The output is in HTML table rows with the expected output on the left and
+    # the generated on the right.
+    module HtmlDiffer
+      def html_diff(expected_file, generated_file, diff_file)
+        system("diff #{diff_options} '#{expected_file}' '#{generated_file}' > '#{diff_file}'")
+      end
+
+      # TODO: it would be nice to have line numbers in the output
+      def diff_options
+        "--old-group-format='<tr><td>%df</td><td class=\"red\"><pre>%<</pre></td><td></td><td></td></tr>' " + 
+        "--new-group-format='<tr><td></td><td></td><td>%dF</td><td class=\"red\"><pre>%></pre><td></tr>' " +
+        "--changed-group-format='<tr class=\"yellow\"><td>%df</td><td><pre>%<</pre></td><td>%dF</td><td><pre>%></pre></td></tr>' " +
+        "--unchanged-group-format='<tr class=\"green\"><td>%df</td><td><pre>%=</pre></td><td>%dF</td><td><pre>%=</pre></td></tr>'"
+      end
+    end
+  end
+end

data/lib/ciat/erb_helpers.rb

@@ -0,0 +1,83 @@
+# If it were easy for you to write your own HTML templates, then the methods
+# in this module would be useful.
+#
+# <em>I don't know if it's easy to write your own HTML template!</em>
+module CIAT::ERBHelpers
+  # Turns a traffic light into a more "testing" word: "FAILURE",
+  # "ERROR", "passed", "n/a".
+  def light_to_word(light)
+  	case
+  	when light.red? then "FAILURE"
+  	when light.yellow? then "ERROR"
+  	when light.green? then "passed"
+  	when light.unset? then "n/a"
+	  else
+	    raise "cannot turn #{light} into word"
+  	end
+  end
+
+  # Turns a traffic light in a sentence wrapped in a classed +span+.
+  def light_to_sentence(prefix, light)
+  	"<span class=\"#{light.setting}\">#{prefix} " +
+  	case
+  	when light.red? then "failed"
+  	when light.yellow? then "errored"
+  	when light.green? then "passed"
+  	when light.unset? then "not run"
+	  else
+	    raise "cannot turn #{light} into a sentence"
+  	end +
+  	".</span>"
+  end
+
+  # Capitalizes string as a title.
+  def title(text)
+    text.gsub(/\b\w/){$&.upcase}
+  end
+  
+  # Replaces tabs with spaces because Firefox does _really_ wacky things with
+  # tabs in a +pre+ in a +table+.
+  def replace_tabs(string)
+  	string.gsub("\t", "    ")
+  end
+  
+  def new_path?(result)
+    if @old_path == File.dirname(result.filename)
+      false
+    else
+      @old_path = File.dirname(result.filename)
+      true
+    end
+  end
+  
+  # Recursively renders another template.  If it's possible to write your own
+  # templates for reports, this will probably play a key role.
+  def render(file, locals)
+    ERB.new(read(file)).result(CIAT::TemplateBinder.new(locals).get_binding)
+  end
+  
+  private
+  
+  def read(file)
+    File.read(template_path(file))
+  end
+  
+  def template_path(file)
+    File.join(File.dirname(__FILE__), '..', 'templates', file + ".html.erb")
+  end
+end
+
+# Assists in binding local variables for a recursive render.
+class CIAT::TemplateBinder
+  include CIAT::ERBHelpers
+  
+  def initialize(locals)
+    locals.each do |variable, value|
+      self.class.send(:define_method, variable, Proc.new {value})
+    end
+  end
+  
+  def get_binding
+    binding
+  end
+end

data/lib/ciat/executors/java.rb

@@ -0,0 +1,36 @@
+module CIAT
+  module Executors
+    # Executor class for Java interpreters.
+    #
+    class Java
+      include CIAT::Processors::BasicProcessing
+      include CIAT::Differs::HtmlDiffer
+
+      # Traffic light
+      attr :light, true
+      attr_reader :processor_kind
+
+      # Creates a Java executor.
+      #
+      # Possible options:
+      # * <code>:description</code> is the description used in the HTML report 
+      #   for this processor (default: <code>"Parrot virtual machine"</code>).
+      def initialize(classpath, interpreter_class, options={})
+        @processor_kind = options[:processor_kind] || CIAT::Processors::Interpreter.new
+        @classpath = classpath
+        @interpreter_class = interpreter_class
+        @description = options[:description] || "in-Java interpreter"
+        @light = CIAT::TrafficLight.new
+      end
+      
+      # Provides a description of the processor.
+      def describe
+        @description
+      end
+
+      def executable
+        "java -cp '#{@classpath}' #{@interpreter_class}"
+      end
+    end
+  end
+end

data/lib/ciat/executors/parrot.rb

@@ -0,0 +1,51 @@
+module CIAT
+  module Executors
+    # Executor class for Parrot programs.  This will execute PIR or PASM code
+    # using the +parrot+ executable.
+    #
+    # The Parrot executor expects <code>compilation</code> and
+    # <code>execution</code> elements.  The <code>compilation</code> element
+    # is used as input (and it actually pulls in the generated version, but it
+    # should be the same as the expected).  <code>execution</code> is
+    # compared.
+    #
+    # The Parrot executor allows for a <code>command line</code> element.  This
+    # specifies the command-line arguments when the <code>compilation</code>
+    # is executed.
+    # If none is provided, no command-line arguments are used.
+    class Parrot
+      include CIAT::Processors::BasicProcessing
+      include CIAT::Differs::HtmlDiffer
+
+      # Traffic light
+      attr :light, true
+      attr_reader :processor_kind
+
+      # Creates a Parrot executor.
+      #
+      # Possible options:
+      # * <code>:description</code> is the description used in the HTML report 
+      #   for this processor (default: <code>"Parrot virtual machine"</code>).
+      # * <code>:command_line</code> is the description used in the HTML
+      #   report
+      #   for the command-line arguments (if any) (default: "Command-line
+      #   arguments").
+      def initialize(options={})
+        @processor_kind = options[:processor_kind] ||   
+          CIAT::Processors::Interpreter.new
+        @description = options[:description] || "Parrot virtual machine"
+        @libraries = options[:libraries] || []
+        @light = CIAT::TrafficLight.new
+      end
+      
+      # Provides a description of the processor.
+      def describe
+        @description
+      end
+      
+      def executable
+        (["parrot"] + @libraries.map { |l| "-L" + l }).join(" ")
+      end
+    end
+  end
+end

data/lib/ciat/feedback/composite.rb

@@ -0,0 +1,20 @@
+# A feedback mechanism for compositing other feedbacks.
+module CIAT::Feedback
+  class Composite
+    # Pass in instances of the feedbacks as arguments to the constructor.
+    def initialize(*feedbacks)
+      @feedbacks = feedbacks
+    end
+  
+    def pre_tests(suite)
+      @feedbacks.each { |feedback| feedback.pre_tests(suite) }
+    end
+    def post_tests(suite)
+      @feedbacks.each { |feedback| feedback.post_tests(suite) }
+    end
+  
+    def processor_result(processor)
+      @feedbacks.each { |feedback| feedback.processor_result(processor) }
+    end
+  end
+end

data/lib/ciat/feedback/feedback_counter.rb

@@ -0,0 +1,45 @@
+module CIAT
+  module Feedback
+    # This feedback class sends some simple messages to the screen about the
+    # progress of a CIAT::Suite run.
+    class FeedbackCounter
+      def initialize
+        @error_count = 0
+        @failure_count = 0
+      end
+      
+      def error_count
+        @error_count
+      end
+      
+      def failure_count
+        @failure_count
+      end
+      
+      def increment_error_count
+        @error_count += 1
+      end
+      
+      def increment_failure_count
+        @failure_count += 1
+      end
+      
+      def pre_tests(suite)
+        nil
+      end
+      
+      def post_tests(suite)
+        nil
+      end
+      
+      def processor_result(processor)
+        case processor.light.setting
+        when :red
+          increment_failure_count
+        when :yellow
+          increment_error_count
+        end
+      end
+    end
+  end
+end

data/lib/ciat/feedback/html_feedback.rb

@@ -0,0 +1,40 @@
+require 'ciat/erb_helpers'
+
+module CIAT::Feedback
+  class HtmlFeedback
+    include CIAT::ERBHelpers
+    
+    def initialize(counter)
+      @counter = counter
+    end
+
+    def pre_tests(suite)
+      suite.cargo.copy_suite_data      
+    end
+  
+    def processor_result(processor)
+      nil
+    end
+  
+    def post_tests(suite)
+      suite.cargo.write_file(
+        suite.cargo.report_filename, 
+        generate_html(suite))
+    end
+
+    def generate_html(suite) #:nodoc:
+      processors = suite.processors
+      results = suite.results
+      report_title = suite.report_title
+      size = suite.size
+      counter = @counter
+      ERB.new(template).result(binding)
+    end
+
+    def template #:nodoc:
+      File.read(File.join(
+        File.dirname(__FILE__), "..", "..", "templates", "report.html.erb"
+        ))
+    end
+  end
+end

data/lib/ciat/feedback/return_status.rb

@@ -0,0 +1,23 @@
+# A feedback mechanism for failing a task
+module CIAT::Feedback
+  class ReturnStatus
+    def pre_tests(suite)
+      @failure = false
+    end
+    
+    def post_tests(suite)
+      if failure?
+        fail "CIAT tests unsuccessful"
+      end
+    end
+    
+    def processor_result(processor)
+      @failure ||= processor.light.yellow? || processor.light.red?
+    end
+    
+    private
+    def failure?
+      @failure
+    end
+  end
+end

data/lib/ciat/feedback/standard_output.rb

@@ -0,0 +1,29 @@
+module CIAT
+  module Feedback
+    # This feedback class sends some simple messages to the screen about the
+    # progress of a CIAT::Suite run.
+    class StandardOutput
+      LIGHT_OUTPUTS = { :green => ".", :red => "F", :yellow => "E", :unset => "-" }
+      
+      def initialize(counter)
+        @counter = counter
+      end
+            
+      def pre_tests(suite)
+        nil
+      end
+      
+      def post_tests(suite)
+        print "\n"
+        print "#{suite.size} tests executed"
+        print ", #{@counter.failure_count} failures" if @counter.failure_count > 0
+        print ", #{@counter.error_count} errors" if @counter.error_count > 0
+        print ".\n"
+      end
+      
+      def processor_result(processor)
+        putc LIGHT_OUTPUTS[processor.light.setting]
+      end
+    end
+  end
+end

data/lib/ciat/processors/basic_processing.rb

@@ -0,0 +1,64 @@
+module CIAT::Processors
+  module BasicProcessing    
+    # Produces a clone for an individual test.
+    def for_test
+      copy = clone
+      copy.light = light.clone
+      copy
+    end
+
+    # Executes the program, and diffs the output.
+    def process(test)
+      # TODO: verify required elements
+      # TODO: handle optional element
+      if execute(test)
+        if diff(test)
+          light.green!
+        else
+          light.red!
+        end
+      else
+        light.yellow!
+      end
+      test
+    end
+    
+    def execute(test)
+      system "#{executable} '#{input_file(test)}' #{command_line_args(test)} > '#{output_file(test)}' 2> '#{error_file(test)}'"
+    end
+    
+    def command_line_args(test) #:nodoc:
+      test.element?(:command_line) ? test.element(:command_line).content.strip : ''
+    end
+    
+    # Compares the expected and generated executions.
+    def diff(test)
+      html_diff(
+        test.element(processor_kind.output_name).as_file,
+        test.element(processor_kind.output_name, :generated).as_file, 
+        test.element(processor_kind.output_name, :diff).as_file)
+    end
+    
+    def relevant_elements(test)
+      relevant_element_names.
+        select { |name| test.element?(name) }.
+        map { |name| test.element(name) }
+    end
+  
+    def relevant_element_names
+      processor_kind.element_name_hash[light.setting]
+    end
+    
+    def input_file(test)
+      test.element(processor_kind.input_name).as_file
+    end
+
+    def output_file(test)
+      test.element(processor_kind.output_name, :generated).as_file
+    end
+
+    def error_file(test)
+      test.element(processor_kind.output_name, :error).as_file
+    end
+  end
+end