ciat 0.4.8 → 0.4.9

data/README.rdoc

@@ -69,8 +69,8 @@ When the "Parrot executor" is run on the compilation, it'll also pass in <code>8
 This sample +Rakefile+ will pull everything together:
 
   require 'ciat'
-  require 'ciat/compilers/java'
-  require 'ciat/executors/parrot'
+  require 'ciat/processors/java'
+  require 'ciat/processors/parrot'
 
   def compiler
     classpath = Dir.glob('../lib/*.jar').join(':') + ":../bin"
@@ -78,7 +78,7 @@ This sample +Rakefile+ will pull everything together:
   end
 
   def executor
-    CIAT::Executors::Parrot.new
+    CIAT::Processors::Parrot.new
   end
 
   CIAT::RakeTask.new do |t|
@@ -97,7 +97,7 @@ documentation for CIAT::RakeTask for more information.
 
 * Pronounce "CIAT" as "dog".  (See this funny video[http://www.youtube.com/watch?v=tyQvjKqXA0Y].)
 * Must have +diff+ executable.
-* You have to provide your own target-code executors (e.g., +parrot+ for the
+* You have to provide your own target-code processors (e.g., +parrot+ for the
   Parrot Virtual Machine, +spim+ for MIPS emulation, etc.)
 
 

data/lib/ciat.rb

@@ -1,9 +1,8 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-# Loads in the basic files needed to use CIAT.  Compilers and Executors have
-# to be required separately. CIAT::Suite is the class you really want to look
-# at.
+# Loads in the basic files needed to use CIAT.  Processors have to be required
+# separately. CIAT::Suite is the class you really want to look at.
 module CIAT; end
 
 require 'ciat/rake_task'
@@ -11,8 +10,7 @@ require 'ciat/traffic_light'
 require 'ciat/suite'
 require 'ciat/test'
 require 'ciat/test_element'
-require 'ciat/cargo'
-require 'ciat/crate'
+require 'ciat/test_file'
 require 'ciat/feedback/standard_output'
 require 'ciat/feedback/html_feedback'
 require 'ciat/differs/html_differ'

data/lib/ciat/differs/html_differ.rb

@@ -1,14 +1,13 @@
 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 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>' " +

data/lib/ciat/erb_helpers.rb

@@ -41,11 +41,11 @@ module CIAT::ERBHelpers
   	string.gsub("\t", "    ")
   end
   
-  def new_path?(result)
-    if @old_path == File.dirname(result.filename)
+  def new_grouping?(result)
+    if @old_grouping == result.grouping
       false
     else
-      @old_path = File.dirname(result.filename)
+      @old_grouping = result.grouping
       true
     end
   end
@@ -53,7 +53,9 @@ module CIAT::ERBHelpers
   # 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)
+    erb = ERB.new(read(file))
+    erb.filename = file
+    erb.result(CIAT::TemplateBinder.new(locals).get_binding)
   end
   
   private

data/lib/ciat/feedback/composite.rb

@@ -13,8 +13,8 @@ module CIAT::Feedback
       @feedbacks.each { |feedback| feedback.post_tests(suite) }
     end
   
-    def processor_result(processor)
-      @feedbacks.each { |feedback| feedback.processor_result(processor) }
+    def report_subresult(subresult)
+      @feedbacks.each { |feedback| feedback.report_subresult(subresult) }
     end
   end
 end

data/lib/ciat/feedback/feedback_counter.rb

@@ -32,8 +32,8 @@ module CIAT
         nil
       end
       
-      def processor_result(processor)
-        case processor.light.setting
+      def report_subresult(subresult)
+        case subresult.light.setting
         when :red
           increment_failure_count
         when :yellow

data/lib/ciat/feedback/html_feedback.rb

@@ -1,34 +1,51 @@
 require 'ciat/erb_helpers'
+require 'ciat/feedback/html_feedback_builder'
+require 'ciat/io'
 
 module CIAT::Feedback
   class HtmlFeedback
     include CIAT::ERBHelpers
+    include CIAT::IO
     
-    def initialize(counter)
+    attr_reader :report_title
+    attr_reader :report_filename
+    
+    def initialize(counter, options)
       @counter = counter
+      builder = CIAT::Feedback::HtmlFeedbackBuilder.new(options)
+      @report_title = builder.build_report_title
+      @report_filename = builder.build_report_filename
     end
 
     def pre_tests(suite)
-      suite.cargo.copy_suite_data      
+      FileUtils.mkdir_p(suite.output_folder)
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "data", "ciat.css"), suite.output_folder)
+      FileUtils.cp(File.join(File.dirname(__FILE__), "..", "..", "data", "prototype.js"), suite.output_folder)
     end
   
-    def processor_result(processor)
+    def report_subresult(processor)
       nil
     end
   
     def post_tests(suite)
-      suite.cargo.write_file(
-        suite.cargo.report_filename, 
-        generate_html(suite))
+      write_file(
+        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)
+      build_erb.result(binding)
+    end
+    
+    def build_erb
+      e = ERB.new(template)
+      e.filename = "report.html.erb"
+      e
     end
 
     def template #:nodoc:

data/lib/ciat/feedback/html_feedback_builder.rb

@@ -0,0 +1,28 @@
+require 'ciat/io'
+
+class CIAT::Feedback::HtmlFeedbackBuilder
+  include CIAT::IO
+  
+  attr_reader :options
+  
+  def initialize(options)
+    @options = options
+  end
+  
+  def build_output_folder
+    options[:output_folder] || OUTPUT_FOLDER
+  end
+  
+  def build_report_filename
+    File.join(build_output_folder, options[:report_filename] || REPORT_FILENAME)
+  end
+  
+  def build_report_title
+    if options[:report_title]
+      "CIAT Report: " + options[:report_title]
+    else
+      "CIAT Report"
+    end
+  end
+
+end

data/lib/ciat/feedback/return_status.rb

@@ -11,7 +11,7 @@ module CIAT::Feedback
       end
     end
     
-    def processor_result(processor)
+    def report_subresult(processor)
       @failure ||= processor.light.yellow? || processor.light.red?
     end
     

data/lib/ciat/feedback/standard_output.rb

@@ -21,7 +21,7 @@ module CIAT
         print ".\n"
       end
       
-      def processor_result(processor)
+      def report_subresult(processor)
         putc LIGHT_OUTPUTS[processor.light.setting]
       end
     end

data/lib/ciat/io.rb

@@ -0,0 +1,17 @@
+module CIAT::IO
+  
+  OUTPUT_FOLDER = "temp"
+  REPORT_FILENAME = "report.html"
+  
+  def write_file(filename, content)
+    FileUtils.mkdir_p(File.dirname(filename))
+    File.open(filename, "w") do |file|
+      file.write content
+    end
+  end
+  
+  def read_file(filename)
+    File.read(filename)
+  end
+  
+end

data/lib/ciat/processors/basic_processing.rb

@@ -1,30 +1,31 @@
-module CIAT::Processors
-  module BasicProcessing    
-    # Produces a clone for an individual test.
-    def for_test
-      copy = clone
-      copy.light = light.clone
-      copy
-    end
+require 'rake'
+require 'ciat/differs/html_differ'
 
+module CIAT::Processors
+  module BasicProcessing
+    include CIAT::Differs::HtmlDiffer
+    
     # 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!
+          CIAT::TrafficLight::GREEN
         else
-          light.red!
+          CIAT::TrafficLight::RED
         end
       else
-        light.yellow!
+        CIAT::TrafficLight::YELLOW
       end
-      test
     end
-    
+
     def execute(test)
-      system "#{executable} '#{input_file(test)}' #{command_line_args(test)} > '#{output_file(test)}' 2> '#{error_file(test)}'"
+      RakeFileUtils.verbose(false) do
+        sh "#{executable} '#{input_file(test)}' #{command_line_args(test)} > '#{output_file(test)}' 2> '#{error_file(test)}'" do |ok, result|
+          return ok
+        end
+      end
     end
     
     def command_line_args(test) #:nodoc:
@@ -34,31 +35,21 @@ module CIAT::Processors
     # 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]
+        test.element(kind.output_name).as_file,
+        test.element(kind.output_name, :generated).as_file, 
+        test.element(kind.output_name, :diff).as_file)
     end
     
     def input_file(test)
-      test.element(processor_kind.input_name).as_file
+      test.element(kind.input_name).as_file
     end
 
     def output_file(test)
-      test.element(processor_kind.output_name, :generated).as_file
+      test.element(kind.output_name, :generated).as_file
     end
 
     def error_file(test)
-      test.element(processor_kind.output_name, :error).as_file
+      test.element(kind.output_name, :error).as_file
     end
   end
 end

data/lib/ciat/{executors → processors}/java.rb

@@ -1,26 +1,25 @@
 module CIAT
-  module Executors
+  module Processors
     # Executor class for Java interpreters.
     #
     class Java
       include CIAT::Processors::BasicProcessing
-      include CIAT::Differs::HtmlDiffer
 
       # Traffic light
-      attr :light, true
-      attr_reader :processor_kind
+      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, options={})
-        @processor_kind = options[:processor_kind] || CIAT::Processors::Interpreter.new
+      def initialize(classpath, interpreter_class)
         @classpath = classpath
         @interpreter_class = interpreter_class
-        @description = options[:description] || "in-Java interpreter"
-        @light = CIAT::TrafficLight.new
+        self.kind = CIAT::Processors::Interpreter.new
+        self.description = "in-Java interpreter"
+        yield self if block_given?
       end
       
       # Provides a description of the processor.

data/lib/ciat/{executors → processors}/parrot.rb

@@ -1,5 +1,5 @@
 module CIAT
-  module Executors
+  module Processors
     # Executor class for Parrot programs.  This will execute PIR or PASM code
     # using the +parrot+ executable.
     #
@@ -17,9 +17,9 @@ module CIAT
       include CIAT::Processors::BasicProcessing
       include CIAT::Differs::HtmlDiffer
 
-      # Traffic light
-      attr :light, true
-      attr_reader :processor_kind
+      attr_accessor :kind
+      attr_accessor :description
+      attr_accessor :libraries
 
       # Creates a Parrot executor.
       #
@@ -30,12 +30,11 @@ module CIAT
       #   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
+      def initialize()
+        self.kind = CIAT::Processors::Interpreter.new
+        self.description = "Parrot virtual machine"
+        self.libraries = []
+        yield self if block_given?
       end
       
       # Provides a description of the processor.

data/lib/ciat/rake_task.rb

@@ -42,7 +42,7 @@ class CIAT::RakeTask
   def define
     desc "Run CIAT tests" + (@name==:test ? "" : ", #{@name}")
     task @name do
-      suite = CIAT::Suite.new(
+      suite = CIAT::Suite.build(
         :processors => @processors,
         :files => @files,
         :feedback => @feedback,

data/lib/ciat/subresult.rb

@@ -0,0 +1,20 @@
+class CIAT::Subresult
+  attr_reader :light
+  attr_reader :processor
+  
+  def initialize(elements, light, processor)
+    @elements = elements
+    @light = light
+    @processor = processor
+  end
+  
+  def relevant_elements
+    relevant_element_names.
+      select { |name| @elements.element?(name) }.
+      map { |name| @elements.element(name) }
+  end
+  
+  def relevant_element_names
+    @processor.kind.element_name_hash[@light.setting]
+  end
+end

data/lib/ciat/suite.rb

@@ -2,6 +2,7 @@ require 'erb'
 require 'ciat/feedback/composite'
 require 'ciat/feedback/feedback_counter'
 require 'ciat/feedback/return_status'
+require 'ciat/suite_builder'
 
 # = A Suite of Tests
 #
@@ -46,67 +47,55 @@ require 'ciat/feedback/return_status'
 #
 # You can create your own processors.  Each processor needs to specify which
 # test elements it wants or will accept, which files it wants checked, and how
-# it should be executed.    See CIAT::Compilers::Java and
-# CIAT::Executors::Parrot (to learn how to use them and how to write others).
+# it should be executed.    See CIAT::Processors::Java and
+# CIAT::Processors::Parrot (to learn how to use them and how to write others).
 #
 # == Test File
 #
 # See the README for details on the format of a test file.
 #
 class CIAT::Suite
-  attr_reader :cargo
-  attr_reader :results
+  
   attr_reader :processors
-  attr_reader :report_title
+  attr_reader :output_folder
+  attr_reader :test_files
+  attr_reader :results
   
-  # Constructs a suite of CIAT tests.  See the instructions above for possible
+  # Builds a suite of CIAT tests.  See the instructions above for possible
   # values for the +options+.
-  def initialize(options = {})
-    @processors = options[:processors]
-    @cargo = options[:cargo] || CIAT::Cargo.new(options)
-    @report_title = "CIAT Report"
-    if options[:report_title]
-      @report_title = @report_title + ": " + options[:report_title]
-    end
-    @feedback = options[:feedback] || default_feedback
-    @feedback = CIAT::Feedback::Composite.new(
-        @feedback, CIAT::Feedback::ReturnStatus.new
-      )
+  def self.build(options = {})
+    builder = CIAT::SuiteBuilder.new(options)
+    CIAT::Suite.new(
+      builder.build_processors,
+      builder.build_output_folder,
+      builder.build_test_files,
+      builder.build_feedback)
   end
   
+  def initialize(processors, output_folder, test_files, feedback)
+    @processors = processors
+    @output_folder = output_folder
+    @test_files = test_files
+    @feedback = feedback
+  end
+    
   # Returns the number of tests in the suite.
   def size
-    cargo.size
+    test_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 = cargo.crates.
-      map { |crate| create_test(crate) }.
+    @results = test_files.
+      map { |test_file| create_test(test_file) }.
       map { |test| test.run }
     @feedback.post_tests(self)
     @results
   end
   
-  def create_test(crate)
-    CIAT::Test.new(crate.test_file,
-      crate.process_test_file,
-      :processors => test_processors,
-      :feedback => @feedback)
-  end
-  
-  def test_processors #:nodoc:
-    @processors.map { |processor| processor.for_test }
-  end
-  
-  private
-  def default_feedback
-    counter = CIAT::Feedback::FeedbackCounter.new
-    CIAT::Feedback::Composite.new(counter,
-      CIAT::Feedback::StandardOutput.new(counter),
-      CIAT::Feedback::HtmlFeedback.new(counter)
-      )
+  def create_test(test_file)
+    CIAT::Test.new(test_file, @processors, @feedback)
   end
 end