asautotest 0.0.1

data/bin/flash-policy-server

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# flash-policy-server --- simple Flash security policy file server
+# Copyright (C) 2010  Go Interactive
+
+# This file is part of ASAutotest.
+
+# ASAutotest is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ASAutotest is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ASAutotest.  If not, see <http://www.gnu.org/licenses/>.
+
+require "socket"
+require "timeout"
+
+class PolicyServer
+  PORT = 843
+
+  def initialize
+    @server = TCPServer.new(PORT)
+    @server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+
+    info "Listening to localhost:#{PORT}."
+  end
+
+  def run
+    loop { accept }
+  end
+
+  def accept
+    handle_socket(@server.accept)
+  end
+
+  def info(message)
+    puts info_string(message)
+  end
+
+  def info_string(message)
+    "policy-server: #{message}"
+  end
+
+  def begin_info(message)
+    STDOUT.print info_string("#{message}...")
+    STDOUT.flush
+  end
+
+  def end_info(message)
+    STDOUT.puts " #{message}."
+  end
+
+  EXPECTED_REQUEST = "<policy-file-request/>\0"
+
+  def handle_socket(socket)
+    source = "#{socket.peeraddr[2]}:#{socket.peeraddr[1]}"
+    begin_info "Serving #{source}"
+    request = Timeout.timeout(3) { socket.read(EXPECTED_REQUEST.size) }
+    if request == EXPECTED_REQUEST
+      socket.print(policy_xml)
+      socket.print("\0")
+      end_info "ok"
+    else
+      end_info "recieved garbage: #{request.inspect}"
+    end
+  rescue Timeout::Error
+    end_info "timeout"
+  ensure
+    socket.close
+  end
+
+  def policy_xml
+    <<-end_xml
+      <cross-domain-policy>
+        <site-control permitted-cross-domain-policies="master-only"/>
+        <allow-access-from domain="*" to-ports="*"/>
+      </cross-domain-policy>
+    end_xml
+  end
+end
+
+PolicyServer.new.run

data/lib/asautotest/compilation-output-parser.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+# compilation-output-parser.rb --- parse the output of one compilation
+# Copyright (C) 2010  Go Interactive
+
+# This file is part of ASAutotest.
+
+# ASAutotest is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ASAutotest is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ASAutotest.  If not, see <http://www.gnu.org/licenses/>.
+
+module ASAutotest
+  class OutputParser
+    def initialize(output, request, stopwatch, result)
+      @output = output
+      @request = request
+      @stopwatch = stopwatch
+      @result = result
+
+      @problematic_file_names = Set.new
+      @n_problems = 0
+    end
+
+    def self.parse(*arguments)
+      new(*arguments).run
+    end
+
+    def run
+      parse_lines
+      add_summary
+    end
+
+    def parse_lines
+      @result.source_directories = @request.source_directories
+
+      while has_more_lines?
+        line = read_line
+        puts ">> #{line}" if Logging.verbose?
+        parse_line(line)
+      end
+    end
+
+    def parse_line(line)
+      case line
+      when /^Loading configuration file /
+      when /^fcsh: Assigned (\d+) as the compile target id/
+        @request.compile_id = $1
+      when /^Recompile: /
+      when /^Reason: /
+      when /^\s*$/
+      when /\(\d+ bytes\)$/
+        @successful = true
+      when /^Nothing has changed /
+        @n_recompiled_files = 0
+      when /^Files changed: (\d+) Files affected: (\d+)/
+        @n_recompiled_files = $1.to_i + $2.to_i
+      when /^(.*?)\((\d+)\): col: (\d+) (.*)/
+        file_name = $1
+        line_number = $2.to_i
+        column_number = $3.to_i - 1
+        message = $4
+        source_line = read_lines(4)[1]
+
+        location = Location[line_number, column_number, source_line]
+        problem = Problem[message, location]
+
+        add_problem(file_name, problem)
+      when /^Error: (.*)/
+        add_problem(nil, Problem[$1, nil])
+      when /^(.*?): (.*)/
+        add_problem($1, Problem[$2, nil])
+      else
+        @result.add_unrecognized_line(line)
+      end
+    end
+
+    def add_problem(file_name, problem)
+      @first_problem ||= problem
+      @problematic_file_names << file_name
+      @n_problems += 1
+      @result.add_problem(file_name, problem)
+    end
+
+    def add_summary
+      @result.add_summary \
+        :request => @request,
+        :successful? => @successful,
+        :n_recompiled_files => @n_recompiled_files,
+        :n_problematic_files => @problematic_file_names.size,
+        :n_problems => @n_problems,
+        :first_problem => @first_problem,
+        :compilation_time => @stopwatch
+    end
+
+    def has_more_lines?
+      not @output.empty?
+    end
+
+    def read_lines(n)
+      @output.shift(n).map(&:chomp)
+    end
+
+    def read_line
+      @output.shift.chomp
+    end
+  end
+end

data/lib/asautotest/compilation-result.rb

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+# compilation-result.rb --- collect the results of a compilation
+# Copyright (C) 2010  Go Interactive
+
+# This file is part of ASAutotest.
+
+# ASAutotest is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ASAutotest is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ASAutotest.  If not, see <http://www.gnu.org/licenses/>.
+
+module ASAutotest
+  class CompilationResult
+    attr_reader :n_recompiled_files
+    attr_reader :problematic_files
+    attr_reader :unrecognized_lines
+    attr_reader :summaries
+
+    def initialize
+      @problematic_files = {}
+      @n_recompiled_files = nil
+      @unrecognized_lines = []
+      @summaries = []
+    end
+    
+    # ----------------------------------------------------
+
+    def source_directories= value
+      @source_directories = value
+    end
+
+    def add_problem(file_name, problem)
+      get_problematic_file(file_name) << problem unless
+        @typing == :dynamic and problem.type_warning?
+    end
+
+    def get_problematic_file(file_name)
+      if @problematic_files.include? file_name
+        @problematic_files[file_name]
+      else
+        @problematic_files[file_name] =
+          ProblematicFile.new(file_name, @source_directories)
+      end
+    end
+
+    # ----------------------------------------------------
+
+    def add_unrecognized_line(line)
+      @unrecognized_lines << line
+    end
+
+    def add_summary(summary)
+      @summaries << summary
+    end
+
+    # ----------------------------------------------------
+
+    def any_type_warnings?
+      @problematic_files.values.any? &:any_type_warnings?
+    end
+
+    def successful?
+      @summaries.all? { |x| x[:successful?] }
+    end
+
+    def n_problematic_files
+      @problematic_files.values.size
+    end
+
+    def n_problems
+      @problematic_files.values.inject(0) { |a, x| a + x.n_problems }
+    end
+
+    def failed?
+      not successful?
+    end
+
+    def bootstrap?
+      @summaries.all? { |x| x[:n_recompiled_files] == nil }
+    end
+
+    def n_recompiled_files
+      @summaries.inject(0) { |a, x| a + x[:n_recompiled_files] }
+    end
+
+    def recompilation?
+      not bootstrap?
+    end
+
+    def did_anything?
+      bootstrap? or n_recompiled_files > 0
+    end
+  end
+end

data/lib/asautotest/compilation-runner.rb

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+# compilation-runner.rb --- run compilations and report the results
+# Copyright (C) 2010  Go Interactive
+
+# This file is part of ASAutotest.
+
+# ASAutotest is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ASAutotest is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ASAutotest.  If not, see <http://www.gnu.org/licenses/>.
+
+require "asautotest/logging"
+
+module ASAutotest
+  class CompilationRunner
+    class CompilationFailure < Exception ; end
+
+    include Logging
+
+    attr_reader :result
+
+    def initialize(shell, options)
+      @shell = shell
+      @typing = options[:typing]
+      @result = CompilationResult.new
+    end
+
+    def run
+      @stopwatch = Stopwatch.new
+      whisper_commands
+      compile
+      @stopwatch.stop
+      print_report
+    end
+
+    def whisper_commands
+      for command in @shell.compilation_commands
+        whisper "$ #{command}"
+      end
+    end
+
+    def compile
+      say("Compiling") do |status|
+        @shell.run_compilations(@result)
+
+        if @result.failed?
+          status << "failed"
+        elsif @result.did_anything?
+          files = if @result.bootstrap?
+                    "everything"
+                  else
+                    n_x(@result.n_recompiled_files, "file")
+                  end
+          status << "recompiled #{files} in #{compilation_time}"
+        else
+          status << "nothing changed"
+        end
+
+        if @result.successful?
+          for summary in @result.summaries
+            title = File.basename(summary[:request].source_file_name)
+            if summary[:successful?] and summary[:n_recompiled_files] != 0
+              files = if summary[:n_recompiled_files]
+                        n_x(summary[:n_recompiled_files], "file")
+                      else
+                        "everything"
+                      end
+              time = "#{summary[:compilation_time].to_s(1)}s"
+              growl_success title, "Compiled #{files} in #{time}."
+            end
+          end
+        else
+          summary = @result.summaries.find { |x| not x[:successful?] }
+          file_name = summary[:first_problem].file.basename
+          line_number = summary[:first_problem].line_number
+          message = summary[:first_problem].plain_message
+          growl_error "#{file_name}, line #{line_number}", message
+        end
+      end
+    end
+
+    def n_x(n, x)
+      "#{n} #{x}#{n == 1 ? "" : "s"}"
+    end
+
+    def growl_success(title, message)
+      if ASAutotest::growl_enabled
+        options = { :title => title, :icon => "as" }
+        if ASAutotest::displaying_growl_error
+          options[:identifier] = GROWL_ERROR_TOKEN
+          ASAutotest::displaying_growl_error = false
+        end
+        Growl.notify(message, options)
+      end
+    end
+
+    def growl_error(title, message)
+      if ASAutotest::growl_enabled
+        Growl.notify_error message,
+          :title => title, :sticky => true,
+          :identifier => GROWL_ERROR_TOKEN
+        ASAutotest::displaying_growl_error = true
+      end
+    end
+
+    def compilation_time
+      "~#{@stopwatch.to_s(1)} seconds"
+    end
+
+    def print_report
+      for line in @result.unrecognized_lines
+        barf line
+      end
+
+      for name, file in @result.problematic_files
+        file.print_report
+      end
+
+      puts unless @result.problematic_files.empty?
+
+      if @typing == nil and @result.any_type_warnings?
+        hint "Use --dynamic-typing to disable type declaration warnings,"
+        hint "or --static-typing to disable this hint."
+      end
+    end
+  end
+end

data/lib/asautotest/compiler-shell.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# compiler-shell.rb --- wrapper around the fcsh executable
+# Copyright (C) 2010  Go Interactive
+
+# This file is part of ASAutotest.
+
+# ASAutotest is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ASAutotest is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ASAutotest.  If not, see <http://www.gnu.org/licenses/>.
+
+module ASAutotest
+  class CompilerShell
+    PROMPT = "\n(fcsh) "
+
+    class PromptNotFound < Exception ; end
+
+    include Logging
+
+    attr_reader :compilation_requests
+
+    def initialize(options)
+      @compilation_requests = options[:compilation_requests]
+    end
+
+    def start
+      say "Starting compiler shell" do
+        @process = IO.popen("#{FCSH} 2>&1", "r+")
+        read_until_prompt
+      end
+    rescue PromptNotFound => error
+      shout "Could not find FCSH prompt:"
+      for line in error.message.lines do
+        barf line.chomp
+      end
+      if error.message.include? "command not found"
+        shout "Please make sure that fcsh is in your PATH."
+        shout "Alternatively, set the ‘FCSH’ environment variable."
+      end
+      exit -1
+    end
+
+    def run_compilations(result)
+      for request in @compilation_requests
+        run_compilation(request, result)
+      end
+    end
+
+    def compilation_commands
+      @compilation_requests.map { |x| x.compilation_command }
+    end
+
+    def run_compilation(request, result)
+      stopwatch = Stopwatch.new
+      @process.puts(request.compilation_command)
+      OutputParser.parse(read_until_prompt, request, stopwatch, result)
+      stopwatch.stop
+    end
+
+    def read_until_prompt
+      result = ""
+      until result.include? PROMPT
+        result << @process.readpartial(100) 
+      end
+      result.lines.entries[0 .. -2]
+    rescue EOFError
+      raise PromptNotFound, result
+    end
+  end
+end