ciat 0.4.9 → 0.4.10

data/lib/ciat/suite.rb

@@ -58,7 +58,7 @@ class CIAT::Suite
   
   attr_reader :processors
   attr_reader :output_folder
-  attr_reader :test_files
+  attr_reader :ciat_files
   attr_reader :results
   
   # Builds a suite of CIAT tests.  See the instructions above for possible
@@ -68,34 +68,34 @@ class CIAT::Suite
     CIAT::Suite.new(
       builder.build_processors,
       builder.build_output_folder,
-      builder.build_test_files,
+      builder.build_ciat_files,
       builder.build_feedback)
   end
   
-  def initialize(processors, output_folder, test_files, feedback)
+  def initialize(processors, output_folder, ciat_files, feedback)
     @processors = processors
     @output_folder = output_folder
-    @test_files = test_files
+    @ciat_files = ciat_files
     @feedback = feedback
   end
     
   # Returns the number of tests in the suite.
   def size
-    test_files.size
+    ciat_files.size
   end
   
   # Runs all of the tests in the suite, and returns the results.  The results
   # are also available through #results.
   def run
     @feedback.pre_tests(self)
-    @results = test_files.
-      map { |test_file| create_test(test_file) }.
+    @results = ciat_files.
+      map { |ciat_file| create_test(ciat_file) }.
       map { |test| test.run }
     @feedback.post_tests(self)
     @results
   end
   
-  def create_test(test_file)
-    CIAT::Test.new(test_file, @processors, @feedback)
+  def create_test(ciat_file)
+    CIAT::Test.new(ciat_file, @processors, @feedback)
   end
 end

data/lib/ciat/suite_builder.rb

@@ -17,22 +17,22 @@ class CIAT::SuiteBuilder
     options[:output_folder] || OUTPUT_FOLDER
   end
   
-  def build_test_files
+  def build_ciat_files
     if options[:files]
-      make_test_files(options[:files])
+      make_ciat_files(options[:files])
     else  
       folder = options[:folder] || "ciat"
       pattern = options[:pattern] || "*.ciat"
-      make_test_files(Dir[File.join(folder, "**", pattern)])
+      make_ciat_files(Dir[File.join(folder, "**", pattern)])
     end
   end
   
-  def make_test_files(filenames)
+  def make_ciat_files(filenames)
     if filenames.empty?
       raise IOError.new("no test files specified")
     end
     filenames.map do |filename|
-      CIAT::TestFile.new(filename, build_output_folder)
+      CIAT::CiatFile.new(filename, build_output_folder)
     end
   end
   

data/lib/ciat/test.rb

@@ -1,55 +1,63 @@
 require 'set'
 require 'ciat/test_result'
+require 'ciat/subtest'
 require 'ciat/subresult'
 
 class CIAT::Test
   attr_reader :processors
 
-  def initialize(test_file, processors, feedback) #:nodoc:
-    @test_file = test_file
+  def initialize(ciat_file, processors, feedback) #:nodoc:
+    @ciat_file = ciat_file
     @processors = processors
     @feedback = feedback
   end
+    
+  def run
+    CIAT::TestResult.new(@ciat_file, run_subtests)
+  end
   
-  def elements
-    @elements ||= @test_file.process
+  def grouping
+    @ciat_file.grouping
   end
   
-  def filename
-    @test_file.filename(:ciat)
+  def run_subtests #:nodoc:
+    subtests = make_subtests
+    subresults = []
+    until subtests.empty?
+      subtest = subtests.shift
+      subresults << subresult(subtest, subtest.process)
+      if subtest.sad_path?
+        return subresults + remaining_subtests(subtests, unneeded)
+      end
+      unless subresults.last.light.green?
+        return subresults + remaining_subtests(subtests, unset)
+      end
+    end
+    subresults
+  end
+
+  def remaining_subtests(subtests, light)
+    subtests.map { |subtest| subresult(subtest, light) }
   end
   
-  def run
-    CIAT::TestResult.new(self, run_processors)
+  def unneeded
+    CIAT::TrafficLight::UNNEEDED
   end
   
-  def grouping
-    @test_file.grouping
+  def unset
+    CIAT::TrafficLight::UNSET
   end
   
-  def run_processors #:nodoc:
-    light = CIAT::TrafficLight::GREEN
+  def make_subtests
     processors.map do |processor|
-      if light.green?
-        light = processor.process(self)
-        subresult(processor, light)
-      else
-        subresult(processor)
-      end
+      CIAT::Subtest.new(@ciat_file, processor)
     end
   end
   
-  def subresult(processor, light = CIAT::TrafficLight::UNSET)
-    subresult = CIAT::Subresult.new(self, light, processor)
+  def subresult(subtest, light)
+    subresult = CIAT::Subresult.new(@ciat_file,
+      subtest.path_kind, light, subtest)
     @feedback.report_subresult(subresult)
     subresult
   end
-  
-  def element(*names)
-    elements[names.compact.join("_").to_sym]
-  end
-  
-  def element?(*names)
-    elements.has_key?(names.compact.join("_").to_sym)
-  end
 end

data/lib/ciat/test_result.rb

@@ -11,11 +11,11 @@ class CIAT::TestResult
   end
   
   def processors
-    @test.processors
+    @subresults.map { |subresult| subresult.processor }
   end
   
   def filename
-    @test.filename
+    @test.filename(:ciat)
   end
   
   def element(*args)

data/lib/ciat/traffic_light.rb

@@ -1,8 +1,6 @@
 class CIAT::TrafficLight
   
-  attr_reader :setting
-  
-  def initialize(setting = :unset) #:nodoc:
+  def initialize(setting) #:nodoc:
     @setting = setting
   end
   
@@ -10,6 +8,7 @@ class CIAT::TrafficLight
   RED = CIAT::TrafficLight.new(:red)
   YELLOW = CIAT::TrafficLight.new(:yellow)
   UNSET = CIAT::TrafficLight.new(:unset)
+  UNNEEDED = CIAT::TrafficLight.new(:unneeded)
   
   def unset?
     @setting == :unset
@@ -19,24 +18,16 @@ class CIAT::TrafficLight
     @setting == :green
   end
   
-  def green! #:nodoc:
-    @setting = :green unless yellow?
-  end
-  
   def yellow?
     @setting == :yellow
   end
   
-  def yellow! #:nodoc:
-    @setting = :yellow
-  end
-  
   def red?
     @setting == :red
   end
-  
-  def red! #:nodoc:
-    @setting = :red unless yellow?
+    
+  def unneeded?
+    @setting == :unneeded
   end
   
   def color

data/lib/data/ciat.css

@@ -35,6 +35,18 @@
   margin: 0;
 }
 
-.details h4, .details h3 {
-  margin: 0;
+.details table, .details p {
+  margin-left: 10px;
+}
+
+tr.details td {
+  padding-bottom: 10px;
+}
+
+.details h3 {
+  margin: 20px 10px 10px 10px;
+}
+
+.details h4 {
+  margin: 10px;
 }

data/lib/data/elements.yml

@@ -7,9 +7,12 @@ compilation:
 compilation_generated:
   description: compilation
   template: plain
-compilation_error:
+compilation_error_generated:
   description: error from compilation
   template: plain
+compilation_error_diff:
+  description: diff of error output
+  template: diff
 compilation_diff:
   description: compilation diff
   template: diff
@@ -19,12 +22,15 @@ execution:
 execution_generated:
   description: execution
   template: plain
-execution_error:
+execution_error_generated:
   description: error from execution
   template: plain
 execution_diff:
   description: execution diff
   template: diff
+execution_error_diff:
+  description: execution error diff
+  template: diff
 command_line:
   description: command-line arguments
   template: plain

data/lib/templates/detail_row.html.erb

@@ -1,10 +1,16 @@
-<tr class="details" style="display:none">
+<tr id="details_<%= filename_to_id(result.filename) %>"
+		class="details" style="display:none">
   <td colspan="<%= result.subresults.size + 1 %>">
 	
 	<% result.subresults.each do |subresult| %>
-	  <h3>Results from <%= subresult.processor.describe %></h3>
-		<%= render "detail_row/elements", 
-			:elements => subresult.relevant_elements %>
+	  <h3>Results from <%= subresult.processor.describe %> (<%= subresult.path_kind %> path)</h3>
+	
+		<% if subresult.light.unset? || subresult.light.unneeded? %>
+			<p>Not executed.</p>
+		<% else %>
+			<%= render "detail_row/elements", 
+				:elements => subresult.relevant_elements %>
+		<% end %>
 	<% end %>
 
 </tr>

data/lib/templates/report.html.erb

@@ -27,11 +27,11 @@
   		</tr>
 
   		<% results.each do |result| %>
-			<% if new_grouping?(result) %>
-				<%= render "group_header", :result => result %>
-			<% end %>
-			<%= render "summary_row", :result => result %>
-			<%= render "detail_row", :result => result %>
+				<% if new_grouping?(result) %>
+					<%= render "group_header", :result => result %>
+				<% end %>
+				<%= render "summary_row", :result => result %>
+				<%= render "detail_row", :result => result %>
   		<% end %>
   	</table>
 	</body>

data/lib/templates/summary_row.html.erb

@@ -1,11 +1,13 @@
-<tr class="summary">
+<tr id="summary_<%= filename_to_id(result.filename) %>" class="summary">
 	<td>
-	  <a href="#" onclick="$(this).up('tr').next().toggle(); return false;" title="<%= result.filename %>">
+	  <a href="#"
+			onclick="$(this).up('tr').next().toggle(); return false;"
+			title="<%= result.filename %>">
 	  <%= result.element(:description).content %>
 	  </a>
   </td>
 	<% result.subresults.each do |subresult| %>
-	  <td class="<%= subresult.light.setting %>">
+	  <td class="<%= subresult.light.color %>">
 	    <%= light_to_word(subresult.light) %>
 	  </td>
 	<% end %>

data/spec/ciat/{test_file_spec.rb → ciat_file_spec.rb}

@@ -1,10 +1,10 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
-describe CIAT::TestFile do
+describe CIAT::CiatFile do
   before(:each) do
     File.should_receive(:exists?).with(anything).
       any_number_of_times.and_return(true)
-    @test_file = CIAT::TestFile.new(mock("filename"), mock("output folder"))
+    @ciat_file = CIAT::CiatFile.new(mock("filename"), mock("output folder"))
   end
   
   describe "processing test file" do
@@ -17,10 +17,10 @@ describe CIAT::TestFile do
         :e0 => mock("element 0"), :e1 => mock("element 1"), 
         :e2 => mock("element 2") }
 
-      @test_file.should_receive(:split).and_return(raw_elements)
-      @test_file.should_receive(:filename).with(:e0).and_return(filenames[0])
-      @test_file.should_receive(:filename).with(:e1).and_return(filenames[1])
-      @test_file.should_receive(:filename).with(:e2).and_return(filenames[2])
+      @ciat_file.should_receive(:split).and_return(raw_elements)
+      @ciat_file.should_receive(:filename).with(:e0).and_return(filenames[0])
+      @ciat_file.should_receive(:filename).with(:e1).and_return(filenames[1])
+      @ciat_file.should_receive(:filename).with(:e2).and_return(filenames[2])
       CIAT::TestElement.should_receive(:new).
         with(:e0, filenames[0], raw_elements[:e0]).and_return(elements[:e0])
       CIAT::TestElement.should_receive(:new).
@@ -28,69 +28,101 @@ describe CIAT::TestFile do
       CIAT::TestElement.should_receive(:new).
         with(:e2, filenames[2], raw_elements[:e2]).and_return(elements[:e2])
       
-      @test_file.process.should == elements
+      @ciat_file.process.should == elements
     end
   end
   
   describe "splitting a test file" do
     it "should split just a description" do
       expect_file_content("description only\n")
-      @test_file.split.should == { :description => "description only\n" }
+      @ciat_file.split.should == { :description => "description only\n" }
     end
     
     it "should split description and something else" do
       expect_file_content("description\n", "==== tag\n", "content\n")
-      @test_file.split.should == { :description => "description\n", :tag => "content\n" }
+      @ciat_file.split.should == { :description => "description\n", :tag => "content\n" }
     end
     
     it "should split the test file" do
       expect_file_content("d\n", "==== source\n", "s\n",
         "==== compilation_expected \n", "p\n",
         "==== output_expected\n", "o\n")
-      @test_file.split.should == { :description => "d\n",
+      @ciat_file.split.should == { :description => "d\n",
         :source => "s\n", :compilation_expected => "p\n", :output_expected => "o\n" }
     end
     
     it "should allow spaces in element name" do
       expect_file_content("description\n" , "==== element name\n", "content\n")
-      @test_file.split.should == {
+      @ciat_file.split.should == {
         :description => "description\n", :element_name => "content\n" }
     end
     
     def expect_file_content(*content)
-      @test_file.should_receive(:read).and_return(content)
+      @ciat_file.should_receive(:read).and_return(content)
+    end
+  end
+  
+  describe "processing elements" do
+    before(:each) do
+      @elements = mock("elements")
+      @ciat_file.should_receive(:elements).and_return(@elements)
+    end
+    
+    it "should return specified element" do
+      element = mock("element")
+    
+      @elements.should_receive(:[]).with(:foo).and_return(element)
+    
+      @ciat_file.element(:foo).should == element
+    end
+
+    it "should return specified element with multi-word name" do
+      element = mock("element")
+    
+      @elements.should_receive(:[]).with(:foo_bar_joe).and_return(element)
+    
+      @ciat_file.element(:foo, :bar, :joe).should == element
+    end
+  
+    it "should check to see if element exists" do
+      exists = mock("a boolean")
+    
+      @elements.should_receive(:has_key?).
+        with(:foo_bar_joe).and_return(exists)
+    
+      @ciat_file.element?(:foo, :bar, :joe).should == exists
     end
   end
 end
 
-describe CIAT::TestFile, "generating actual file names" do
+describe CIAT::CiatFile, "generating actual file names" do
   before(:each) do
     File.should_receive(:exists?).with(anything).
       any_number_of_times.and_return(true)
     @output_folder = "outie"
-    @test_file = CIAT::TestFile.new("ciat/phile.ciat", @output_folder)
+    @ciat_file = CIAT::CiatFile.new("ciat/phile.ciat", @output_folder)
   end
   
   it "should return the original filename" do
-    @test_file.filename(:ciat).should == "ciat/phile.ciat"
+    @ciat_file.filename(:ciat).should == "ciat/phile.ciat"
   end
   
   it "should work with no modifiers" do
-    @test_file.filename().should == "outie/ciat/phile"
+    @ciat_file.filename().should == "outie/ciat/phile"
   end
   
   it "should work with multiple modifiers" do
-    @test_file.filename("one", "two", "three").should == "outie/ciat/phile_one_two_three"
+    @ciat_file.filename("one", "two", "three").should == "outie/ciat/phile_one_two_three"
   end
 end
 
-describe CIAT::TestFile, "constructor errors" do
+describe CIAT::CiatFile, "constructor errors" do
   it "should complain about a missing file" do
     File.should_receive(:exists?).
       with("does-not-exist.ciat").and_return(false)
     
     lambda {
-      CIAT::TestFile.new("does-not-exist.ciat", nil)
+      CIAT::CiatFile.new("does-not-exist.ciat", nil)
     }.should raise_error(IOError)
   end
 end