ciat 0.4.8

data/lib/ciat/processors/compilation_interpreter.rb

@@ -0,0 +1,18 @@
+class CIAT::Processors::CompilationInterpreter
+  def element_name_hash
+    {
+      :green => [:compilation_generated, :execution_generated],
+      :yellow => [:compilation_generated, :execution_error],
+      :red => [:compilation_generated, :execution_diff],
+      :unset => []
+    }
+  end
+  
+  def input_name
+    :compilation_generated
+  end
+  
+  def output_name
+    :execution
+  end
+end

data/lib/ciat/processors/compiler.rb

@@ -0,0 +1,18 @@
+class CIAT::Processors::Compiler
+  def element_name_hash
+    {
+      :green => [:source, :compilation_generated],
+      :yellow => [:source, :compilation_error],
+      :red => [:source, :compilation_diff],
+      :unset => []
+    }
+  end
+
+  def input_name
+    :source
+  end
+  
+  def output_name
+    :compilation
+  end
+end

data/lib/ciat/processors/copy.rb

@@ -0,0 +1,37 @@
+module CIAT
+  module Processors
+    # A simple processor that just simply copies the code from one file to the other
+    # using the Unix +cp+ command.
+    class Copy
+      attr :light, true
+      
+      def initialize(original, copy)
+        @original = original
+        @copy = copy
+        @light = CIAT::TrafficLight.new
+      end
+      
+      def for_test
+        copy = clone
+        copy.light = light.clone
+        copy
+      end
+      
+      def describe
+        "copy processor"
+      end
+      
+      def process(crate)
+        if system( "cp '#{crate.element(@original).as_file}' '#{crate.element(@copy).as_file}'")
+          light.green!
+        else
+          light.red!
+        end
+      end
+      
+      def relevant_elements(crate)
+        [@original, @copy].map { |e| crate.element(e) }
+      end
+    end
+  end
+end

data/lib/ciat/processors/interpreter.rb

@@ -0,0 +1,18 @@
+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 => []
+    }
+  end
+  
+  def input_name
+    :source
+  end
+  
+  def output_name
+    :execution
+  end
+end

data/lib/ciat/rake_task.rb

@@ -0,0 +1,56 @@
+# = A Rake Task for a Suite of Tests
+#
+# This is the class to use in your +Rakefile+.  The simplest use looks like
+# this:
+#
+#   CIAT::RakeTask(:name_of_task) do |t|
+#     t.processors << compiler
+#     t.processors << executor
+#   end
+#
+# Define +compiler+ and +executor+ in the +Rakefile+ to return a compiler and
+# executor, respectively.  <code>:name_of_task</code> is (as I try to make
+# clear by its name) the name of the rake task.  If you leave out this name,
+# it defaults to <code>:ciat</code>.  The options on +t+ correspond directly
+# to the options of CIAT::Suite.  See CIAT::Suite for defaults and details.
+#
+# * <code>t.processors</code> is <em>required</em> and specifies the
+#   processors to be executed; order matters!  Use <code>=</code> to assign a
+#   list of processors; use <code>&lt;&lt;</code> to push processors onto the
+#   existing list of processors.
+# * <code>t.folder</code> specifies folders to search for test files.
+# * <code>t.files</code> is an array of specific files.
+# * <code>t.report_filename</code> is the name of the report
+# * <code>t.feedback</code> specifies a feedback mechanism
+#
+class CIAT::RakeTask
+  attr_accessor :processors
+  attr_accessor :files
+  attr_accessor :feedback
+  attr_accessor :folder
+  attr_accessor :report_filename
+  attr_accessor :report_title
+  attr_accessor :output_folder
+  
+  def initialize(name = :ciat)
+    @name = name
+    @processors = []
+    yield self if block_given?
+    define
+  end
+  
+  def define
+    desc "Run CIAT tests" + (@name==:test ? "" : ", #{@name}")
+    task @name do
+      suite = CIAT::Suite.new(
+        :processors => @processors,
+        :files => @files,
+        :feedback => @feedback,
+        :folder => @folder,
+        :report_filename => @report_filename,
+        :output_folder => @output_folder,
+        :report_title => @report_title)
+      suite.run
+    end
+  end
+end

data/lib/ciat/suite.rb

@@ -0,0 +1,112 @@
+require 'erb'
+require 'ciat/feedback/composite'
+require 'ciat/feedback/feedback_counter'
+require 'ciat/feedback/return_status'
+
+# = A Suite of Tests
+#
+# This is the top-level class for organizing CIAT tests.  It can be used in a
+# +Rakefile+ like so:
+#
+#   task :ciat do
+#     CIAT::Suite.new(:processors => [compiler, executor]).run
+#   end
+#
+# You may find the CIAT::RakeTask a little bit easier and more familiar 
+# to use.
+#
+# == Specifying Test and Output Files and Folders
+#
+# By default, this suite will do the following:
+# * find tests ending in <code>.ciat</code> in a folder named
+#   <code>ciat</code>,
+# * use simple standard-output feedback,
+# * put all output files into a folder named <code>temp</code>,
+# * produce an HTML report in <code>temp/report.html</code>.
+#
+# Each of these settings can be overridden with these options:
+# * <code>:processors</code> is <em>required</em> and specifies the processors
+#   to be executed; order matters!
+# * <code>:folder</code> specifies folders to search for test files (default:
+#   <code>ciat/**</code>).
+# * <code>:pattern</code> specifies a pattern for matching test files
+#   (default: <code>*.ciat</code>).
+# * <code>:files</code> is an array of specific files (default: none).
+# * <code>:output_folder</code> is the output folder (default: +temp+)
+# * <code>:report_filename</code> is the name of the report (default:
+#   <code>report.html</code> in the output folder)
+# * <code>:feedback</code> specifies a feedback mechanism (default: a
+#   CIAT::Feedback::StandardOutput).
+#
+# <code>:folder</code> and <code>:pattern</code> can be used together;
+# <code>:files</code> overrides both <code>:folder</code> and
+# <code>:pattern</code>.
+#
+# == Processors
+#
+# 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).
+#
+# == 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
+  
+  # Constructs 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
+      )
+  end
+  
+  # Returns the number of tests in the suite.
+  def size
+    cargo.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) }.
+      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)
+      )
+  end
+end

data/lib/ciat/test.rb

@@ -0,0 +1,41 @@
+require 'set'
+
+class CIAT::Test
+  attr_reader :filename
+  attr_reader :processors
+  attr_reader :elements
+
+  def initialize(filename, elements, options={}) #:nodoc:
+    @filename = filename
+    @elements = elements
+    @processors = options[:processors]
+    @feedback = options[:feedback]
+  end
+  
+  def run
+    run_processors
+    report_lights
+    self
+  end
+  
+  def run_processors #:nodoc:
+    processors.each do |processor|
+      processor.process(self)
+      break unless processor.light.green?
+    end
+  end
+  
+  def report_lights #:nodoc:
+    processors.each do |processor|
+      @feedback.processor_result(processor)
+    end
+  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_element.rb

@@ -0,0 +1,44 @@
+require "yaml"
+
+class CIAT::TestElement
+  attr_reader :name
+  attr_reader :filename
+  
+  def initialize(name, filename, content)
+    @name = name
+    @filename = filename
+    @content = content
+  end
+  
+  def template
+    if yaml_entry.nil?
+      raise "Need entry for #{name.to_s} in data/elements.yml"
+    end
+    File.join("elements", yaml_entry["template"])
+  end
+  
+  def describe
+    yaml_entry["description"]
+  end
+  
+  def yaml_entry
+    metadata[name.to_s]
+  end
+  
+  def content
+    @content ||= CIAT::Cargo.read_file(@filename)
+  end
+  
+  def as_file
+    if @content
+      CIAT::Cargo.write_file(@filename, @content)
+    end
+    @filename
+  end
+  
+  private
+  
+  def metadata
+    @@metadata ||= YAML.load_file(File.join(File.dirname(__FILE__), "..", "data", "elements.yml"))
+  end
+end

data/lib/ciat/traffic_light.rb

@@ -0,0 +1,39 @@
+class CIAT::TrafficLight
+  attr_reader :setting
+  
+  def initialize(setting = :unset) #:nodoc:
+    @setting = setting
+  end
+  
+  def unset?
+    @setting == :unset
+  end
+  
+  def green?
+    @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?
+  end
+  
+  def color
+    @setting.to_s
+  end
+end

data/lib/ciat/version.rb

@@ -0,0 +1,7 @@
+module CIAT::VERSION #:nodoc:
+  MAJOR = 0
+  MINOR = 3
+  TINY  = 0
+
+  STRING = [MAJOR, MINOR, TINY].join('.')
+end

data/lib/data/ciat.css

@@ -0,0 +1,40 @@
+/* color scheme from FitNesse */
+.red {
+    background-color: #FFAAAA;
+}
+.green {
+    background-color: #AAFFAA;
+}
+.yellow {
+    background-color: #FFFFAA;
+}
+.unset {
+    background-color: #CCCCCC;
+}
+
+.code {
+    background-color: #AAAAFF;
+}
+
+.compilation_error .code {
+  background-color: #FFFFAA;
+}
+
+
+.results {
+  clear: both;
+}
+
+.details .diff td {
+  padding-top: 0;
+  padding-bottom: 0;
+}
+
+.details pre {
+  padding: 0.5em;
+  margin: 0;
+}
+
+.details h4, .details h3 {
+  margin: 0;
+}