speckle 0.1.2

data/lib/speckle/cli/environment.rb

@@ -0,0 +1,148 @@
+module Speckle
+
+  module CLI
+
+    require 'optparse'
+    require 'ostruct'
+
+    class Environment
+      include Loader
+
+      def load(args)
+        options = OpenStruct.new
+        options.libs = nil
+        options.grep_pattern = nil
+        options.grep_invert = false
+        options.reporter = 'dot'
+        options.args = args
+        options.verbose = false
+        options.vim = 'vim'
+        options.cwd = Dir.pwd
+        options.root_dir = ROOT_DIR
+        options.speckle_build_dir = "#{ROOT_DIR}/build"
+        options.speckle_lib_dir = "#{ROOT_DIR}/lib"
+        options.skip_vimrc = false
+        options.slow_threshold = 10
+        options.colorize = true
+        options.bail = false
+
+        parser = OptionParser.new do |opts|
+          options.opts = opts
+
+          opts.banner = "Usage: speckle [options] [file(s) OR directory]"
+          opts.separator ''
+          opts.separator 'Options:'
+          opts.separator ''
+
+          opts.on_head('-c', '--compile', 'Only compile tests') do
+            options.action = :compile
+          end
+
+          opts.on_head('-t', '--test', 'Only run tests') do
+            options.action = :test
+          end
+
+          opts.on_head('-a', '--all', 'Compile and run tests (default)') do
+            options.action = :compile_and_test
+          end
+
+          opts.on('-I', '--libs <libs>', 'Specify additional riml library path(s)') do |libs|
+            options.libs = libs
+          end
+
+          opts.on('-g', '--grep <pattern>', 'Only run tests matching the pattern') do |pattern|
+            options.grep_pattern = pattern.strip
+          end
+
+          opts.on('-i', '--invert', 'Inverts --grep matches') do
+            options.grep_invert = true
+          end
+
+          opts.on('-r', '--reporter <reporter>', 'Specify the reporter to use (spec, min, dot, tap)') do |reporter|
+            options.reporter = reporter.strip
+          end
+
+          opts.on('-b', '--bail', 'Bail on first test failure') do
+            options.bail = true
+          end
+
+          opts.on('-w', '--watch', 'Watch tests for changes') do
+            options.action = :watch
+          end
+
+          opts.on('-m', '--vim <vim>', 'Vim program used to test, default(vim)') do |vim|
+            options.vim = vim.strip
+          end
+
+          opts.on('-s', '--slow-threshold <ms>', Integer, 'Threshold in milliseconds to indicate slow tests') do |ms|
+            options.slow_threshold = ms
+          end
+
+          opts.on('-k', '--skip-vimrc', 'Does not load ~/.vimrc file') do
+            options.skip_vimrc = true
+          end
+
+          opts.on('-C', '--no-colors', 'Disable color output') do
+            options.colorize = false
+          end
+
+          opts.on('-v', '--verbose', 'Display verbose output') do
+            options.verbose = true
+          end
+          
+          opts.on('-D', '--debug', 'Display debug output') do
+            options.verbose = true
+            options.debug = true
+          end
+
+          opts.on_tail('-V', '--version', 'Print Speckle version') do
+            options.action = :show_version
+          end
+
+          opts.on_tail('-h', '--help', 'Print Speckle help') do
+            options.action = :show_help
+          end
+        end
+
+        begin
+          parser.parse!(args)
+
+          if options.action.nil?
+            spec_dir = "#{options.cwd}/spec"
+            if File.directory?(spec_dir)
+              args << 'spec'
+              options.action = :compile_and_test
+            else
+              options.action = :show_no_spec_dir
+            end
+          elsif action_needs_args?(options.action) and args.empty?
+            spec_dir = "#{options.cwd}/spec"
+            if File.directory?(spec_dir)
+              args << 'spec'
+              options.action = :compile_and_test
+            end
+          end
+
+          options.inputs = args
+        rescue OptionParser::InvalidOption => e
+          options.error = e
+          options.action = :show_invalid_option
+        rescue OptionParser::MissingArgument => e
+          options.error = e
+          options.action = :show_missing_args
+        rescue OptionParser::ParseError => e
+          options.error = e
+          options.action = :show_parser_error
+        end
+
+        options
+      end
+
+      def action_needs_args?(action)
+        [:compile_and_test, :compile, :test].include? action
+      end
+    end
+
+
+  end
+end

data/lib/speckle/cli/rake_app.rb

@@ -0,0 +1,146 @@
+module Speckle
+  module CLI
+
+    require 'rake'
+
+    class RakeApp
+      def initialize(options)
+        @options = options
+      end
+
+      def inputs
+        @options.inputs
+      end
+
+      def verbose
+        @options.verbose
+      end
+
+      def debug
+        @options.debug
+      end 
+
+      def rake
+        if @rake_app
+          return @rake_app
+        end
+
+        configure_rake
+        Dir.chdir @options.root_dir
+
+        @rake_app = Rake.application
+        @rake_app.init
+        @rake_app.load_rakefile
+
+        Dir.chdir @options.cwd
+        @rake_app
+      end
+
+      def invoke_task(name)
+        rake.invoke_task("speckle:#{name.to_s}")
+      end
+
+      def rake_env(key, value)
+        unless value.nil?
+          ENV[key] = if value.is_a?(Array) then value.join(';') else value end
+          puts "rake_env: #{key} = #{ENV[key]}" if debug
+        end
+      end 
+
+      def configure_rake
+        rake_env('TEST_SOURCES', test_sources)
+        rake_env('TEST_LIBS', test_libs)
+        rake_env('BUILD_DIR', test_build_dir)
+        rake_env('TEST_COMPILED', test_compiled)
+        rake_env('TEST_VIM', @options.vim)
+        rake_env('TEST_REPORTER', @options.reporter)
+        rake_env('SLOW_THRESHOLD', @options.slow_threshold.to_s)
+        rake_env('SKIP_VIMRC', to_int(@options.skip_vimrc))
+        rake_env('COLORIZE', to_int(@options.colorize))
+        rake_env('BAIL', to_int(@options.bail))
+
+        if @options.verbose
+          rake_env('VERBOSE', 'yes')
+        end
+
+        if @options.debug
+          rake_env('DEBUG', 'yes')
+        end
+      end
+
+      def to_int(option)
+        option ? '1' : '0'
+      end
+
+      def test_build_dir
+        "#{@options.cwd}/build"
+      end
+
+      def test_compiled
+        compiled = test_sources.map do |s|
+          s.ext('vim')
+        end
+
+        compiled
+      end
+
+      def test_sources
+        sources = []
+        grep_pattern = @options.grep_pattern
+        grep_invert = @options.grep_invert
+        unless grep_pattern.nil?
+          regex = Regexp.new(grep_pattern)
+        end
+
+        inputs.each do |input|
+          if File.directory?(input)
+            if grep_pattern.nil?
+              sources << "#{input}/**/*_spec.riml"
+            else
+              sources = Dir.glob("#{input}/**/*_spec.riml")
+              sources.keep_if do |source|
+                matched = regex.match(source)
+                if grep_invert
+                  matched = !matched
+                end
+
+                matched
+              end
+            end
+          else
+            if grep_pattern.nil?
+              sources << input
+            else
+              matched = regex.match(input)
+              if grep_invert
+                matched = !matched
+              end
+              sources << input if matched
+            end
+          end
+        end
+
+        sources
+      end
+
+      def test_libs
+        input_libs = @options.libs
+        return nil if input_libs.nil?
+
+        input_libs = input_libs.split(':')
+        input_libs << 'spec'
+        if File.directory?(@options.speckle_lib_dir)
+          input_libs << @options.speckle_lib_dir
+        end
+
+        libs = []
+        input_libs.each do |lib|
+          libs << File.absolute_path(lib)
+        end
+
+        libs.join(':')
+      end
+
+    end
+  end
+end

data/lib/speckle/cli/router.rb

@@ -0,0 +1,16 @@
+module Speckle
+  module CLI
+
+    require_relative 'rake_app'
+    require_relative 'controller'
+
+    class Router
+      def route(action, options)
+        rake_app = RakeApp.new(options)
+        controller = Controller.new(options, rake_app)
+        controller.send(action)
+      end
+    end
+
+  end
+end

data/lib/speckle/loader.rb

@@ -0,0 +1,10 @@
+module Speckle
+
+  module Loader
+    ROOT_DIR = File.expand_path('../../../', __FILE__)
+    LIB_DIR = File.join(ROOT_DIR, 'lib')
+
+    $:.unshift(LIB_DIR) unless $:.include? LIB_DIR
+  end
+
+end

data/lib/speckle/version.rb

@@ -0,0 +1,3 @@
+module Speckle
+  VERSION = "0.1.2"
+end

data/lib/speckle.rb

@@ -0,0 +1,4 @@
+require "speckle/version"
+
+module Speckle
+end

data/lib/speckle.riml

@@ -0,0 +1,148 @@
+"" utils
+riml_include 'spec_timer.riml'
+riml_include 'spec_meta.riml'
+riml_include 'statistician.riml'
+
+"" matchers
+riml_include 'equality_matcher.riml'
+riml_include 'boolean_matcher.riml'
+riml_include 'existance_matcher.riml'
+riml_include 'above_matcher.riml'
+riml_include 'below_matcher.riml'
+riml_include 'between_matcher.riml'
+riml_include 'length_matcher.riml'
+riml_include 'atleast_matcher.riml'
+riml_include 'atmost_matcher.riml'
+riml_include 'within_matcher.riml'
+riml_include 'regexp_matcher.riml'
+riml_include 'dict_key_matcher.riml'
+
+"" matcher internals
+riml_include 'match_item.riml'
+riml_include 'match_tester.riml'
+riml_include 'matchers.riml'
+
+"" writers
+riml_include 'file_writer.riml'
+riml_include 'console_writer.riml'
+riml_include 'buffer_writer.riml'
+riml_include 'writer_factory.riml'
+
+"" reporters
+riml_include 'base_reporter.riml'
+riml_include 'spec_reporter.riml'
+riml_include 'min_reporter.riml'
+riml_include 'tap_reporter.riml'
+riml_include 'dotmatrix_reporter.riml'
+riml_include 'reporter_factory.riml'
+
+"" runners
+riml_include 'spec_runner.riml'
+riml_include 'runner.riml'
+
+"" dsl
+riml_include 'expectation.riml'
+
+"" main entry point
+class Speckle
+  defm configure()
+    options_map = {
+      \ 'output_file': '"speckle.log"',
+      \ 'file_mode': '0',
+      \ 'reporter_name': '"spec"',
+      \ 'slow_threshold': '10',
+      \ 'colorize': '1',
+      \ 'bail': '0'
+    \}
+
+    self.options(options_map)
+  end
+
+  defm options(options_map)
+    for [name, value] in items(options_map)
+      self.option(name, value)
+    end
+  end
+
+  defm option(variable, default)
+    if !exists("g:speckle_#{variable}")
+      execute("let g:speckle_#{variable} = #{default}")
+    end
+  end
+
+  defm get_writer()
+    factory = new WriterFactory()
+    writer = factory.get_writer('buffer')
+
+    if self.is_file_mode()
+      writer.set_output_file(self.get_output_file())
+    end
+
+    return writer
+  end
+
+  defm get_reporter(writer)
+    factory = new ReporterFactory()
+    reporter = factory.get_reporter(self.get_reporter_name())
+    reporter.set_writer(writer)
+
+    return reporter
+  end
+
+  defm is_file_mode
+    return g:speckle_file_mode
+  end
+
+  defm get_output_file
+    return g:speckle_output_file
+  end
+
+  defm get_reporter_name
+    return g:speckle_reporter_name
+  end
+
+  defm get_slow_threshold
+    return g:speckle_slow_threshold
+  end
+
+  defm get_colorize
+    return g:speckle_colorize
+  end
+
+  defm get_bail
+    return g:speckle_bail
+  end
+
+  defm run()
+    self.configure()
+
+    writer = self.get_writer()
+    stats = new Statistician()
+    reporter = self.get_reporter(writer)
+    reporter.set_colorize_output(self.get_colorize())
+    runner = new Runner()
+    runner.set_bail(self.get_bail())
+    functions = ''
+
+    :redir => functions
+    :silent function /SpecConstructor$/
+    :redir END
+
+    self.add_specs(runner, functions)
+
+    runner.start(reporter, stats)
+
+    if self.is_file_mode()
+      writer.flush()
+    end
+  end
+
+  defm add_specs(runner, lines)
+    classes = split(lines, "\n")
+    map(classes, "substitute(v:val, 'function ', '', '')")
+
+    for klass in classes
+      eval("a:runner.add(#{klass})")
+    end
+  end
+end

data/lib/utils/spec_meta.riml

@@ -0,0 +1,30 @@
+class SpecMeta
+  def initialize(context, method)
+    self.context = context
+    self.method = method
+  end
+
+  defm get_context()
+    return self.context
+  end
+
+  defm get_method()
+    return self.method
+  end
+
+  defm get_sentence()
+    return substitute(self.get_method(), '_', ' ', 'g')
+  end
+
+  defm set_duration(duration)
+    self.duration = duration
+  end
+
+  defm get_duration()
+    return self.duration
+  end
+
+  defm is_slow()
+    return self.get_duration() > g:speckle_slow_threshold
+  end
+end

data/lib/utils/spec_timer.riml

@@ -0,0 +1,30 @@
+class SpecTimer
+  def initialize()
+    self.start_time = 0
+    self.end_time = 0
+  end
+
+  defm start()
+    self.start_time = reltime()
+  end
+
+  defm stop()
+    self.end_time = reltime()
+    self.duration = self.time_to_ms(reltime(self.start_time))
+  end
+
+  defm get_duration()
+    return self.duration
+  end
+
+  defm time_to_ms(time)
+    duration_str = reltimestr(time)
+    duration_split = split(duration_str, '\.')
+    seconds = str2nr(duration_split[0])
+    microseconds = str2nr(duration_split[1])
+    milliseconds = (seconds * 1000) + (microseconds / 1000)
+
+    return milliseconds
+  end
+
+end

data/lib/utils/statistician.riml

@@ -0,0 +1,70 @@
+class Statistician
+  def initialize()
+    self.count = 0
+    self.passes = 0
+    self.failures = 0
+    self.errors = 0
+    self.pending = 0
+  end
+
+  defm inc_count()
+    self.count += 1
+  end
+
+  defm inc_passes()
+    self.inc_count()
+    self.passes += 1
+  end
+
+  defm inc_failures()
+    self.inc_count()
+    self.failures += 1
+  end
+
+  defm inc_pending()
+    self.inc_count()
+    self.pending += 1
+  end
+
+  defm inc_errors()
+    self.inc_count()
+    self.errors += 1
+  end
+
+  defm inc_assertions()
+    env = g:speckle_env
+    env.assertions += 1
+  end
+
+  defm get_count()
+    return self.count
+  end
+
+  defm get_passes()
+    return self.passes
+  end
+
+  defm get_failures()
+    return self.failures
+  end
+
+  defm get_pending()
+    return self.pending
+  end
+
+  defm get_errors()
+    return self.errors
+  end
+
+  defm get_assertions()
+    return g:speckle_env.assertions
+  end
+
+  defm is_ok()
+    return self.get_errors() == 0 && self.get_failures() == 0
+  end
+
+  defm is_not_ok()
+    return !self.is_ok()
+  end
+end

data/lib/writers/buffer_writer.riml

@@ -0,0 +1,37 @@
+class BufferWriter
+  def initialize()
+    self.writer = new FileWriter()
+  end
+
+  defm set_output_file(output_file)
+    self.writer.set_output_file(output_file)
+  end
+
+  defm strip_colors(line)
+    return substitute(line, '\e\[[0-9;]\+[mK]', '', 'g')
+  end
+
+  defm write(line)
+    self.writer.write(line)
+
+    line = self.strip_colors(line)
+    append(line('$'), line)
+    :normal gJ
+  end
+
+  defm writeln(line)
+    self.writer.writeln(line)
+
+    line = self.strip_colors(line)
+    append(line('$'), line)
+    :normal G
+  end
+
+  defm flush()
+    self.writer.flush()
+  end
+
+  defm flush_line()
+    self.writer.flush_line()
+  end
+end

data/lib/writers/console_writer.riml

@@ -0,0 +1,28 @@
+class ConsoleWriter
+  def initialize()
+    self.writer = new FileWriter()
+  end
+
+  defm set_output_file(output_file)
+    self.writer.set_output_file(output_file)
+  end
+
+  defm write(line)
+    self.writer.write(line)
+    echon line
+  end
+
+  defm writeln(line)
+    self.writer.writeln(line)
+    echomsg line
+  end
+
+  defm flush()
+    self.writer.flush()
+  end
+
+  defm flush_line()
+    self.writer.flush_line()
+  end
+end
+

data/lib/writers/file_writer.riml

@@ -0,0 +1,31 @@
+class FileWriter
+  def initialize()
+    self.lines = []
+    self.current_line = ''
+  end
+
+  defm set_output_file(output_file)
+    self.output_file = output_file
+  end
+
+  defm write(line)
+    self.current_line = "#{self.current_line}#{line}"
+  end
+
+  defm writeln(line)
+    self.flush_line()
+    add(self.lines, line)
+  end
+
+  defm flush_line()
+    unless self.current_line == ''
+      add(self.lines, self.current_line)
+      self.current_line = ''
+    end
+  end
+
+  defm flush()
+    self.flush_line()
+    writefile(self.lines, self.output_file)
+  end
+end