speckle 0.1.2

data/lib/matchers/regexp_matcher.riml

@@ -0,0 +1,14 @@
+class RegExpMatcher
+  defm match(pattern, expr)
+    result = matchstr(expr, pattern)
+    return empty(result) == false
+  end
+
+  defm failure_message_for_match(pattern, expr)
+    return "expected “#{pattern}” to match #{expr}"
+  end
+
+  defm failure_message_for_mismatch(pattern, expr)
+    return "expected “#{pattern}” to not match #{expr}"
+  end
+end

data/lib/matchers/within_matcher.riml

@@ -0,0 +1,28 @@
+class WithinMatcher
+  defm match(expected, actual)
+    delta = expected[0]
+    num = expected[1]
+    self.result = abs(num - actual)
+    return self.result <= delta
+  end
+
+  defm failure_message_for_match(expected, actual)
+    delta = expected[0]
+    num = expected[1]
+    actual_str = printf("%f", actual)
+    delta_str = printf("%f", delta)
+    num_str = printf("%f", num)
+    result_str = printf('%f', self.result)
+    return "expected “#{actual_str}” to be within +/- “#{delta_str}” of “#{num_str}”, delta was “#{result_str}”"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    delta = expected[0]
+    num = expected[1]
+    actual_str = printf("%f", actual)
+    delta_str = printf("%f", delta)
+    num_str = printf("%f", num)
+    result_str = printf('%f', self.result)
+    return "expected “#{actual_str}” to not be within +/- “#{delta_str}” of “#{num_str}”, delta was “#{result_str}”"
+  end
+end

data/lib/reporters/base_reporter.riml

@@ -0,0 +1,126 @@
+class BaseReporter
+  def initialize()
+    self.colorize_output = true
+  end
+
+  defm set_writer(writer)
+    self.writer = writer
+  end
+
+  defm on_start(stats)
+  end
+
+  defm on_end(duration, stats)
+    self.write_epilogue(duration, stats)
+  end
+
+  defm on_context_start(context, stats)
+  end
+
+  defm on_context_end(context, stats)
+  end
+
+  defm on_spec_start(meta, stats)
+  end
+
+  defm on_spec_end(meta, stats)
+  end
+
+  defm on_spec_pass(meta, stats)
+  end
+
+  defm on_spec_failure(meta, err, stats)
+  end
+  
+  defm on_spec_error(meta, err, stats)
+  end
+
+  defm on_spec_pending(meta, stats)
+  end
+
+  defm duration_to_str(duration)
+    time = a:duration
+    if time >= 1000
+      time = time / 1000
+      return "#{time}s"
+    else
+      return "#{time}ms"
+    end
+  end
+
+  defm get_duration_msg(meta)
+    if meta.is_slow()
+      duration_str = self.duration_to_str(meta.get_duration())
+      return "(#{duration_str})"
+    else
+      return ''
+    end
+  end
+
+  defm write_epilogue_separator
+    self.writer.writeln("----------------------------------------------------")
+  end
+
+  defm write_epilogue(duration, stats)
+    self.write_epilogue_separator()
+    duration_str = self.duration_to_str(duration)
+    if stats.is_ok()
+      icon = self.get_tick_icon()
+    else
+      icon = self.get_cross_icon()
+    end
+
+    self.writer.writeln(self.to_color("#{icon} #{stats.get_count()} tests completed (#{duration_str})", stats))
+    self.writer.writeln("Passed: #{stats.get_passes()}, Failures: #{stats.get_failures()}, Errors: #{stats.get_errors()}, Assertions: #{stats.get_assertions()}")
+  end
+
+  defm set_colorize_output(colorize_output)
+    self.colorize_output = colorize_output
+  end
+
+  defm get_colorize_output()
+    return self.colorize_output
+  end
+
+  defm colorize(str, color)
+    if self.get_colorize_output()
+      return "[#{color}#{str}"
+    else
+      return str
+    end
+  end
+
+  defm to_color(str, stats)
+    if stats.is_ok()
+      return self.to_green(str)
+    else
+      return self.to_red(str)
+    end
+  end
+
+  defm to_red(str)
+    return self.colorize(str, '31m')
+  end
+
+  defm to_green(str)
+    return self.colorize(str, '32m')
+  end
+
+  defm get_tick_icon()
+    return '✓'
+  end
+
+  defm get_cross_icon()
+    return '✖'
+  end
+
+  defm get_tick()
+    return self.to_green(self.get_tick_icon())
+  end
+
+  defm get_cross()
+    return self.to_red(self.get_cross_icon())
+  end
+
+end
+

data/lib/reporters/dotmatrix_reporter.riml

@@ -0,0 +1,47 @@
+class DotMatrixReporter < BaseReporter
+
+  def initialize()
+    super()
+    self.dots = 0
+    self.line_buffer = []
+  end
+
+  defm write(msg)
+    if self.dots > 50
+      self.writer.writeln(msg)
+      self.dots = 0
+    else
+      self.writer.write(msg)
+    end
+  end
+
+  defm on_spec_pass(meta, stats)
+    self.dots += 1
+    self.write('.')
+  end
+
+  defm on_spec_failure(meta, err, stats)
+    self.dots += 1
+    self.write(self.to_red("x"))
+
+    name = meta.get_sentence()
+    context = meta.get_context()
+    add(self.line_buffer, self.to_red("#{context} ##{name}"))
+    add(self.line_buffer, self.to_red("    #{err}"))
+    add(self.line_buffer, '')
+  end
+
+  defm on_spec_error(meta, err, stats)
+    self.on_spec_failure(meta, err, stats)
+  end
+
+  defm write_epilogue_separator()
+    self.writer.writeln('')
+    for line in self.line_buffer
+      self.writer.writeln(line)
+    end
+
+    self.writer.writeln("")
+  end
+
+end

data/lib/reporters/min_reporter.riml

@@ -0,0 +1,13 @@
+class MinReporter < BaseReporter
+
+  defm on_spec_failure(meta, err, stats)
+    name = meta.get_sentence()
+    context = meta.get_context()
+    self.writer.writeln(self.to_red("#{context} ##{name} - #{err}"))
+  end
+  
+  defm on_spec_error(meta, err, stats)
+    self.on_spec_failure(meta, err, stats)
+  end
+  
+end

data/lib/reporters/reporter_factory.riml

@@ -0,0 +1,15 @@
+class ReporterFactory
+  defm get_reporter(reporter_name)
+    if a:reporter_name == 'spec'
+      return new SpecReporter()
+    elseif a:reporter_name == 'min'
+      return new MinReporter() 
+    elseif a:reporter_name == 'tap'
+      return new TAPReporter()
+    elseif a:reporter_name == 'dot'
+      return new DotMatrixReporter()
+    else
+      return new SpecReporter()
+    end
+  end
+end

data/lib/reporters/spec_reporter.riml

@@ -0,0 +1,58 @@
+class SpecReporter < BaseReporter
+
+  def initialize()
+    super()
+    self.indents = 0
+  end
+
+  defm write(msg)
+    line = "#{self.indent_to_str()}#{msg}"
+    self.writer.writeln(line)
+  end
+
+  defm on_start(stats)
+  end
+
+  defm on_context_start(context, stats)
+    self.write("#{context}")
+    self.indent(1)
+  end
+
+  defm on_context_end(context, stats)
+    self.unindent(1)
+  end
+
+  defm on_spec_pass(meta, stats)
+    duration_msg = self.get_duration_msg(meta)
+    self.write("#{self.get_tick()} #{meta.get_sentence()} #{duration_msg}")
+  end
+
+  defm on_spec_failure(meta, err, stats)
+    self.write("#{self.get_cross()} #{self.to_red(meta.get_sentence())}")
+    self.indent(2)
+    self.write(self.to_red(err))
+    self.unindent(2)
+  end
+
+  defm on_spec_error(meta, err, stats)
+    self.on_spec_failure(meta, err, stats)
+  end
+
+  defm indent_to_str()
+    return repeat("  ", self.indents)
+  end
+
+  defm indent(size)
+    self.indents += size
+  end
+
+  defm unindent(size)
+    self.indents -= size
+  end
+
+  defm write_epilogue_separator()
+    self.writer.writeln('')
+    super()
+  end
+
+end

data/lib/reporters/tap_reporter.riml

@@ -0,0 +1,38 @@
+class TAPReporter < BaseReporter
+  defm on_start(stats)
+  end
+
+  defm on_spec_start(meta, stats)
+  end
+
+  defm on_spec_end(meta, stats)
+  end
+
+  defm on_spec_pass(meta, stats)
+    name = meta.get_sentence()
+    duration_msg = self.get_duration_msg(meta)
+    preamble = self.get_preamble('ok', stats.get_count(), meta.get_context())
+    self.writer.writeln("#{preamble} ##{name} #{duration_msg}")
+  end
+
+  defm on_spec_failure(meta, err, stats)
+    name = meta.get_sentence()
+    preamble = self.get_preamble('not ok', stats.get_count(), meta.get_context())
+    self.writer.writeln("#{preamble} ##{name} - #{err}")
+  end
+
+  defm on_spec_error(meta, err, stats)
+    name = meta.get_sentence()
+    preamble = self.get_preamble('not ok', stats.get_count(), meta.get_context())
+    self.writer.writeln("#{preamble} ##{name} - #{err}")
+  end
+
+  defm on_spec_pending(meta, stats)
+  end
+
+  defm get_preamble(status, count, context)
+    ""status = status . repeat(' ', 6 - len(status))
+    msg = "#{status} #{count} - #{context}"
+    return msg
+  end
+end

data/lib/runners/runner.riml

@@ -0,0 +1,49 @@
+class Runner
+  def initialize()
+    self.specs = []
+    self.halt = false
+    self.stopped = false
+    self.bail = false
+  end
+
+  defm set_bail(bail)
+    self.bail = bail
+  end
+
+  defm get_bail()
+    return self.bail
+  end
+
+  defm add(spec)
+    add(self.specs, spec)
+  end
+
+  defm start(reporter, stats)
+    reporter.on_start(stats)
+
+    timer = new SpecTimer()
+    timer.start()
+
+    for spec in self.specs
+      if self.stopped
+        break
+      end
+
+      spec_runner = new SpecRunner(spec)
+      spec_runner.set_bail(self.get_bail())
+      spec_runner.start(reporter, stats)
+
+      if spec_runner.has_bailed()
+        self.stopped = true
+      end
+    end
+
+    timer.stop()
+    reporter.on_end(timer.get_duration(), stats)
+  end
+
+  defm stop()
+    self.stopped = true
+  end
+
+end

data/lib/runners/spec_runner.riml

@@ -0,0 +1,96 @@
+class SpecRunner
+
+  def initialize(spec)
+    self.spec = spec
+    self.stopped = false
+    self.bail = false
+    self.bailed = false
+  end
+
+  defm set_bail(bail)
+    self.bail = bail
+  end
+
+  defm has_bailed()
+    return self.bailed
+  end
+
+  defm start(reporter, stats)
+    spec = self.spec
+    did_fail = false
+    context = self.call_hook('describe')
+    reporter.on_context_start(context, stats)
+    self.call_hook('before')
+
+    for method in keys(spec)
+      if self.stopped
+        break
+      end
+
+      if method =~ '^it'
+        timer = new SpecTimer()
+        meta = new SpecMeta(context, method)
+
+        reporter.on_spec_start(meta, stats)
+        result = 0
+
+        try
+          timer.start()
+
+          self.call_hook('before_each')
+          eval("spec.#{method}()")
+          self.call_hook('after_each')
+
+          timer.stop()
+          meta.set_duration(timer.get_duration())
+
+          stats.inc_passes()
+          reporter.on_spec_pass(meta, stats)
+        catch /Unknown function.*expect/
+          did_fail = true
+          stats.inc_failures()
+          exception = 'DSLError: expect() not found, dsl.riml may not be included'
+          reporter.on_spec_failure(meta, exception, stats)
+        catch /Unknown function.*define_matcher/
+          did_fail = true
+          stats.inc_failures()
+          exception = 'DSLError: define_matcher() not found, dsl.riml may not be included'
+          reporter.on_spec_failure(meta, exception, stats)
+        catch /^AssertionError/
+          did_fail = true
+          stats.inc_failures()
+          reporter.on_spec_failure(meta, v:exception, stats)
+        catch /.*/
+          did_fail = true
+          stats.inc_errors()
+          reporter.on_spec_error(meta, v:exception, stats)
+        end
+
+        reporter.on_spec_end(meta, stats)
+        :redraw
+
+        if did_fail && self.bail
+          self.bailed = true
+          break
+        end
+      end
+    end
+
+    self.call_hook('after')
+    reporter.on_context_end(context, stats)
+  end
+
+  defm call_hook(hook)
+    spec = self.spec
+    if has_key(spec, hook)
+      return eval("spec.#{hook}()");
+    else
+      return "Undefined hook: #{hook}"
+    end
+  end
+
+  defm stop()
+    self.stopped = true
+  end
+
+end

data/lib/speckle/cli/app.rb

@@ -0,0 +1,18 @@
+module Speckle
+  module CLI
+
+    require_relative 'environment'
+    require_relative 'router'
+    
+    class App
+      def start(args)
+        env = Environment.new
+        options = env.load(args)
+
+        router = Router.new
+        router.route(options.action, options)
+      end
+    end
+
+  end
+end

data/lib/speckle/cli/controller.rb

@@ -0,0 +1,67 @@
+module Speckle
+  module CLI
+
+    require 'speckle/version'
+
+    class Controller
+
+      def initialize(options, rake_app)
+        @options = options
+        @rake_app = rake_app
+      end
+
+      def rake(task)
+        @rake_app.invoke_task(task)
+      end
+
+      def show_version
+        puts VERSION
+      end
+
+      def show_help
+        puts @options.opts
+      end
+
+      def show_error(msg = @options.error)
+        puts "Error: #{msg}"
+        puts
+
+        show_help
+      end
+
+      def show_invalid_option
+        show_error @options.error
+      end
+
+      def show_missing_args
+        show_error @options.error
+      end
+
+      def show_parser_error
+        show_error @options.error
+      end
+
+      def show_no_spec_dir
+        show_error '"spec" directory not found'
+      end
+
+      def compile
+        rake :compile_tests
+      end
+
+      def compile_and_test
+        rake :compile_and_test
+      end
+
+      def test
+        rake :test
+      end
+
+      def watch
+        puts '--- TODO ---'
+      end
+
+    end
+
+  end
+end