minispec 0.0.1

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+root = File.expand_path('..', __FILE__)
+Rake::TestTask.new do |t|
+  t.ruby_opts << '-r "%s/test/setup" -I "%s/lib"' % [root, root]
+  t.pattern = 'test/**/test__*.rb'
+  t.verbose = true
+end
+task default: :test

data/bin/minispec

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'minispec'
+Minispec.run

data/lib/minispec.rb

@@ -0,0 +1,175 @@
+require 'stringio'
+require 'pp'
+require 'coderay'
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+
+# private module.
+# for internal use only.
+module MiniSpec
+  extend self
+
+  # files loading pattern. relative to `Dir.pwd`
+  DEFAULT_PATTERN = "{spec,test}/**/{*_spec.rb,*_test.rb,test_*.rb}".freeze
+
+  SPEC_WRAPPERS = %w[
+    describe
+    context
+    section
+  ].freeze
+
+  TEST_WRAPPERS = %w[
+    test
+    testing
+    example
+    should
+    it
+  ].freeze
+
+  IMPORTABLES = %w[
+    tests
+    helpers
+    before
+    after
+    around
+    vars
+    continue_on_failures
+  ].map(&:to_sym).freeze
+
+  AFFIRMATIONS = %w[
+    is   is?
+    are  are?
+    was  was?
+    does does?
+    did  did?
+    have have?
+    has  has?
+    assert
+    affirm
+    assume
+    assure
+    expect
+    verify
+    check
+    prove
+    would
+    will
+  ].freeze
+
+  NEGATIONS = %w[
+    refute
+    negate
+    fail_if
+    not_expected
+    assert_not
+  ].freeze
+
+
+  def source_location_cache file
+    return unless File.file?(file) && File.readable?(file)
+    (@source_location_cache ||= {})[file] ||= File.readlines(file)
+  end
+end
+
+MiniSpec::SPEC_WRAPPERS.each do |meth|
+  # top-level methods that allows to define specs using Minispec's DSL
+  #
+  # @example
+  #
+  #   describe SomeSpec do
+  #     # some tests
+  #   end
+  #
+  #   describe SomeAnotherSpec do
+  #     # some another tests
+  #   end
+  #
+  define_method meth do |subject, &proc|
+    spec_name = subject.to_s.freeze
+    spec = Class.new do
+      include Minispec
+      define_method(:subject) { subject }
+      # set spec name before executing the proc
+      # otherwise wrong spec name will be reported
+      define_singleton_method(:spec_name)     { spec_name }
+      define_singleton_method(:spec_fullname) { spec_name }
+      define_singleton_method(:spec_proc)     { proc      }
+      define_singleton_method(:indent)        { 0         }
+    end
+    spec.class_exec(&proc)
+  end
+end
+
+require 'minispec/utils'
+require 'minispec/mocks'
+require 'minispec/proxy'
+require 'minispec/reporter'
+require 'minispec/api'
+
+# public module.
+# to be used for inclusions by end users.
+module Minispec
+  # extending Minispec module with MiniSpec::ClassAPI
+  # to be able to define global shared resources
+  #
+  # @example
+  #  module Minispec
+  #    around do
+  #      # all specs includes Minispec module
+  #      # so all tests will run inside this block
+  #    end
+  #
+  #    def some_utility_method
+  #      # all specs will have this method
+  #    end
+  #
+  #    # etc
+  #  end
+  #
+  extend MiniSpec::ClassAPI
+
+  class << self
+    attr_accessor :specs, :tests, :assertions
+
+    def included base
+      base.extend(MiniSpec::ClassAPI)
+      base.send(:include, MiniSpec::InstanceAPI)
+
+      # inserting global shared resources defined inside Minispec module
+      MiniSpec::IMPORTABLES.each do |importable|
+        base.send('import_%s' % importable, self)
+      end
+
+      specs.push(base) unless specs.include?(base)
+    end
+
+    def run opts = {}
+      files = opts[:files] || opts[:file]
+      files ||= File.basename($0) == 'minispec' && $*.any? && $*
+      files ||= Dir[File.join(Dir.pwd, opts[:pattern] || MiniSpec::DEFAULT_PATTERN)]
+      files = [files] unless files.is_a?(Array)
+
+      $:.include?(Dir.pwd) || $:.unshift(Dir.pwd)
+      lib = File.join(Dir.pwd, 'lib')
+      !$:.include?(lib) && File.directory?(lib) && $:.unshift(lib)
+
+      pwd = /\A#{Regexp.escape(Dir.pwd)}\//.freeze
+      files.each do |f|
+        path = File.expand_path(File.dirname(f), Dir.pwd).sub(pwd, '')
+        path = File.join(Dir.pwd, path.split('/').first)
+        $:.include?(path) || $:.unshift(path)
+        require(f)
+      end
+      reporter = opts[:reporter] || MiniSpec::Reporter.new
+      specs.each {|s| s.run(reporter)}
+      reporter.summary
+      exit(1) if reporter.failures?
+    end
+  end
+end
+
+Minispec.specs      = []
+Minispec.tests      = 0
+Minispec.assertions = 0
+
+require 'minispec/helpers'

data/lib/minispec/api.rb

@@ -0,0 +1,2 @@
+require 'minispec/api/class'
+require 'minispec/api/instance'

data/lib/minispec/api/class.rb

@@ -0,0 +1,195 @@
+module MiniSpec
+  module ClassAPI
+
+    # @example
+    #    module CPUTests
+    #      include Minispec
+    #
+    #      # CPU related tests
+    #    end
+    #
+    #    module RAMTests
+    #      include Minispec
+    #
+    #      # RAM related tests
+    #    end
+    #
+    #    describe :MacBook do
+    #      include CPUTests
+    #      include RAMTests
+    #
+    #      # will run CPU and RAM tests + any tests defined here
+    #    end
+    #
+    def included base
+      base.send(:include, Minispec)
+      MiniSpec::IMPORTABLES.each do |importable|
+        base.send('import_%s' % importable, self)
+      end
+    end
+
+    # @example
+    #    module CPUTests
+    #      include Minispec
+    #
+    #      # CPU related tests
+    #    end
+    #
+    #    module RAMTests
+    #      include Minispec
+    #
+    #      # RAM related tests
+    #    end
+    #
+    #    describe :MacBook do
+    #      include CPUTests
+    #      include RAMTests
+    #
+    #      # we do not need :around hook nor included variables
+    #      reset :around, :vars
+    #
+    #      # will run CPU and RAM tests + any tests defined here
+    #    end
+    #
+    def reset *importables
+      importables.each do |importable|
+        MiniSpec::IMPORTABLES.include?(inheritable.to_sym) || raise(ArgumentError,
+          'Do not know how to reset %s. Use one of %s' % [inheritable.inspect, MiniSpec::IMPORTABLES*', '])
+        self.send('reset_%s' % inheritable)
+      end
+    end
+
+    # by default MiniSpec will stop evaluating a test on first failed assertion.
+    # `continue_on_failures true` will make MiniSpec continue evaluating regardless failures.
+    #
+    # @example set globally
+    #
+    #   MiniSpec.setup do
+    #     continue_on_failures true
+    #   end
+    #
+    # @example set per spec
+    #
+    #   describe SomeTest do
+    #     continue_on_failures true
+    #
+    #     # ...
+    #   end
+    #
+    def continue_on_failures status
+      @continue_on_failures = status
+    end
+    def continue_on_failures?
+      @continue_on_failures
+    end
+
+    def import_continue_on_failures base
+      import_instance_variable(:continue_on_failures, base)
+    end
+    alias import_continue_on_failures_from import_continue_on_failures
+
+    def reset_continue_on_failures
+      remove_instance_variable(:@continue_on_failures)
+    end
+
+    def hooks_filter callbacks, filter
+      return callbacks unless filter
+      callbacks.map do |(matchers,proc)|
+        MiniSpec::Utils.any_match?(filter, matchers) ? [filter, matchers, proc] : nil
+      end.compact
+    end
+
+    def import_instance_variable var, base
+      return unless base.instance_variable_defined?('@%s' % var)
+      val = base.instance_variable_get('@%s' % var)
+      val.is_a?(Proc) ? send(var, &val) : send(var, val)
+    end
+
+    MiniSpec::SPEC_WRAPPERS.each do |meth|
+      # used to define nested specs
+      #
+      # inner specs will not share any of its stuff with parent spec
+      # nor will affect parent's state in any way,
+      # i.e. wont override any variables, setups nor tests etc.
+      # that's it, a inner spec is a isolated closure.
+      #
+      # @note  if these methods used inside a class that included Minispec,
+      #   the created spec will use parent spec as superclass.
+      #
+      # @example
+      #   describe :Math do
+      #
+      #     # Math tests
+      #
+      #     describe :PI do
+      #       # PI tests
+      #     end
+      #   end
+      #
+      define_method meth do |subject, opts = {}, &proc|
+        spec_name     = subject.to_s.freeze
+        spec_fullname = [self.spec_fullname, spec_name].join(' / ').freeze
+        indent = self.indent + 2
+        args   = self.is_a?(Class) && self.include?(Minispec) ? [self] : []
+        spec   = Class.new *args do
+          include Minispec
+          define_method(:subject) { subject }
+          # set spec name before executing the proc
+          # otherwise wrong spec name will be reported in failures
+          define_singleton_method(:spec_name)     { spec_name     }
+          define_singleton_method(:spec_fullname) { spec_fullname }
+          define_singleton_method(:spec_proc)     { proc          }
+          define_singleton_method(:indent)        { indent        }
+        end
+        MiniSpec::IMPORTABLES.reject {|i| i == :tests}.each do |importable|
+          spec.send('import_%s' % importable, self)
+        end
+        spec.class_exec(&proc)
+      end
+    end
+
+    def spec_name; self.name    end
+    alias :spec_fullname :spec_name
+    def spec_proc; nil          end
+    def indent;    0            end
+
+    def run reporter
+      reporter.puts(spec_name, indent: indent)
+      instance = self.allocate
+      runner   = proc do
+        instance.__ms__boot
+        tests.each_pair do |label,(verb,proc)|
+          reporter.print('%s %s ' % [verb, label], indent: indent + 2)
+
+          failures = instance.__ms__run_test(label)
+
+          if skipped = instance.__ms__skipped?
+            reporter.mark_as_skipped(spec_name, label, skipped)
+            next
+          end
+
+          if failures.empty?
+            reporter.mark_as_passed(spec_name, label)
+            next
+          end
+
+          reporter.mark_as_failed(spec_fullname, label, verb, proc, failures)
+        end
+        instance.__ms__halt
+      end
+      if around_all = around_all?
+        instance.instance_exec(runner, &around_all)
+      else
+        runner.call
+      end
+      reporter
+    rescue Exception => e
+      # catch exceptions raised inside :before_all/:after_all/:around_all hooks.
+      # exceptions raised inside tests are caught by instance#__ms__run_test
+      reporter.failed_specs << [spec_name, spec_proc, e]
+      reporter
+    end
+  end
+end
+
+Dir[File.expand_path('../class/**/*.rb', __FILE__)].each {|f| require(f)}

data/lib/minispec/api/class/after.rb

@@ -0,0 +1,49 @@
+module MiniSpec
+  module ClassAPI
+
+    # same as `before` except it will run after matched tests.
+    # @note `after` hooks will run even on failed tests.
+    #       however it wont run if some exception arise inside test.
+    def after *matchers, &proc
+      proc || raise(ArgumentError, 'block is missing')
+      matchers.flatten!
+      matchers = [:*] if matchers.empty?
+      return if after?.find {|x| x[0] == matchers && x[1].source_location == proc.source_location}
+      after?.push([matchers, proc])
+    end
+
+    def after? filter = nil
+      hooks_filter(@after ||= [], filter)
+    end
+
+    def reset_after
+      @after = []
+    end
+
+    # import `:after` and `:after_all` hooks from base
+    def import_after base
+      import_instance_variable(:after_all, base)
+      base.after?.each {|(m,p)| self.after(m, &p)}
+    end
+    alias import_after_from import_after
+
+    # code to run once after all tests finished.
+    # this callback will run only once.
+    # for callbacks that runs after any test @see #after
+    #
+    # @note this callback will run even if there are failed tests.
+    def after_all &proc
+      proc || raise(ArgumentError, 'block is missing')
+      @after_all = proc
+    end
+    alias after! after_all
+
+    def after_all?
+      @after_all
+    end
+
+    def reset_after_all
+      remove_instance_variable(:@after_all)
+    end
+  end
+end

data/lib/minispec/api/class/around.rb

@@ -0,0 +1,54 @@
+module MiniSpec
+  module ClassAPI
+
+    # a block to wrap each test evaluation
+    #
+    # @example
+    #   describe SomeClass do
+    #
+    #     around do |test|
+    #       DB.connect
+    #       test.run
+    #       DB.disconnect
+    #     end
+    #   end
+    #
+    def around *matchers, &proc
+      proc || raise(ArgumentError, 'block is missing')
+      matchers.flatten!
+      matchers = [:*] if matchers.empty?
+      return if around?.find {|x| x[0] == matchers && x[1].source_location == proc.source_location}
+      around?.push([matchers, proc])
+    end
+
+    def around? filter = nil
+      hooks_filter(@around ||= [], filter)
+    end
+
+    def reset_around
+      @around = []
+    end
+
+    # import `:around` and `:around_all` from base
+    def import_around base
+      import_instance_variable(:around_all, base)
+      base.around?.each {|(m,p)| self.around(m, &p)}
+    end
+    alias import_around_from import_around
+
+    # a block to wrap all tests evaluation
+    def around_all &proc
+      proc || raise(ArgumentError, 'block is missing')
+      @around_all = proc
+    end
+    alias around! around_all
+
+    def around_all?
+      @around_all
+    end
+
+    def reset_around_all
+      remove_instance_variable(:@around_all)
+    end
+  end
+end