speckle 0.1.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWZhOGE2OTdjMTZmYzIzYmRhMWUxZDZjM2FjMzlhNDAzZjFhZTg2Zg==
+  data.tar.gz: !binary |-
+    ODcwYzhhOGU5OTliY2UzNjQwMzNhN2JlMzkwMzM1MWJiMTViN2VjNA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YTEwYzIwN2I0MDY4M2U2N2QyOTIwZDExODc5NzlhZTcxZWEzNzFhMDRjMGUw
+    NTZhNWExODI2YzJiMjljNDIyYTQzMGY2YTZjZmEwMmNiYzY1NTk1ZmQ2Y2Jk
+    ZmM3MWJhMjYyMWQ1YmRlYTUxYmNkZmUxNTBiN2I5ZGRmMjU5ZmI=
+  data.tar.gz: !binary |-
+    YmQ5NjJkOWQzMTUzNjQ4MTZmOTc3OTliMDIzN2FlODM1OTdhYzA2MzgzMTZm
+    NTViZjIxMzViYTNjMmI1ZjRmNTNhMTM5MDdhNzg3NTMxZjcyODE4ZGNmOGEx
+    OWNjNzQ3NDMyZmYzNDUxNzkyNTViY2IxNDQ0YTBiYWNiNTYzMjg=

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+*.swp
+*.swo
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+build
+scratch.vim
+lib/scratch.riml

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Darshan Sawardekar <darshan@sawardekar.org>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Speckle
+
+Behaviour driven framework for testing vim scripts written in Riml.
+
+## Installation
+
+    $ gem install speckle
+
+## Usage
+
+    $ speckle [options] [file(s) OR directory]
+    -a, --all                        Compile and run tests (default)
+    -t, --test                       Only run tests
+    -c, --compile                    Only compile tests
+
+Options:
+
+    -I, --libs <libs>                Specify additional riml library path(s)
+    -g, --grep <pattern>             Only run tests matching the pattern
+    -i, --invert                     Inverts --grep matches
+    -r, --reporter <reporter>        Specify the reporter to use (spec, min, dot, tap)
+    -b, --bail                       Bail on first test failure
+    -w, --watch                      Watch tests for changes
+    -m, --vim <vim>                  Vim program used to test, default(vim)
+    -s, --slow-threshold <ms>        Threshold in milliseconds to indicate slow tests
+    -k, --skip-vimrc                 Does not load ~/.vimrc file
+    -C, --no-colors                  Disable color output
+    -v, --verbose                    Display verbose output
+    -D, --debug                      Display debug output
+    -V, --version                    Print Speckle version
+    -h, --help                       Print Speckle help
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,230 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Default task :compile_and_test'
+task :default => :test
+
+# :spec task from rspec
+desc "Run speckle's rspec tests"
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'Run rspec and speckle tests'
+task :test => [:spec, 'speckle:compile_and_test']
+
+desc 'Clean temporary files'
+task :clean => ['speckle:clean']
+
+desc 'Clobber temporary files'
+task :clobber => ['speckle:clobber']
+
+# speckle tasks
+namespace :speckle do
+
+  require 'rake/clean'
+  require 'tempfile'
+
+  # build paths
+  BUILD_DIR      = ENV['BUILD_DIR'] || 'build'
+
+  # misc config
+  VERBOSE = ENV.has_key?('VERBOSE')
+  DEBUG = ENV.has_key?('DEBUG')
+  SLOW_THRESHOLD = ENV['SLOW_THRESHOLD'] || 10
+  SKIP_VIMRC = ENV['SKIP_VIMRC'] == '1' || false
+  COLORIZE = ENV['COLORIZE'] || 1
+  BAIL = ENV['BAIL'] || 0
+
+  # speckle sources
+  SPECKLE_DIR = File.dirname(__FILE__)
+  SPECKLE_BUILD_DIR = "#{SPECKLE_DIR}/build"
+  LIB_DIR        = "#{SPECKLE_DIR}/lib"
+  SPECKLE_LIBS = Dir.glob("#{LIB_DIR}/**/*").select { |f| File.directory? f }.push(LIB_DIR).join(':')
+  SPECKLE_MAIN = 'speckle.riml'
+  SPECKLE_SOURCE = "#{LIB_DIR}/#{SPECKLE_MAIN}"
+  SPECKLE_TEMP_OUTPUT = "#{SPECKLE_MAIN}".ext('vim')
+  SPECKLE_OUTPUT = "#{SPECKLE_BUILD_DIR}/#{SPECKLE_TEMP_OUTPUT}"
+  SPECKLE_VIM = ENV['SPECKLE_VIM'] || SPECKLE_MAIN.ext('vim')
+
+  SPECKLE_DSL = 'dsl.riml'
+  SPECKLE_DSL_SOURCE = "#{LIB_DIR}/#{SPECKLE_DSL}"
+  SPECKLE_DSL_TEMP_OUTPUT = "#{SPECKLE_DSL}".ext('vim')
+  SPECKLE_DSL_OUTPUT = "#{SPECKLE_BUILD_DIR}/#{SPECKLE_DSL_TEMP_OUTPUT}"
+
+  # clean
+  CLEAN.include("#{BUILD_DIR}/**/*.vim")
+  CLEAN.include("#{BUILD_DIR}/**/*.log")
+  CLOBBER.include(BUILD_DIR)
+
+  # test sources
+  TEST_LIBS = ENV['TEST_LIBS'] || "spec:#{LIB_DIR}"
+  TEST_VIM = ENV['TEST_VIM'] || 'vim'
+  TEST_REPORTER = ENV['TEST_REPORTER'] || 'spec'
+  TEST_LOG = "#{BUILD_DIR}/speckle.log"
+  TEST_SOURCES  = FileList.new do |fl|
+    sources = ENV['TEST_SOURCES']
+    if sources
+      sources = sources.split(';')
+      sources.each do |s|
+        fl.include(s)
+      end
+    else
+      fl.include('spec/**/*_spec.riml')
+    end
+  end
+
+  TEST_COMPILED = FileList.new do |fl|
+    fl.exclude("#{SPECKLE_OUTPUT}")
+    compiled = ENV['TEST_COMPILED']
+    if compiled
+      compiled = compiled.split(';')
+      compiled.each do |c|
+        fl.include("#{BUILD_DIR}/#{c}")
+      end
+    else
+      fl.include("#{BUILD_DIR}/**/*.vim")
+    end
+  end
+
+  desc 'All tasks'
+  task :all => [:clean, :compile, :compile_tests, :test]
+
+  desc 'Build files and folders'
+  task :build do
+    verbose DEBUG do
+      mkdir_p BUILD_DIR
+      mkdir_p SPECKLE_BUILD_DIR
+    end
+  end
+
+  desc "Compile #{SPECKLE_MAIN}"
+  task :compile => [:build] do
+    puts "Compiling: #{SPECKLE_MAIN}"
+    verbose VERBOSE do
+      sh "riml -c #{SPECKLE_SOURCE} -I #{SPECKLE_LIBS}"
+    end
+    verbose DEBUG do
+      mv "#{SPECKLE_TEMP_OUTPUT}", "#{SPECKLE_OUTPUT}"
+    end
+
+    verbose VERBOSE do
+      sh "riml -c #{SPECKLE_DSL_SOURCE}"
+    end
+
+    verbose DEBUG do
+      mv "#{SPECKLE_DSL_TEMP_OUTPUT}", "#{SPECKLE_DSL_OUTPUT}"
+    end
+  end
+
+  task :scratch => [:build] do
+    sh "riml -c lib/scratch.riml -I #{SPECKLE_LIBS}"
+  end
+
+  desc "Compile specs"
+  task :compile_tests => [:build] do
+    TEST_SOURCES.each do |t|
+      verbose VERBOSE do
+        puts "Compiling: #{t} "
+        sh "riml -c #{t} -I #{TEST_LIBS}"
+      end
+
+      spec_dir = "#{BUILD_DIR}/#{File.dirname(t)}"
+      verbose DEBUG do
+        mkdir_p "#{spec_dir}"
+        mv "#{File.basename(t).ext('vim')}", "#{spec_dir}"
+      end
+    end
+
+    puts
+  end
+
+  desc "Compile and test specs"
+  task :compile_and_test => [:compile_tests] do
+    verbose VERBOSE do
+      Rake::Task['speckle:test'].invoke
+    end
+  end
+
+  desc "Launch test runner"
+  task :test do
+    unless File.exists?(SPECKLE_OUTPUT)
+      Rake::Task['speckle:compile'].invoke
+    end
+
+    puts 'Running tests: '
+    puts
+
+    launch_vim
+  end
+
+  desc "Watch files for changes and run tests"
+  task :watch do 
+    puts '--- TODO ---'
+  end
+
+  def get_vim_options
+    cmd = ''
+    if SKIP_VIMRC
+      cmd += "-u NONE -i NONE"
+    end
+
+    cmd
+  end
+
+  def launch_vim
+    begin
+      verbose DEBUG do
+        launch_file = get_launch_cmd_file()
+        sh "#{TEST_VIM} #{get_vim_options()} -S #{launch_file.path}"
+        sh "cat #{TEST_LOG}"
+        launch_file.unlink
+      end
+    rescue RuntimeError => error
+      puts error
+      if DEBUG
+        puts error.backtrace
+      end
+    end
+  end
+
+  # utils
+  def get_launch_cmd_source
+    launch_cmd = <<CMD
+      source #{SPECKLE_OUTPUT}
+CMD
+
+    TEST_COMPILED.each do |t|
+      launch_cmd += <<CMD
+      source #{t}
+CMD
+    end
+
+    launch_cmd += <<CMD
+      let g:speckle_file_mode = 1
+      let g:speckle_output_file = '#{TEST_LOG}'
+      let g:speckle_reporter_name = '#{TEST_REPORTER}'
+      let g:speckle_slow_threshold = #{SLOW_THRESHOLD}
+      let g:speckle_colorize = #{COLORIZE}
+      let g:speckle_bail = #{BAIL}
+      let speckle = g:SpeckleConstructor()
+      :autocmd VimEnter * :call speckle.run()
+      :q!
+CMD
+
+    if DEBUG
+      puts launch_cmd
+    end
+    launch_cmd.gsub!(/([^\n])\n([^\n])/, '\1 | \2')
+  end
+
+  def get_launch_cmd_file
+    cmd = get_launch_cmd_source
+    file = Tempfile.new('speckle')
+    file.write(cmd)
+    file.close
+
+    file
+  end
+
+end
+

data/bin/speckle

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/speckle/loader', __FILE__)
+ 
+module Speckle
+
+  require 'speckle/cli/app'
+
+  app = Speckle::CLI::App.new
+  app.start(ARGV)
+
+end

data/lib/dsl.riml

@@ -0,0 +1,29 @@
+if !exists("g:speckle_env")
+  g:speckle_env = {}
+  g:speckle_env.matchers = g:MatchersConstructor()
+  g:speckle_env.assertions = 0
+end
+
+
+def expect(actual)
+  env = g:speckle_env
+  env.actual = actual
+  matchers = env.matchers
+
+  expectation = g:ExpectationConstructor(a:actual)
+  expectation.load(matchers)
+
+  return expectation
+end
+
+def get_matchers()
+  env = g:speckle_env
+  matchers = env.matchers
+
+  return matchers
+end
+
+def define_matcher(ok_name, not_ok_name, matcher)
+  matchers = get_matchers()
+  matchers.define_pair(ok_name, not_ok_name, matcher)
+end

data/lib/expectation.riml

@@ -0,0 +1,34 @@
+class Expectation
+
+  def initialize(actual)
+    self.actual = actual
+  end
+
+  defm load(matchers)
+    matchers.load_defaults()
+
+    match_tester = new MatchTester()
+    match_items = matchers.get_match_items()
+
+    for match_item in match_items
+      func_name = "g:Expectation_#{match_item.name}"
+      matcher_func = <<EOS
+function! #{func_name}(...) dict  
+  if a:0 == 0
+    let expected = 'null'
+  else
+    let expected = a:1
+  endif
+
+  let matcher_name = '#{match_item.name}'
+  let match_tester = g:MatchTesterConstructor()
+  call match_tester.test_from_env(matcher_name, expected)"
+endfunction"   
+EOS
+      :exe matcher_func
+
+      self[match_item.name] = function(func_name)
+    end
+  end
+
+end

data/lib/matchers/above_matcher.riml

@@ -0,0 +1,13 @@
+class AboveMatcher
+  defm match(expected, actual)
+    return actual > expected
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected “#{actual}” to be above “#{expected}”"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected “#{actual}” to not be above “#{expected}”"
+  end
+end

data/lib/matchers/atleast_matcher.riml

@@ -0,0 +1,13 @@
+class AtleastMatcher
+  defm match(expected, actual)
+    return actual >= expected
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected “#{actual}” to be greater than or equal to “#{expected}”"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected “#{actual}” to not be greater than or equal to “#{expected}”"
+  end
+end

data/lib/matchers/atmost_matcher.riml

@@ -0,0 +1,13 @@
+class AtmostMatcher
+  defm match(expected, actual)
+    return actual <= expected
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected “#{actual}” to be less than or equal to “#{expected}”"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected “#{actual}” to not be less than or equal to “#{expected}”"
+  end
+end

data/lib/matchers/below_matcher.riml

@@ -0,0 +1,13 @@
+class BelowMatcher
+  defm match(expected, actual)
+    return actual < expected
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected “#{actual}” to be below “#{expected}”"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected “#{actual}” to not be below “#{expected}”"
+  end
+end

data/lib/matchers/between_matcher.riml

@@ -0,0 +1,19 @@
+class BetweenMatcher
+  defm match(bounds, actual)
+    min = bounds[0]
+    max = bounds[1]
+    return actual >= min && actual <= max
+  end
+
+  defm failure_message_for_match(bounds, actual)
+    min = bounds[0]
+    max = bounds[1]
+    return "expected “#{actual}” to be between “#{min} .. #{max}”"
+  end
+
+  defm failure_message_for_mismatch(bounds, actual)
+    min = bounds[0]
+    max = bounds[1]
+    return "expected “#{actual}” to not be between “#{min} .. #{max}”"
+  end
+end

data/lib/matchers/boolean_matcher.riml

@@ -0,0 +1,13 @@
+class BooleanMatcher
+  defm match(expected, actual)
+    return actual == true
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected “#{actual}” to be true"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected “#{actual}” to be false"
+  end
+end

data/lib/matchers/dict_key_matcher.riml

@@ -0,0 +1,14 @@
+class DictKeyMatcher
+  defm match(expected, actual)
+    return has_key(actual, expected)
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected dict to have key #{actual}"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected dict to not have key #{actual}"
+  end
+end
+

data/lib/matchers/equality_matcher.riml

@@ -0,0 +1,13 @@
+class EqualityMatcher
+  defm match(expected, actual)
+    return actual == expected
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected “#{actual}” to equal “#{expected}”"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected “#{actual}” to not equal “#{expected}”"
+  end
+end

data/lib/matchers/existance_matcher.riml

@@ -0,0 +1,13 @@
+class ExistanceMatcher
+  defm match(expected, actual)
+    return exists(actual)
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected “#{actual}” to exist"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected “#{actual}” to not exist"
+  end
+end

data/lib/matchers/length_matcher.riml

@@ -0,0 +1,14 @@
+class LengthMatcher
+  defm match(expected, actual)
+    self.result = len(actual)
+    return self.result == expected
+  end
+
+  defm failure_message_for_match(expected, actual)
+    return "expected length of “#{actual}” to be “#{expected}”, but was #{self.result}"
+  end
+
+  defm failure_message_for_mismatch(expected, actual)
+    return "expected length of “#{actual}” to not be “#{expected}”, but was #{self.result}"
+  end
+end

data/lib/matchers/match_item.riml

@@ -0,0 +1,8 @@
+class MatchItem
+  def initialize(name, matcher, negate)
+    self.name = name
+    self.matcher = matcher
+    self.negate = negate
+  end
+end
+

data/lib/matchers/match_tester.riml

@@ -0,0 +1,33 @@
+class MatchTester
+
+  defm test_from_env(matcher_name, expected)
+    env = g:speckle_env
+    matchers = env.matchers
+    match_item = matchers.get_match_item(matcher_name)
+    negate = match_item.negate
+    matcher = match_item.matcher
+    actual = env.actual
+
+    tester = new MatchTester()
+    tester.test(matcher, negate, a:expected, actual)
+  end
+
+  defm test(matcher, negate, expected, actual)
+    result = matcher.match(expected, actual)
+    g:speckle_env.assertions += 1
+    if negate
+      if result
+        message = matcher.failure_message_for_mismatch(expected, actual)
+        message = "AssertionError: #{message}"
+        throw message
+      end
+    else
+      unless result
+        message = matcher.failure_message_for_match(expected, actual)
+        message = "AssertionError: #{message}"
+        throw message
+      end
+    end
+  end
+
+end

data/lib/matchers/matchers.riml

@@ -0,0 +1,72 @@
+class Matchers
+  def initialize()
+    self.matchers = {}
+  end
+
+  defm load_defaults()
+    matcher = new EqualityMatcher()
+    self.define_pair('to_equal', 'to_not_equal', matcher)
+    self.define_pair('to_eq', 'to_neq', matcher)
+
+    matcher = new BooleanMatcher()
+    self.define_pair('to_be_true', 'to_be_false', matcher)
+    self.define_pair('to_be_ok', 'to_not_be_ok', matcher)
+
+    matcher = new ExistanceMatcher()
+    self.define_pair('to_exist', 'to_not_exist', matcher)
+
+    matcher = new AboveMatcher()
+    self.define_pair('to_be_above', 'to_not_be_above', matcher)
+    self.define_pair('to_be_gt', 'to_not_be_gt', matcher)
+
+    matcher = new BelowMatcher()
+    self.define_pair('to_be_below', 'to_not_be_below', matcher)
+    self.define_pair('to_be_lt', 'to_not_be_lt', matcher)
+
+    matcher = new BetweenMatcher()
+    self.define_pair('to_be_between', 'to_not_be_between', matcher)
+
+    matcher = new LengthMatcher()
+    self.define_pair('to_have_length', 'to_not_have_length', matcher)
+
+    matcher = new AtleastMatcher()
+    self.define_pair('to_be_at_least', 'to_not_be_at_least', matcher)
+    self.define_pair('to_be_gte', 'to_not_be_gte', matcher)
+
+    matcher = new AtmostMatcher()
+    self.define_pair('to_be_at_most', 'to_not_be_at_most', matcher)
+    self.define_pair('to_be_lte', 'to_not_be_lte', matcher)
+
+    matcher = new WithinMatcher()
+    self.define_pair('to_be_within', 'to_not_be_within', matcher)
+
+    matcher = new RegExpMatcher()
+    self.define_pair('to_match', 'to_not_match', matcher)
+    self.define_pair('to_have_string', 'to_not_have_string', matcher)
+
+    matcher = new DictKeyMatcher()
+    self.define_pair('to_have_key', 'to_not_have_key', matcher)
+  end
+
+  defm get_match_items()
+    return values(self.matchers)
+  end
+
+  defm get_match_item(name)
+    return self.matchers[name]
+  end
+
+  defm define_single(name, matcher)
+    item = new MatchItem(name, matcher)
+    self.matchers[name] = item
+  end
+
+  defm define_pair(ok_name, not_ok_name, matcher)
+    ok_item = new MatchItem(ok_name, matcher, false)
+    not_ok_item = new MatchItem(not_ok_name, matcher, true)
+
+    self.matchers[ok_name] = ok_item
+    self.matchers[not_ok_name] = not_ok_item
+  end
+
+end