torkify 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d3a7e8564007cfc37702bcc37cbba490154c0fcd
+  data.tar.gz: e757b6552cb0cdb63434839d22c3ab9395759f5e
+SHA512:
+  metadata.gz: 3059816687b7ae835341dd7100ed6bcba3c1f7fd4c6465f8010a3179839c7e552d1897b8bebf3eb85f3f21775d5f562d4c0eea4f72aae56cb257524eda060b46
+  data.tar.gz: 9f13edf48f04710e380723f5b9c43ec4f596bdb2b8d730dca33163b6eae93ec09cf3d70cdb74001c078b37779802add673bc8e33d8feb76faa1e0acc2589f119

data/.gitignore

@@ -16,4 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 *.tags
-log/
+/log/

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - 2.0.0
+  - rbx-19mode

data/README.md

@@ -1,8 +1,14 @@
 # Torkify
 
-Torkify integrates with [tork][1], which is a solution for automating tests as you change your source files.
+[![Build Status](https://travis-ci.org/joonty/torkify.png?branch=master)](https://travis-ci.org/joonty/torkify)
 
-Torkify hooks in to tork's remote events, and allows you to write ruby code that's called when particular events fire. This makes it easy for you to write code that triggers cool stuff when your tests pass or fail.
+Torkify aims to be a one-stop shop for testing ruby applications, and handling callbacks after test execution for things like notifications.
+
+Torkify integrates with [tork][1], which is a solution for automating test execution, as you change your source files.
+
+Torkify hooks in to tork's remote events, and allows you to add gems and build callbacks that run when tests fail or pass. This makes it easy for you to write code that triggers cool stuff when your tests explode (your imagination is the limit).
+
+Plus, [tork][1] is a fantastic tool that makes it very easy to run tests immediately and automatically in a pre-loaded environment.
 
 ## An example
 

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/torkify/conductor.rb

@@ -1,33 +1,44 @@
-require_relative 'events/event'
-require_relative 'event_parser'
+require_relative 'event/basic_event'
+require_relative 'event/parser'
+require_relative 'event/dispatcher'
+require_relative 'log/parser'
 
 module Torkify
 
   # Connect the socket reader and observers, and dispatch events.
   class Conductor
-    attr_accessor :observers
-
     # Create with a set of observers.
     def initialize(observers)
-      @observers = observers
+      @dispatcher = Event::Dispatcher.new observers
+    end
+
+    def observers
+      @dispatcher.observers
+    end
+
+    def observers=(*args)
+      @dispatcher.send :observers=, *args
     end
 
     # Start reading from the reader, which is an IO-like object.
     #
     # Parse each line and dispatch it as an event object to all observers.
     def start(reader)
-      dispatch Event.new 'startup'
-      parser = EventParser.new
-        reader.each_line do |line|
-          event = parser.parse line
-          dispatch event
-        end
-      dispatch Event.new 'shutdown'
+      dispatch Event::BasicEvent.new 'startup'
+      parser = Event::Parser.new
+
+      while line = reader.gets
+        Torkify.logger.debug { "Read line: #{line}" }
+        events = parser.parse line
+        dispatch(*events)
+      end
+
+      dispatch Event::BasicEvent.new 'shutdown'
     end
 
     protected
-    def dispatch(event)
-      @observers.dispatch(event)
+    def dispatch(*events)
+      events.each { |event| @dispatcher.dispatch(event) }
     end
   end
 end

data/lib/torkify/{events/event.rb → event/basic_event.rb}

@@ -1,6 +1,6 @@
-require_relative 'event_message'
+require_relative 'message'
 
-module Torkify
+module Torkify::Event
 
   # Event used for all events that have no associated data.
   #
@@ -10,8 +10,8 @@ module Torkify
   #  - shutdown
   #  - startup
   #  - anything else...
-  class Event < Struct.new(:type)
-    include EventMessage
+  class BasicEvent < Struct.new(:type)
+    include Message
 
     def to_s
       type

data/lib/torkify/event/dispatcher.rb

@@ -0,0 +1,91 @@
+require_relative 'ran_all_test_files_event'
+
+module Torkify::Event
+  class Dispatcher
+    attr_accessor :observers
+
+    def initialize(observers)
+      @observers = observers
+    end
+
+    def dispatch(event)
+      observers.each do |o|
+        ObserverEventDispatcher.new(o, event).dispatch
+      end
+      act_if_required event
+    end
+
+  protected
+
+    def act_if_required(event)
+      case event.type
+      when :run_all_test_files
+        @ran_all_tests_event = RanAllTestFilesEvent.new(:ran_all_test_files, [], [])
+      when :pass
+        if @ran_all_tests_event
+          @ran_all_tests_event.passed << event
+        end
+      when :fail
+        if @ran_all_tests_event
+          @ran_all_tests_event.failed << event
+        end
+      when :idle
+        if @ran_all_tests_event
+          @ran_all_tests_event.stop!
+          dispatch @ran_all_tests_event
+          @ran_all_tests_event = nil
+        end
+      end
+
+    end
+
+    class ObserverEventDispatcher
+      def initialize(observer, event)
+        @observer = observer
+        @event = event
+      end
+
+      def dispatch
+        dispatch_and_rescue
+      rescue => e
+        Torkify.logger.error { "Caught exception from observer #{observer.inspect} during ##{event.message}: #{e}\n\t#{e.backtrace.join("\n\t")}" }
+      end
+
+    protected
+      attr_reader :observer, :event
+
+      def dispatch_and_rescue
+        send_and_trap arguments_for_event_message
+      rescue NameError
+        send_args = arguments_by_arity 1
+        send_and_trap send_args
+      end
+
+      def send_and_trap(args)
+        observer.send event.message, *args
+      rescue NoMethodError => e
+        if e.message.include? event.message.to_s
+          Torkify.logger.debug { "No method #{event.message} defined on #{observer.inspect}" }
+        else
+          raise
+        end
+      end
+
+      def arguments_for_event_message
+        arguments_by_arity observer.method(event.message).arity
+      end
+
+      def arguments_by_arity(method_arity)
+        case method_arity
+        when 0
+          []
+        when -1, 1
+          [event]
+        else
+          [event].fill(nil, 1, method_arity - 1)
+        end
+      end
+    end
+
+  end
+end

data/lib/torkify/event/echo_event.rb

@@ -0,0 +1,23 @@
+require_relative 'message'
+
+module Torkify::Event
+
+  # Event used for all events that have no associated data.
+  #
+  # Types:
+  #
+  #  - absorb
+  #  - shutdown
+  #  - startup
+  #  - anything else...
+  class EchoEvent < Struct.new(:type, :arguments)
+    include Message
+
+    def to_s
+      type
+    end
+
+    alias :args :arguments
+  end
+end
+

data/lib/torkify/{events/event_message.rb → event/message.rb}

@@ -1,5 +1,5 @@
-module Torkify
-  module EventMessage
+module Torkify::Event
+  module Message
     def message
       "on_#{type}".to_sym
     end

data/lib/torkify/event/parser.rb

@@ -0,0 +1,70 @@
+require 'json'
+require_relative 'basic_event'
+require_relative 'test_event'
+require_relative 'pass_or_fail_event'
+require_relative 'status_change_event'
+require_relative 'echo_event'
+
+module Torkify::Event
+
+  # Parse raw strings passed by tork into event objects.
+  class Parser
+
+    # Parse a raw string and return an object based on the event type.
+    #
+    # E.g. a raw string like:
+    # > '["test","spec/reader_spec.rb",[],"spec/reader_spec.rb.log",3]'
+    def parse(line)
+      raw = JSON.load line
+      event_from_data raw
+    end
+
+  protected
+    # Create an event object from the array of data.
+    def event_from_data(data)
+      case data.first
+      when 'test'
+        [ TestEvent.new(*data) ]
+      when 'pass', 'fail'
+        [ PassOrFailEvent.new(*data) ]
+      when 'pass_now_fail', 'fail_now_pass'
+        [ StatusChangeEvent.new(data[0], data[1], event_from_data(data[2]).first) ]
+      when 'echo'
+        parse_echo_event data
+      else
+        [ BasicEvent.new(data.first) ]
+      end
+    end
+
+    def parse_echo_event(data)
+      events = [ EchoEvent.new(*data) ]
+      event = event_from_echo(*data[1])
+      events << event if event
+      events
+    end
+
+    def event_from_echo(action, *action_args)
+      if echo_commands_requiring_args.include? action
+        return if action_args.empty? || action_args.first.empty?
+      end
+      if known_echo_commands.include? action
+        BasicEvent.new action
+      end
+    end
+
+    def known_echo_commands
+      [ 'run_all_test_files',
+        'run_test_files',
+        'run_test_file',
+        'stop_running_test_files',
+        'stop_running_test_files',
+        'rerun_passed_test_files',
+        'rerun_failed_test_files' ]
+    end
+
+    def echo_commands_requiring_args
+      [ 'run_test_files',
+        'run_test_file' ]
+    end
+  end
+end

data/lib/torkify/{events → event}/pass_or_fail_event.rb

@@ -1,6 +1,6 @@
-require_relative 'event_message'
+require_relative 'message'
 
-module Torkify
+module Torkify::Event
 
   # Event used for test passes or failures.
   #
@@ -9,7 +9,7 @@ module Torkify
   #  - pass
   #  - fail
   class PassOrFailEvent < Struct.new(:type, :file, :lines, :log_file, :worker, :exit_code, :exit_info)
-    include EventMessage
+    include Message
 
     # Get the PID from the exit info.
     def pid
@@ -17,9 +17,21 @@ module Torkify
       matched.first.to_i if matched
     end
 
+    def errors
+      @errors ||= parse_errors_from_log
+    end
+
     def to_s
       s = "#{type.upcase} #{file}"
       s += lines.any? ? " (lines #{lines.join(', ')})" : ''
     end
+
+  protected
+    def parse_errors_from_log
+      log = File.open log_file
+      parser = Torkify::Log::Parser.new log
+      parser.parse
+      parser.errors
+    end
   end
 end

data/lib/torkify/event/ran_all_test_files_event.rb

@@ -0,0 +1,30 @@
+require_relative 'message'
+
+module Torkify::Event
+
+  # Event used when all tests have finished running.
+  #
+  # The time method gives the approximate time in seconds that the tests
+  # took to run.
+  class RanAllTestFilesEvent < Struct.new(:type, :passed, :failed)
+    include Message
+
+    def initialize(type, passed = [], failed = [])
+      @created = Time.now.to_f
+      super
+    end
+
+    def stop!
+      if @time.nil?
+        @time = Time.now.to_f - @created
+      end
+      self
+    end
+
+    def time
+      stop!
+      @time
+    end
+  end
+end
+

data/lib/torkify/{events → event}/status_change_event.rb

@@ -1,6 +1,6 @@
-require_relative 'event_message'
+require_relative 'message'
 
-module Torkify
+module Torkify::Event
 
   # Event used for changes in test status.
   #
@@ -11,7 +11,7 @@ module Torkify
   #
   # Includes the actual fail/pass event as a separate object.
   class StatusChangeEvent < Struct.new(:type, :file, :event)
-    include EventMessage
+    include Message
 
     def to_s
       "#{type.upcase.gsub('_',' ')} #{file}"

data/lib/torkify/{events → event}/test_event.rb

@@ -1,11 +1,12 @@
-require_relative 'event_message'
+require_relative 'message'
+
+module Torkify::Event
 
-module Torkify
   # Event used when a test is started.
   #
   # This is currently only one type: 'test'
   class TestEvent < Struct.new(:type, :file, :lines, :log_file, :worker)
-    include EventMessage
+    include Message
 
     def to_s
       s = "#{type.upcase} #{file}"

data/lib/torkify/listener.rb

@@ -1,5 +1,5 @@
+require 'set'
 require_relative 'conductor'
-require_relative 'observer_set'
 require_relative 'reader'
 require_relative 'exceptions'
 
@@ -12,7 +12,7 @@ module Torkify
     def initialize(command = 'tork-remote tork-engine', dir = Dir.pwd)
       @command = command
       @dir = dir
-      @conductor = Conductor.new ObserverSet.new
+      @conductor = Conductor.new Set.new
     end
 
     # Add an observer object to be notified of tork events.
@@ -72,20 +72,29 @@ module Torkify
     # Start the torkify listener and tork itself.
     #
     # It forks the current process and runs torkify as the child. It then
-    # runs tork as the main process, allowing for stdin to be passed to tork.
+    # runs the tork CLI as the main process, allowing for stdin to be passed to tork.
     #
     # Calls #start_loop().
-    #
-    # The command to run tork can be passed as an argument, and the
-    # TORK_CONFIGS environment variable can be passed as the second argument.
-    def start_with_tork(command = 'tork', tork_env = 'default')
+    def start_with_tork
+      load_tork
+
       if fork
         start_loop
       else
         # Run tork in main process to keep stdin
         Torkify.logger.info { "Starting tork" }
-        exec({'TORK_CONFIGS' => tork_env}, command)
+
+        $0 = File.basename Dir.pwd
+        Tork::CLIApp.new.loop
       end
     end
+
+    def load_tork
+      require 'tork/config'
+      require 'tork/cliapp'
+    rescue LoadError
+      Torkify.logger.fatal { "Could not load tork: try running `gem install tork`" }
+      raise
+    end
   end
 end

data/lib/torkify/log/line_matcher.rb

@@ -0,0 +1,33 @@
+
+module Torkify::Log
+  class LineMatcher
+    PATTERNS = {
+      'tork_load_line'        => /^Loaded suite tork[^\s]+\s(.+)/,
+      'error_description'     => /^[\s#]*([^:]+):([0-9]+):in/,
+      'file_extraction'       => /\[([^:]+):([0-9]+)\]/m,
+      'tork_error_line'       => /^.+tork\/master\.rb:[0-9]+:in [^:]+:\s/,
+      'test_error_or_failure' => /^(\s+[0-9]+\)|Failure(?!s)|Error)/,
+      'test_summary'          => /^([0-9]+\s[a-z]+,)+/,
+      'finished_line'         => /^Finished/
+    }
+
+    def initialize(line)
+      self.line = line
+    end
+
+    PATTERNS.each do |name, reg|
+      define_method("#{name}?") { !(line =~ PATTERNS[name]).nil? }
+      define_method("#{name}")  { PATTERNS[name].match(line) }
+    end
+
+    def end_of_errors?
+      test_summary? || finished_line?
+    end
+
+    alias :ruby_error :error_description
+    alias :ruby_error? :error_description?
+
+  protected
+    attr_accessor :line
+  end
+end

data/lib/torkify/log/log_reader.rb

@@ -0,0 +1,32 @@
+require_relative 'line_matcher'
+
+module Torkify::Log
+  class LogReader
+    attr_reader :line
+
+    def initialize(stream)
+      @stream = stream
+      @line = stream.readline
+    end
+
+    def forward
+      self.line = stream.readline
+      self
+    end
+
+
+    def matcher
+      @matcher ||= LineMatcher.new(line)
+    end
+
+  protected
+    attr_reader :stream
+    attr_writer :line
+
+    def line=(line)
+      @line = line
+      @matcher = nil
+    end
+  end
+
+end

data/lib/torkify/log/parser.rb

@@ -0,0 +1,96 @@
+require_relative 'test_error'
+require_relative 'log_reader'
+
+module Torkify::Log
+  module Error; end
+  class ParserError < StandardError; end
+
+  class Parser
+    attr_reader :errors
+
+    def initialize(stream)
+      @reader = LogReader.new stream
+      self.errors = []
+    end
+
+    def parse
+      parse_log
+      self
+    rescue EOFError
+      # noop
+      self
+    rescue Exception => e
+      # Tag all exceptions with Torkify::Error
+      e.extend Error
+      raise e
+    end
+
+  protected
+    attr_writer :errors
+    attr_reader :reader
+
+    def parse_log
+      loop do
+        if reader.matcher.ruby_error?
+          parse_ruby_error
+          if errors.empty?
+            raise ParserError, "Failed to read error from log file"
+          end
+          break
+        elsif tork_line_match = reader.matcher.tork_load_line
+          @file_fallback = tork_line_match[1].strip + ".rb"
+        elsif reader.matcher.test_error_or_failure?
+          parse_errors_or_failures
+        end
+        reader.forward
+      end
+    end
+
+    def parse_ruby_error
+      line = reader.line
+      if tork_match = reader.matcher.tork_error_line
+        line.slice! tork_match[0]
+      end
+      matches = line.split(':')
+      if matches.length >= 3
+        self.errors << TestError.new(matches.shift.strip,
+                                     matches.shift.strip,
+                                     matches.join(':').strip.gsub("'", "`"),
+                                     'E')
+      end
+    end
+
+    def apply_file_from_matches(error, matches)
+      if matches
+        matches = matches.to_a
+        matches.shift
+        error.filename = matches.shift.strip
+        error.lnum = matches.shift.strip
+      end
+    end
+
+    def parse_errors_or_failures
+      until reader.matcher.end_of_errors?
+        if reader.matcher.test_error_or_failure?
+          error = TestError.new(@file_fallback, '0', '', 'E')
+          self.errors << error
+        end
+
+        matches = reader.matcher.error_description
+        error.text << reader.line.gsub("'", "`")
+
+        apply_file_from_matches error, matches
+        reader.forward
+      end
+
+      errors.each do |err|
+        if err.lnum == '0'
+          matches = err.text.match(LineMatcher::PATTERNS['file_extraction'])
+          apply_file_from_matches err, matches
+        end
+      end
+    end
+
+  end
+
+end

data/lib/torkify/log/test_error.rb

@@ -0,0 +1,7 @@
+module Torkify::Log
+  class TestError < Struct.new(:filename, :lnum, :text, :type)
+    def clean_text
+      text.strip
+    end
+  end
+end

data/lib/torkify/reader.rb

@@ -12,10 +12,10 @@ module Torkify
     # has been written to the command's STDERR stream.
     def initialize(command = 'tork-remote tork-engine', run_in_dir = Dir.pwd)
       Dir.chdir(run_in_dir) do
-        _, @io, stderr, _ = Open3.popen3 command
+        self.in, self.out, self.err, self.thread = Open3.popen3 command
 
-        if @io.eof?
-          raise TorkError, stderr.read.strip
+        if out.eof?
+          raise TorkError, err.read.strip
         end
       end
     end
@@ -24,12 +24,14 @@ module Torkify
     #
     # This allows this class to be used in an IO like way.
     def method_missing(method, *args, &blk)
-      @io.send method, *args, &blk
+      out.send method, *args, &blk
     end
 
     # Allow respond_to? to work with method_missing.
     def respond_to?(method, include_private = false)
-      @io.respond_to? method, include_private
+      out.respond_to? method, include_private
     end
+  protected
+    attr_accessor :in, :out, :err, :thread
   end
 end

data/lib/torkify/version.rb

@@ -1,3 +1,3 @@
 module Torkify
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end