ciat 0.4.9 → 0.4.10

data/lib/ciat.rb

@@ -10,11 +10,10 @@ require 'ciat/traffic_light'
 require 'ciat/suite'
 require 'ciat/test'
 require 'ciat/test_element'
-require 'ciat/test_file'
+require 'ciat/ciat_file'
 require 'ciat/feedback/standard_output'
 require 'ciat/feedback/html_feedback'
 require 'ciat/differs/html_differ'
-require 'ciat/processors/basic_processing'
 require 'ciat/processors/compiler'
 require 'ciat/processors/interpreter'
 require 'ciat/processors/compilation_interpreter'

data/lib/ciat/{test_file.rb → ciat_file.rb}

@@ -1,23 +1,35 @@
-class CIAT::TestFile #:nodoc:all
+class CIAT::CiatFile #:nodoc:all
     
-  def initialize(test_file, output_folder)
-    unless File.exists?(test_file)
-      raise IOError.new(test_file + " does not exist")
+  def initialize(ciat_file, output_folder)
+    unless File.exists?(ciat_file)
+      raise IOError.new(ciat_file + " does not exist")
     end
-    @test_file = test_file
+    @ciat_file = ciat_file
     @output_folder = output_folder
   end
 
+  def elements
+    @elements ||= process
+  end
+  
+  def element(*names)
+    elements[names.compact.join("_").to_sym]
+  end
+  
+  def element?(*names)
+    elements.has_key?(names.compact.join("_").to_sym)
+  end
+
   def filename(*modifiers)
     if modifiers == [:ciat]
-      @test_file
+      @ciat_file
     else
       File.join(@output_folder, [stub, *modifiers].compact.join("_"))
     end
   end
   
   def grouping
-    File.dirname(@test_file)
+    File.dirname(@ciat_file)
   end
   
   def process #:nodoc:
@@ -51,7 +63,7 @@ class CIAT::TestFile #:nodoc:all
   private
   
   def read
-    File.readlines(@test_file)
+    File.readlines(@ciat_file)
   end  
   
   def empty_elements_hash
@@ -61,6 +73,6 @@ class CIAT::TestFile #:nodoc:all
   end
   
   def stub
-    @test_file.gsub(File.extname(@test_file), "")
+    @ciat_file.gsub(File.extname(@ciat_file), "")
   end
 end

data/lib/ciat/erb_helpers.rb

@@ -11,6 +11,7 @@ module CIAT::ERBHelpers
   	when light.yellow? then "ERROR"
   	when light.green? then "passed"
   	when light.unset? then "n/a"
+  	when light.unneeded? then "unneeded"
 	  else
 	    raise "cannot turn #{light} into word"
   	end
@@ -18,7 +19,7 @@ module CIAT::ERBHelpers
 
   # Turns a traffic light in a sentence wrapped in a classed +span+.
   def light_to_sentence(prefix, light)
-  	"<span class=\"#{light.setting}\">#{prefix} " +
+  	"<span class=\"#{light.color}\">#{prefix} " +
   	case
   	when light.red? then "failed"
   	when light.yellow? then "errored"
@@ -29,6 +30,10 @@ module CIAT::ERBHelpers
   	end +
   	".</span>"
   end
+  
+  def filename_to_id(filename)
+    filename.gsub(/[\/\-.]/, "_")
+  end
 
   # Capitalizes string as a title.
   def title(text)

data/lib/ciat/feedback/feedback_counter.rb

@@ -4,26 +4,23 @@ module CIAT
     # progress of a CIAT::Suite run.
     class FeedbackCounter
       def initialize
-        @error_count = 0
-        @failure_count = 0
+        @counts = {
+          CIAT::TrafficLight::RED => 0,
+          CIAT::TrafficLight::YELLOW => 0,
+          CIAT::TrafficLight::GREEN => 0,
+          CIAT::TrafficLight::UNSET => 0,
+          CIAT::TrafficLight::UNNEEDED => 0
+        }
       end
       
       def error_count
-        @error_count
+        @counts[CIAT::TrafficLight::YELLOW]
       end
       
       def failure_count
-        @failure_count
+        @counts[CIAT::TrafficLight::RED]
       end
-      
-      def increment_error_count
-        @error_count += 1
-      end
-      
-      def increment_failure_count
-        @failure_count += 1
-      end
-      
+            
       def pre_tests(suite)
         nil
       end
@@ -33,12 +30,7 @@ module CIAT
       end
       
       def report_subresult(subresult)
-        case subresult.light.setting
-        when :red
-          increment_failure_count
-        when :yellow
-          increment_error_count
-        end
+        @counts[subresult.light] = @counts[subresult.light] + 1
       end
     end
   end

data/lib/ciat/feedback/return_status.rb

@@ -11,11 +11,15 @@ module CIAT::Feedback
       end
     end
     
-    def report_subresult(processor)
-      @failure ||= processor.light.yellow? || processor.light.red?
+    def report_subresult(subresult)
+      @failure ||= subresult_failure?(subresult, subresult.light)
     end
     
     private
+    def subresult_failure?(subresult, light)
+      light.yellow? || light.red?
+    end
+    
     def failure?
       @failure
     end

data/lib/ciat/feedback/standard_output.rb

@@ -3,7 +3,12 @@ module CIAT
     # 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 => "-" }
+      LIGHT_OUTPUTS = {
+        CIAT::TrafficLight::GREEN => ".", 
+        CIAT::TrafficLight::RED => "F", 
+        CIAT::TrafficLight::YELLOW => "E", 
+        CIAT::TrafficLight::UNSET => "-",
+        CIAT::TrafficLight::UNNEEDED => "." }
       
       def initialize(counter)
         @counter = counter
@@ -22,7 +27,7 @@ module CIAT
       end
       
       def report_subresult(processor)
-        putc LIGHT_OUTPUTS[processor.light.setting]
+        putc LIGHT_OUTPUTS[processor.light]
       end
     end
   end

data/lib/ciat/processors/compilation_interpreter.rb

@@ -1,11 +1,10 @@
 class CIAT::Processors::CompilationInterpreter
-  def element_name_hash
-    {
-      :green => [:compilation_generated, :execution_generated],
-      :yellow => [:compilation_generated, :execution_error],
-      :red => [:compilation_generated, :execution_diff],
-      :unset => []
-    }
+  def relevant_elements(color, path)
+    element_name_hash[color]
+  end
+  
+  def happy_path_element
+    :execution
   end
   
   def input_name
@@ -15,4 +14,18 @@ class CIAT::Processors::CompilationInterpreter
   def output_name
     :execution
   end
+  
+  def error_name
+    :execution_error
+  end
+  
+  private
+  def element_name_hash
+    {
+      CIAT::TrafficLight::GREEN => [:compilation_generated, :execution_generated],
+      CIAT::TrafficLight::YELLOW => [:compilation_generated, :execution_error_generated],
+      CIAT::TrafficLight::RED => [:compilation_generated, :execution_diff],
+      CIAT::TrafficLight::UNSET => []
+    }
+  end
 end

data/lib/ciat/processors/compiler.rb

@@ -1,18 +1,41 @@
-class CIAT::Processors::Compiler
-  def element_name_hash
-    {
-      :green => [:source, :compilation_generated],
-      :yellow => [:source, :compilation_error],
-      :red => [:source, :compilation_diff],
-      :unset => []
-    }
-  end
+module CIAT::Processors
+  class Compiler
+    def relevant_elements(color, path)
+      element_name_hash[path][color]
+    end
+  
+    def happy_path_element
+      :compilation
+    end
 
-  def input_name
-    :source
-  end
+    def input_name
+      :source
+    end
   
-  def output_name
-    :compilation
+    def output_name
+      :compilation
+    end
+  
+    def error_name
+      :compilation_error
+    end
+
+    private
+    def element_name_hash
+      {
+        :happy => {
+          CIAT::TrafficLight::GREEN => [:source, :compilation_generated],
+          CIAT::TrafficLight::YELLOW => [:source, :compilation_generated, :compilation_error_generated],
+          CIAT::TrafficLight::RED => [:source, :compilation_diff],
+          CIAT::TrafficLight::UNSET => []
+        },
+        :sad => {
+          CIAT::TrafficLight::GREEN => [:source, :compilation_error_generated],
+          CIAT::TrafficLight::YELLOW => [:source, :compilation_generated, :compilation_error_generated],
+          CIAT::TrafficLight::RED => [:source, :compilation_error_diff, :compilation_generated],
+          CIAT::TrafficLight::UNSET => []
+        }
+      }
+    end
   end
-end
+end

data/lib/ciat/processors/interpreter.rb

@@ -1,13 +1,12 @@
 class CIAT::Processors::Interpreter
-  def element_name_hash
-    {
-      :green => [:source, :command_line, :execution_generated],
-      :yellow => [:source, :command_line, :execution_error],
-      :red => [:source, :command_line, :execution_diff],
-      :unset => []
-    }
+  def relevant_elements(color, path)
+    element_name_hash[path][color]
   end
   
+  def happy_path_element
+    :execution
+  end
+
   def input_name
     :source
   end
@@ -15,4 +14,26 @@ class CIAT::Processors::Interpreter
   def output_name
     :execution
   end
+  
+  def error_name
+    :execution_error
+  end
+  
+  private
+  def element_name_hash
+    {
+      :happy => {
+        CIAT::TrafficLight::GREEN => [:source, :command_line, :execution_generated],
+        CIAT::TrafficLight::YELLOW => [:source, :command_line, :execution_generated, :execution_error_generated],
+        CIAT::TrafficLight::RED => [:source, :command_line, :execution_diff, :execution_error_generated],
+        CIAT::TrafficLight::UNSET => []
+      },
+      :sad => {
+        CIAT::TrafficLight::GREEN => [:source, :command_line, :execution_error_generated],
+       CIAT::TrafficLight::YELLOW => [:source, :command_line, :execution_error_generated, :execution_generated],
+        CIAT::TrafficLight::RED => [:source, :command_line, :execution_error_diff, :execution_generated],
+        CIAT::TrafficLight::UNSET => []
+      }
+    }
+  end
 end

data/lib/ciat/processors/java.rb

@@ -1,19 +1,13 @@
 module CIAT
   module Processors
-    # Executor class for Java interpreters.
+    # Processor class for compilers and interpreters implemented in Java (or
+    # on the JVM).
     #
     class Java
-      include CIAT::Processors::BasicProcessing
-
-      # Traffic light
       attr_accessor :kind
       attr_accessor :description
 
       # 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)
         @classpath = classpath
         @interpreter_class = interpreter_class

data/lib/ciat/processors/parrot.rb

@@ -14,9 +14,6 @@ module CIAT
     # is executed.
     # If none is provided, no command-line arguments are used.
     class Parrot
-      include CIAT::Processors::BasicProcessing
-      include CIAT::Differs::HtmlDiffer
-
       attr_accessor :kind
       attr_accessor :description
       attr_accessor :libraries

data/lib/ciat/subresult.rb

@@ -1,11 +1,21 @@
 class CIAT::Subresult
   attr_reader :light
-  attr_reader :processor
+  attr_reader :path_kind
+  attr_reader :subtest
   
-  def initialize(elements, light, processor)
+  def initialize(elements, path_kind, light, subtest)
     @elements = elements
+    @path_kind = path_kind
     @light = light
-    @processor = processor
+    @subtest = subtest
+  end
+  
+  def happy_path?
+    path_kind == :happy
+  end
+  
+  def processor
+    subtest.processor
   end
   
   def relevant_elements
@@ -15,6 +25,6 @@ class CIAT::Subresult
   end
   
   def relevant_element_names
-    @processor.kind.element_name_hash[@light.setting]
+    processor.kind.relevant_elements(@light, @subtest.path_kind)
   end
 end

data/lib/ciat/subtest.rb

@@ -0,0 +1,83 @@
+require 'rake'
+require 'ciat/differs/html_differ'
+
+class CIAT::Subtest
+  include CIAT::Differs::HtmlDiffer
+  
+  attr_reader :processor
+  
+  def initialize(ciat_file, processor)
+    @ciat_file = ciat_file
+    @processor = processor
+  end
+  
+  def describe
+    @processor.describe
+  end
+  
+  # Executes the program, and diffs the output.
+  def process
+    if execute
+      if diff
+        CIAT::TrafficLight::GREEN
+      else
+        CIAT::TrafficLight::RED
+      end
+    else
+      CIAT::TrafficLight::YELLOW
+    end
+  end
+
+  def execute
+    RakeFileUtils.verbose(false) do
+      sh(command_line) do |ok, result|
+        return happy_path? == ok
+      end
+    end
+  end
+  
+  def happy_path?
+    @ciat_file.element?(@processor.kind.happy_path_element)
+  end
+  
+  def sad_path?
+    not happy_path?
+  end
+  
+  def path_kind
+    happy_path? ? :happy : :sad
+  end
+  
+  def command_line
+    "#{@processor.executable} '#{input_file}' #{command_line_args} > '#{output_file}' 2> '#{error_file}'"
+  end
+  
+  def command_line_args
+    if @ciat_file.element?(:command_line)
+      @ciat_file.element(:command_line).content.strip
+    else
+      ''
+    end
+  end
+  
+  def input_file
+    @ciat_file.element(@processor.kind.input_name).as_file
+  end
+
+  def output_file
+    @ciat_file.element(@processor.kind.output_name, :generated).as_file
+  end
+
+  def error_file
+    @ciat_file.element(@processor.kind.error_name, :generated).as_file
+  end
+
+  # Compares the expected and generated executions.
+  def diff
+    element_name = happy_path? ? @processor.kind.output_name : @processor.kind.error_name
+    html_diff(
+      @ciat_file.element(element_name).as_file,
+      @ciat_file.element(element_name, :generated).as_file, 
+      @ciat_file.element(element_name, :diff).as_file)
+  end
+end