fcshd 0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@fcshd --create

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    fcshd (0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fcshd!

data/bin/fcshc

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+
+begin
+  require "fcshd"
+rescue LoadError
+  require "pathname"
+  $: << File.expand_path("../../lib", Pathname.new(__FILE__).realpath)
+  require "fcshd"
+end
+
+require "optparse"
+require "socket"
+
+def die(message)
+  puts "#{File.basename($0)}: #{message}"
+  exit 1
+end
+
+$source_directories = []
+$library_filenames = []
+$extra_arguments = []
+
+OptionParser.new do |parser|
+  parser.banner = "Usage: fcshc MAIN [SRCDIR|LIB]... -o OUTPUT"
+
+  parser.on("--halo", "Use the Halo theme") do
+    if ENV["FLEX_HOME"]
+      $extra_arguments << "-theme=" +
+        File.join(ENV["FLEX_HOME"], *%w(frameworks themes Halo halo.swc))
+    else
+      die "must set $FLEX_HOME to use --halo option"
+    end
+  end
+
+  parser.on("-o", "--output FILENAME", "Write SWF to FILENAME") do |value|
+    $output_filename = File.expand_path(value)
+  end
+
+  parser.on("-3", "Use -compatibility-version=3") do |value|
+    $extra_arguments << "-compatibility-version=3"
+  end
+
+  parser.on("-X EXTRA-ARGUMENT", "Pass EXTRA-ARGUMENT to mxmlc") do |value|
+    $extra_arguments << value
+  end
+
+  parser.on("-v", "--verbose", "Print mxmlc command line") do
+    $verbose = true
+  end
+end.parse!
+
+for name in ARGV
+  if not File.exists? name
+    die "no such file or directory: #{name}"
+  elsif File.directory? name
+    $source_directories << File.expand_path(name)
+  elsif %w(.as .mxml).include? File.extname(name)
+    die "multiple source files not allowed" if $source_filename
+    $source_filename = File.expand_path(name)
+  elsif %w(.swc).include? File.extname(name)
+    $library_filenames << File.expand_path(name)
+  else
+    die "don't know what to do with file: #{name}"
+  end
+end
+
+if $source_filename == nil
+  die "missing source file to compile"
+end
+
+if $output_filename == nil
+  $source_filename.sub(/\.(as|mxml)$/, ".swf").tap do |filename|
+    local_filename = File.basename(filename)
+    $output_filename = File.expand_path(local_filename)
+  end
+end
+
+$fcshd_arguments = ["mxmlc #$source_filename -output=#$output_filename"]
+
+for directory in $source_directories
+  $fcshd_arguments << "-compiler.source-path+=#{directory}"
+end
+
+for filename in $library_filenames
+  $fcshd_arguments << "-compiler.library-path+=#{filename}"
+end
+
+$fcshd_arguments.concat($extra_arguments)
+
+begin
+  host, port = "localhost", 34345
+  socket = TCPSocket.new(host, port)
+rescue Errno::ECONNREFUSED
+  die "Could not connect to fcshd at #{host}:#{port}."
+end
+
+basedir = File.join(File.expand_path("."), "")
+
+fcshd_command = $fcshd_arguments.join(" ")
+warn fcshd_command.gsub(basedir, "") if $verbose
+socket.puts fcshd_command
+
+compiler_output = ""
+socket.each_line do |line|
+  case line
+  when /^fcshd: /
+    warn line.chomp
+  else
+    compiler_output << line
+  end
+end
+
+output = FCSHD::CompilerOutput[compiler_output, basedir]
+output.write! FCSHD::CompilerOutputWriter.new(STDOUT, basedir)
+
+exit 1 if not output.succeeded?

data/bin/fcshd

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+begin
+  require "fcshd"
+rescue LoadError
+  require "pathname"
+  $: << File.expand_path("../../lib", Pathname.new(__FILE__).realpath)
+  require "fcshd"
+end
+
+logger = FCSHD::Logger.new(STDERR)
+compiler = FCSHD::Compiler.new(logger)
+compiler.start! 
+
+Thread.abort_on_exception = true
+
+FCSHD_PORT = 34345
+
+begin
+  logger.log "Listening to port #{FCSHD_PORT}."
+  FCSHD::Server.new(FCSHD_PORT, compiler, logger).run!
+rescue Interrupt
+  logger.log "Exiting."
+end

data/fcshd.gemspec

@@ -0,0 +1,19 @@
+require "./lib/fcshd/version"
+ 
+Gem::Specification.new do |gem|
+  gem.name = "fcshd"
+  gem.summary = "Usable CLI for the Adobe Flex compiler shell (fcsh)"
+  gem.description = <<'^D'
+By using a client-server architecture, we are able to make the Adobe Flex
+compiler run fast while still being usable in command-line environments.
+In practice, you start the `fcshd' server, and are then able to use the
+client program `fcshc' as a faster and more usable replacement for `mxmlc'.
+^D
+  gem.version = FCSHD::VERSION
+  gem.author = "Daniel Brockman"
+  gem.email = "daniel@gointeractive.se"
+  gem.date = Time.now.utc.strftime("%Y-%m-%d")
+  gem.homepage = "http://github.com/dbrock/fcshd"
+  gem.files = `git ls-files`.lines.map(&:chomp)
+  gem.executables = %w"fcshd fcshc"
+end

data/lib/fcshd.rb

@@ -0,0 +1,8 @@
+require "fcshd/compiler-output-writer"
+require "fcshd/compiler-output"
+require "fcshd/compiler"
+require "fcshd/logger"
+require "fcshd/problem"
+require "fcshd/server"
+require "fcshd/source-location"
+require "fcshd/version"

data/lib/fcshd/compiler-output-writer.rb

@@ -0,0 +1,19 @@
+module FCSHD
+  class CompilerOutputWriter
+    def initialize(output, basedir)
+      @output = output
+      @basedir = basedir
+    end
+
+    def write_uninterpreted_line! line
+      @output.puts line
+    end
+
+    def write_problem! problem
+      location = problem.source_location.with_basedir(@basedir)
+      for line in problem.formatted_message_lines do
+        @output.puts "#{location}: #{line}"
+      end
+    end
+  end
+end

data/lib/fcshd/compiler-output.rb

@@ -0,0 +1,91 @@
+module FCSHD
+  class CompilerOutput
+    def self.[] text, basedir
+      new.tap do |result|
+        Parser.new(text.lines.entries, basedir, result).parse!
+      end
+    end
+
+    attr_accessor :n_compiled_files
+
+    def initialize
+      @events = []
+    end
+
+    def << event
+      @events << event
+    end
+
+    def write! writer
+      for event in @events
+        case event
+        when String
+          writer.write_uninterpreted_line! event
+        when Problem
+          writer.write_problem! event
+        end
+      end
+    end
+
+    def nothing_to_do?
+      n_compiled_files == 0
+    end
+
+    def succeeded!
+      @succeeded = true
+    end
+
+    def succeeded?
+      @succeeded
+    end
+
+    class Parser < Struct.new(:lines, :basedir, :result)
+      def parse!
+        parse_line! until lines.empty?
+      end
+
+      def parse_line!
+        take_line! do |line|
+          case line
+          when /^(Recompile|Reason): /
+          when /^Loading configuration file /
+          when /^(.+\.swf) \((\d+) bytes\)$/
+            result.succeeded!
+          when "Nothing has changed since the last compile. Skip..."
+            result.n_compiled_files = 0
+          when /^Files changed: (\d+) Files affected: (\d+)$/
+            result.n_compiled_files = $1.to_i + $2.to_i
+          when /^(\/.+?)(?:\((\d+)\))?: (?:col: (\d+) )?(.+)$/
+            location = SourceLocation[$1, $2.to_i, $3.to_i, basedir]
+            result << Problem[location, $4]
+            skip_indented_lines!
+          when /^Required RSLs:$/
+            skip_indented_lines!
+          when /^fcshd: /
+            result << line
+          else
+            result << "mxmlc: #{line}"
+          end
+        end
+      end
+
+      def take_line!
+        yield skip_line!
+      end
+
+      def skip_line!
+        current_line
+      ensure
+        lines.shift
+      end
+
+      def current_line
+        lines[0].chomp
+      end
+
+      def skip_indented_lines!
+        skip_line! until lines.empty? or current_line =~ /^\S/
+      end
+    end
+  end
+end

data/lib/fcshd/compiler.rb

@@ -0,0 +1,145 @@
+require "find"
+
+module FCSHD
+  class Compiler
+    FLEX_HOME = ENV["FLEX_HOME"]
+
+    def self.flex_path(*components)
+      File.join(FLEX_HOME, *components)
+    end
+
+    def self.standard_fcsh_executable
+      FLEX_HOME ? flex_path("bin", "fcsh") : "fcsh"
+    end
+
+    def self.standard_source_directory_root
+      flex_path("frameworks", "projects")
+    end
+
+    def self.barename(filename)
+      File.basename(filename).sub(/\..*/, "")
+    end
+
+    def self.find_standard_component(name)
+      if FLEX_HOME
+        Find.find(standard_source_directory_root) do |filename|
+          if barename(filename) == name
+            break File.dirname(filename).
+              sub(%r{.+/src/}, "").gsub("/", ".")
+          end
+        end
+      end
+    end
+
+    FCSH_EXECUTABLE = ENV["FCSH"] || standard_fcsh_executable
+
+    def initialize(logger)
+      @logger = logger
+      @output_buffer = ""
+    end
+
+    def start!
+      start_fcsh_process!
+      parse_fcsh_boilerplate!
+      @logger.log "Started Flex #@flex_version compiler shell."
+    rescue PromptNotFound => error
+      @logger.error "Could not find fcsh prompt:"
+      @logger.error @logger.format_command(FCSH_EXECUTABLE, error.message)
+      @logger.log "Please set $FLEX_HOME or $FCSH." if
+        error.message.include? "command not found"
+      @logger.exit
+    end
+
+    def compile! command, frontend
+      @command, @frontend = command, frontend
+
+      if have_command_id?
+        recompile!
+      else
+        compile_new!
+      end
+    end
+
+  private
+
+    def start_fcsh_process!
+      stop_fcsh_process!
+      @fcsh_process = IO.popen("#{FCSH_EXECUTABLE} 2>&1", "r+")
+      read_fcsh_output!
+    end
+
+    def stop_fcsh_process!
+      @fcsh_process.close if @fcsh_process
+      @fcsh_process = nil
+      @command_ids = {}
+    end
+
+    def parse_fcsh_boilerplate!
+      case @output
+      when /Version (\S+)/
+        @flex_version = $1
+      else
+        @flex_version = "(unknown version)"
+      end
+    end
+
+    def compile_new!
+      @frontend.puts "fcshd: Compiling from scratch..."
+      @frontend.flush
+      send_fcsh_command! @command
+      parse_compilation_output!
+    ensure
+      if not have_command_id?
+        @logger.error "Could not determine compilation ID:"
+        @logger.error @logger.format_command("(fcsh) #@command", @output)
+      end
+    end
+
+    def recompile!
+      send_fcsh_command! "compile #{command_id}"
+      parse_compilation_output!
+    end
+
+    def command_id
+      @command_ids[@command]
+    end
+
+    def command_id= id
+      @command_ids[@command] = id
+    end
+
+    def have_command_id?
+      @command_ids.include? @command
+    end
+
+    def parse_compilation_output!
+      for line in @output.lines
+        case line
+        when /^fcsh: Assigned (\d+) as the compile target id$/
+          self.command_id = $1
+        else
+          @frontend.puts(line)
+          @logger.log_raw(line) if line =~ /^fcsh: /
+        end
+      end
+    end
+
+    def send_fcsh_command! command
+      @logger.log_raw("> #{command}")
+      @fcsh_process.puts(command)
+      read_fcsh_output!
+    end
+
+    FCSH_PROMPT = "\n(fcsh) "
+    class PromptNotFound < Exception ; end
+
+    def read_fcsh_output!
+      @output_buffer << @fcsh_process.readpartial(256) until
+        @output_buffer.include? FCSH_PROMPT
+      @output, @output_buffer =
+        @output_buffer.split(FCSH_PROMPT, 2)
+    rescue EOFError
+      raise PromptNotFound, @output_buffer
+    end
+  end
+end

data/lib/fcshd/logger.rb

@@ -0,0 +1,41 @@
+module FCSHD
+  class Logger
+    def initialize(output)
+      @stderr = output
+    end
+
+    def log_raw(message)
+      @stderr.puts message
+    end
+
+    def log(message)
+      for line in message.lines
+        log_raw "#{program_name}: #{line.chomp}"
+      end
+    end
+
+    def program_name
+      File.basename($0)
+    end
+
+    def error(message)
+      for line in message.lines
+        log "error: #{line.chomp}"
+      end
+    end
+
+    def die(message)
+      error message ; exit
+    end
+
+    def exit(code=1)
+      Kernel.exit code
+    end
+
+    def format_command(command, output)
+      ["$ #{command}", *output.lines].
+        map { |line| "    #{line.chomp}" }.
+        join("\n")
+    end
+  end
+end

data/lib/fcshd/problem.rb

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+
+module FCSHD
+  class Problem < Struct.new(:source_location, :raw_mxmlc_message)
+    ERROR_PREFIX = /^\s*Error: /
+
+    def mxmlc_message
+      raw_mxmlc_message.sub(ERROR_PREFIX, "")
+    end
+
+    def error?
+      raw_mxmlc_message =~ ERROR_PREFIX
+    end
+
+    def quote(string)
+      "‘#{string}’"
+    end
+
+    def message
+      case raw = raw_message
+      when String then raw
+      when Array then raw * "\n"
+      else fail
+      end
+    end
+
+    def raw_message
+      case mxmlc_message
+
+      when "Unable to resolve MXML language version. Please specify the language namespace on the root document tag."
+      then
+        <<"^D"
+missing MXML version
+→ xmlns:fx="library://ns.adobe.com/mxml/2009"
+→ xmlns="library://ns.adobe.com/flex/spark"
+→ xmlns:mx="library://ns.adobe.com/flex/mx" (Flex 3 compatibility)
+→ xmlns="http://www.adobe.com/2006/mxml" (Flex 3)
+^D
+
+      when /^Incorrect number of arguments.  Expected (\d+)\.$/
+      then "expected #$1 arguments"
+
+      when /^(?:Access of possibly undefined property|Call to a possibly undefined method) (.+) through a reference with static type (.+)\.$/
+      then "#{quote $1} undeclared in #$2"
+
+      when /^Attempted access of inaccessible property (.+) through a reference with static type (.+)\.$/
+      then "#{quote $1} inaccessible in #$2"
+
+      when
+        /^Could not resolve <(.+)> to a component implementation.$/,
+        /^Call to a possibly undefined method (.+).$/,
+        /^Access of undefined property (.+).$/,
+        /^The definition of base class (.+) was not found.$/,
+        /^Type was not found or was not a compile-time constant: (.+)\.$/
+      then
+        ["#{quote $1} undeclared"].tap do |result|
+          Compiler.find_standard_component($1).tap do |package|
+            result << "→ import #{package}.*" if package
+          end
+        end
+
+      when /^Definition (.+) could not be found\.$/
+      then "#{quote $1} not found"
+
+      when
+        /^Implicit coercion of a value of type (.+) to an unrelated type (.+)\.$/,
+
+        /^Implicit coercion of a value with static type (.+) to a possibly unrelated type (.+)\./
+
+      then
+        actual, expected = $1, $2
+        expected_base = expected.sub(/.+:/, "")
+        actual_base = actual.sub(/.+:/, "")
+        if actual_base != expected_base
+          "expected #{expected_base} (got #{actual_base})"
+        else
+          "expected #{expected} (got #{actual})"
+        end
+
+      when "Method marked override must override another method."
+      then "overriding nonexistent method"
+
+      when "Overriding a function that is not marked for override."
+      then ["unmarked override", "→ add override keyword"]
+
+      when "Incompatible override."
+      then "incompatible override"
+
+      when /^Ambiguous reference to (.+)\.$/
+      then "#{quote $1} is ambiguous"
+
+      when /^A conflict exists with definition (.+) in namespace internal\.$/
+      then "#{quote $1} is conflicting"
+
+      when
+        /^Warning: parameter '(.+)' has no type declaration\.$/,
+        /^Warning: return value for function '(.+)' has no type declaration\.$/
+      then
+        case $1
+        when "anonymous" then "anonymous function"
+        else quote $1
+        end + " missing type declaration"
+
+      when /^A file found in a source-path must have the same package structure '(.*)', as the definition's package, '(.*)'\.$/
+      then "package should be #{quote $1}"
+
+      when /^Comparison between a value with static type (.+) and a possibly unrelated type (.+)\.$/
+      then "comparing #$1 to #$2"
+
+      when "Illegal assignment to a variable specified as constant."
+      then "modifying constant"
+
+      when "Function does not have a body."
+      then "missing function body"
+
+      when "Return type of a setter definition must be unspecified or void."
+      then "setter must return void"
+
+      when "Function does not return a value."
+      then "missing return statement"
+
+      when "Syntax error: expecting identifier before rightparen."
+      then "#{quote ")"} unexpected"
+
+      when
+        /^The (.+) attribute can only be used inside a package\./,
+        /^The (.+) attribute may be used only on class property definitions\./
+      then
+        "#{quote $1} unexpected"
+
+      else
+        mxmlc_message
+      end
+    end
+
+    def formatted_message_lines
+      lines = message.lines.entries
+      if error?
+        first = <<"^D"
+error: #{lines[0].chomp}
+^D
+        rest = lines[1..-1].map do |line|
+          <<"^D"
+       #{line.chomp}
+^D
+        end
+        [first] + rest
+      else
+        lines
+      end
+    end
+  end
+end

data/lib/fcshd/server.rb

@@ -0,0 +1,34 @@
+require "socket"
+
+module FCSHD
+  class Server
+    def initialize(port, compiler, logger)
+      @server = TCPServer.new("localhost", port)
+      @compiler = compiler
+      @logger = logger
+    end
+
+    def run!
+      loop do
+        Thread.start(@server.accept) do |socket|
+          Client.new(socket, @compiler).run!
+        end
+      end
+    end
+
+    class Client < Struct.new(:socket, :compiler)
+      def run!
+        case command = socket.gets
+        when /^mxmlc /
+          compiler.compile! command, socket
+        else
+          sockets.puts "fcshd: Unrecognized command: #{command}"
+        end
+      rescue Errno::EPIPE
+        logger.log "Broken pipe."
+      ensure
+        socket.close
+      end
+    end
+  end
+end

data/lib/fcshd/source-location.rb

@@ -0,0 +1,27 @@
+module FCSHD
+  class SourceLocation < Struct.new \
+    :filename, :line_number, :column_number, :basedir
+
+    def to_s
+      relative_filename.tap do |result|
+        result << ":#{line_number}" if line_number
+      end
+    end
+
+    def relative_filename
+      if basedir
+        filename.sub(/^#{Regexp.quote(basedir)}/, "")
+      else
+        filename
+      end
+    end
+
+    def with_basedir(new_basedir)
+      dup.tap { |result| result.basedir = new_basedir }
+    end
+
+    def without_column_number
+      dup.tap { |result| result.column_number = nil }
+    end
+  end
+end

data/lib/fcshd/version.rb

@@ -0,0 +1,5 @@
+unless defined? FCSHD::VERSION
+  module FCSHD
+    VERSION = "0.1"
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: fcshd
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Daniel Brockman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-31 00:00:00 Z
+dependencies: []
+
+description: |
+  By using a client-server architecture, we are able to make the Adobe Flex
+  compiler run fast while still being usable in command-line environments.
+  In practice, you start the `fcshd' server, and are then able to use the
+  client program `fcshc' as a faster and more usable replacement for `mxmlc'.
+
+email: daniel@gointeractive.se
+executables: 
+- fcshd
+- fcshc
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- bin/fcshc
+- bin/fcshd
+- fcshd.gemspec
+- lib/fcshd.rb
+- lib/fcshd/compiler-output-writer.rb
+- lib/fcshd/compiler-output.rb
+- lib/fcshd/compiler.rb
+- lib/fcshd/logger.rb
+- lib/fcshd/problem.rb
+- lib/fcshd/server.rb
+- lib/fcshd/source-location.rb
+- lib/fcshd/version.rb
+homepage: http://github.com/dbrock/fcshd
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Usable CLI for the Adobe Flex compiler shell (fcsh)
+test_files: []
+