tengu 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12e7d2f0783ace8519c31deb1b36a70057c2ddb2
+  data.tar.gz: 22900571d9768970c13b1fe6bb42cdfa220e45b4
+SHA512:
+  metadata.gz: 575f49bd06887612dfa45a755047358e2f8ec8b9ad6ad7745cb9c1b7d9b0eabd3356ef7858d8642e9f3f8556d103d4f21ea31b24541919ca481e2884736e2180
+  data.tar.gz: a20dc50058a5bc07118fa8cf12d0d5172e1b3f7f9bd05eecc1a25d3be98cc0e9657396960a4e76d400008c7b56f69c5c15f76af5614fe712a1e5afed3ee43533

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tengu.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 halogenandtoast
+
+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,16 @@
+# Tengu
+
+An object oriented test library with similar syntax to RSpec
+
+## About
+
+This is a work in progress and isn't suggested for actual use.
+
+
+## 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,7 @@
+require "bundler/gem_tasks"
+
+require 'tengu/rake_task'
+
+Tengu::RakeTask.new(:spec)
+
+task default: :spec

data/bin/tengu

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "tengu"
+
+formatter = Tengu::BaseFormatter.new
+runner = Tengu::Runner.new
+
+if ARGV.count < 1
+  files = Dir.glob("spec/**/*_spec.rb").map { |filename| ::File.open(filename, "r") }
+else
+  files = ARGV.map { |arg| ::File.open(arg, "r") }
+end
+
+runner.run(files, [formatter])

data/lib/tengu.rb

@@ -0,0 +1,19 @@
+require "tengu/base_formatter"
+require "tengu/composite_matcher"
+require "tengu/describe_block.rb"
+require "tengu/expectation"
+require "tengu/file"
+require "tengu/it_block.rb"
+require "tengu/matcher"
+require "tengu/matchers"
+require "tengu/result"
+require "tengu/runner"
+require "tengu/version"
+
+module Tengu
+  def self.test(file_name, formatter = nil)
+    formatters = Array(formatter)
+    runner = Runner.new
+    runner.run([::File.open(file_name, "r")], formatters)
+  end
+end

data/lib/tengu/allow.rb

@@ -0,0 +1,12 @@
+module Tengu
+  class Allow
+    def initialize(runner, object)
+      @runner = runner
+      @object = object
+    end
+
+    def to(receiver)
+      receiver.setup_allow(@runner, @object)
+    end
+  end
+end

data/lib/tengu/base_formatter.rb

@@ -0,0 +1,57 @@
+module Tengu
+  class BaseFormatter
+    def initialize(out = $stdout)
+      @out = out
+      @failures = []
+    end
+
+    def notify(event, object = nil)
+      case event
+      when :started then started(object)
+      when :pending then out.print "P"
+      when :success then out.print "."
+      when :failure then
+        @failures << object
+        out.print "F"
+      when :finished then finished(object)
+      end
+    end
+
+    private
+
+    attr_reader :out
+
+    def started(runner)
+      @started = Time.now
+    end
+
+    def finished(result)
+      out.puts
+      out.puts "Finished in %0.5f seconds" % [Time.now - @started]
+      out.puts "#{display(result.total_count, "example")}, #{display(result.failure_count, "failure")}"
+      if @failures.count > 0
+        puts
+        @failures.each do |it_block|
+          puts it_block.description
+          it_block.expectations.each do |expectation|
+            unless expectation.success?
+              puts expectation.message
+            end
+          end
+        end
+      end
+      if result.pending_count > 0
+        out.puts "#{result.pending_count} pending"
+      end
+    end
+
+    def display(count, word)
+      "#{count} " +
+        if count == 1
+          word
+        else
+          word + "s"
+        end
+    end
+  end
+end

data/lib/tengu/composite_matcher.rb

@@ -0,0 +1,23 @@
+module Tengu
+  class CompositeMatcher
+    def matches?(object)
+      object
+    end
+
+    def > value
+      Matcher.new("be greater than #{value.inspect}") { |object| object > value }
+    end
+
+    def >= value
+      Matcher.new("be greater than or equal to #{value.inspect}") { |object| object >= value }
+    end
+
+    def < value
+      Matcher.new("be less than #{value.inspect}") { |object| object < value }
+    end
+
+    def <= value
+      Matcher.new("be less than or equal to #{value.inspect}") { |object| object <= value }
+    end
+  end
+end

data/lib/tengu/describe_block.rb

@@ -0,0 +1,61 @@
+module Tengu
+  class DescribeBlock
+    def initialize(description, block)
+      @description = description
+      @block = block
+      @test_cases = []
+      @before_hooks = []
+      @after_hooks = []
+      load_test_cases
+    end
+
+    def run(runner, listeners = [])
+      run_test_cases(runner, listeners)
+    end
+
+    def success_count
+      @test_cases.count { |test_case| test_case.success? }
+    end
+
+    def test_count
+      @test_cases.count { |test_case| !test_case.pending? }
+    end
+
+    def pending_count
+      @test_cases.count { |test_case| test_case.pending? }
+    end
+
+    private
+
+    def include(included_module)
+      singleton_class.send(:include, included_module)
+    end
+
+    def before(&block)
+      @before_hooks << block
+    end
+
+    def after(&block)
+      @after_hooks << block
+    end
+
+
+    def load_test_cases
+      instance_eval &@block
+    end
+
+    def run_test_cases(runner, listeners = [])
+      @test_cases.each do |test_case|
+        @before_hooks.each { |hook| hook.call }
+        test_case.run(runner, listeners)
+        @after_hooks.each { |hook| hook.call }
+      end
+    end
+
+    def it(description = nil, &block)
+      @test_cases << ItBlock.new(description, block)
+    end
+
+    def xit(description, &block); end
+  end
+end

data/lib/tengu/double.rb

@@ -0,0 +1,22 @@
+module Tengu
+  class Double
+    def initialize(identifier = nil, methods = {})
+      @identifier = identifier
+      methods.each do |message, value|
+        define_singleton_method message, -> (*args) { _tengu_received[message] << args; value }
+      end
+    end
+
+    def _tengu_received
+      @_tengu_received ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def _tengu_received?(message, args = [])
+      if args.length > 0
+        _tengu_received[message] && _tengu_received[message].include?(args)
+      else
+        _tengu_received.keys.include?(message)
+      end
+    end
+  end
+end

data/lib/tengu/expectation.rb

@@ -0,0 +1,33 @@
+module Tengu
+  class Expectation
+    def initialize(object)
+      @object = object
+      @success = false
+      @positive = true
+      @matcher = nil
+    end
+
+    def success?
+      @success
+    end
+
+    def to(matcher)
+      @matcher = matcher
+      @success = @matcher.matches?(@object)
+    end
+
+    def not_to(matcher)
+      @positive = false
+      @matcher = matcher
+      @success = !@matcher.matches?(@object)
+    end
+
+    def message
+      if @positive
+        "expected #{@object.inspect} to #{@matcher.description}"
+      else
+        "expected #{@object.inspect} not to #{@matcher.description}"
+      end
+    end
+  end
+end

data/lib/tengu/file.rb

@@ -0,0 +1,43 @@
+module Tengu
+  class File
+    def initialize(io)
+      @io = io
+      @describes = []
+      load_tests
+    end
+
+    def run(runner, listeners = [])
+      run_tests(runner, listeners)
+    end
+
+    def success_count
+      @describes.inject(0) { |sum, n| sum += n.success_count }
+    end
+
+    def test_count
+      @describes.inject(0) { |sum, n| sum += n.test_count }
+    end
+
+    def pending_count
+      @describes.inject(0) { |sum, n| sum += n.pending_count }
+    end
+
+    private
+
+    def code
+      @code ||= @io.read
+    end
+
+    def load_tests
+      instance_eval(code)
+    end
+
+    def run_tests(runner, listeners= [])
+      @describes.each { |describe| describe.run(runner, listeners) }
+    end
+
+    def describe(description, &block)
+      @describes << DescribeBlock.new(description, block)
+    end
+  end
+end

data/lib/tengu/it_block.rb

@@ -0,0 +1,77 @@
+require "tengu/matchers"
+require "tengu/double"
+require "tengu/allow"
+require "tengu/receiver"
+
+module Tengu
+  class ItBlock
+    include Matchers
+    attr_reader :description, :expectations
+
+    def initialize(description, block)
+      @description = description
+      @block = block
+      @success = true
+      @pending = false
+      @expectations = []
+    end
+
+    def run(runner, listeners = [])
+      @runner = runner
+      instance_eval(&@block)
+      @runner.reset_overrides
+      notify(listeners)
+    end
+
+    def success?
+      unless pending?
+        @expectations.all? { |expectation| expectation.success? }
+      end
+    end
+
+    def pending?
+      @pending
+    end
+
+    private
+
+    def allow(object)
+      Allow.new(@runner, object)
+    end
+
+    def receive(message)
+      Receiver.new(message)
+    end
+
+    def double(identifier = nil, args = {})
+      Double.new(identifier, args)
+    end
+
+    def notify(listeners)
+      listeners.each do |listener|
+        listener.notify(success_state, self)
+      end
+    end
+
+    def success_state
+      if pending?
+        :pending
+      elsif success?
+        :success
+      else
+        :failure
+      end
+    end
+
+    def pending
+      @success = false
+      @pending = true
+    end
+
+    def expect(object)
+      expectation = Expectation.new(object)
+      @expectations << expectation
+      expectation
+    end
+  end
+end

data/lib/tengu/matcher.rb

@@ -0,0 +1,13 @@
+module Tengu
+  class Matcher
+    attr_reader :description
+    def initialize(description, &block)
+      @description = description
+      @block = block
+    end
+
+    def matches?(object)
+      @block.call(object)
+    end
+  end
+end

data/lib/tengu/matchers.rb

@@ -0,0 +1,57 @@
+require "tengu/receive_matcher"
+
+module Tengu
+  module Matchers
+    def be_true
+      eq(true)
+    end
+
+    def be_false
+      eq(false)
+    end
+
+    def be_nil
+      eq(nil)
+    end
+
+    def have_received(message)
+      ReceiveMatcher.new(message, "have received #{message.inspect}") { |object| object._tengu_received?(message) }
+    end
+
+    def include(value)
+      Matcher.new("include #{value.inspect}") { |object| object.include?(value) }
+    end
+
+    def eq(value)
+      Matcher.new("be eq to #{value.inspect}") { |object| object == value }
+    end
+
+    def eql(value)
+      Matcher.new("be eql to #{value.inspect}")  { |object| object.eql?(value) }
+    end
+
+    def equal(value)
+      Matcher.new("be equal to #{value.inspect}") { |object| object.equal?(value) }
+    end
+
+    def be(value = nil)
+      if value
+        equal(value)
+      else
+        CompositeMatcher.new
+      end
+    end
+
+    def be_instance_of(value)
+      Matcher.new("be instance of #{value.inspect}") { |object| object.instance_of?(value) }
+    end
+
+    def be_kind_of(value)
+      Matcher.new("be kind of #{value.inspect}") { |object| object.kind_of?(value) }
+    end
+
+    def match(value)
+      Matcher.new("match #{value.inspect}") { |object| object =~ value }
+    end
+  end
+end

data/lib/tengu/rake_task.rb

@@ -0,0 +1,19 @@
+require "rake"
+require "rake/tasklib"
+require "tengu"
+
+module Tengu
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    def initialize(name = :spec)
+      desc "Run tengu tests"
+      task name do |_, task_args|
+        files = Dir.glob("spec/**/*_spec.rb").map { |filename| ::File.open(filename, "r") }
+        formatter = Tengu::BaseFormatter.new
+        runner = Tengu::Runner.new
+        runner.run(files, [formatter])
+      end
+    end
+  end
+end

data/lib/tengu/receive_matcher.rb

@@ -0,0 +1,18 @@
+require "tengu/matcher"
+
+module Tengu
+  class ReceiveMatcher < Matcher
+    def initialize(method_message, message, &block)
+      @method_message = method_message
+      @message = message
+      @with = nil
+      super(message, &block)
+    end
+
+    def with(*args)
+      method_message = @method_message
+      @block = -> (object) { object._tengu_received?(method_message, args) }
+      self
+    end
+  end
+end

data/lib/tengu/receiver.rb

@@ -0,0 +1,53 @@
+require 'pry'
+
+module Tengu
+  class Receiver
+    def initialize(message)
+      @message = message
+      @args = nil
+      @return = nil
+    end
+
+    def with(*args)
+      @args = args
+      self
+    end
+
+    def and_return(return_value)
+      @return = return_value
+      self
+    end
+
+    def setup_allow(runner, object)
+      unless object.respond_to?(:_tengu_received?)
+        object.instance_eval do
+          define_singleton_method(:_tengu_received) do
+            @_tengu_received ||= Hash.new { |hash, key| hash[key] = [] }
+          end
+
+          define_singleton_method(:_tengu_received?) do |message, args = []|
+            if args.length > 0
+              _tengu_received[message] && _tengu_received[message].include?(args)
+            else
+              _tengu_received.keys.include?(message)
+            end
+          end
+        end
+      end
+
+      message = @message
+      return_value = @return
+      if object.is_a? Tengu::Double
+        object.instance_eval do
+          define_singleton_method message, -> (*args) { _tengu_received[message] << args; return_value }
+        end
+      else
+        original_method = object.method(@message.to_sym)
+        runner.record_override(object, original_method)
+        object.instance_eval do
+          define_singleton_method message, -> (*args) { _tengu_received[message] << args; return_value }
+        end
+      end
+    end
+  end
+end

data/lib/tengu/result.rb

@@ -0,0 +1,16 @@
+module Tengu
+  class Result
+    attr_reader :success_count, :total_count, :pending_count
+
+    def initialize(files)
+      @files = files
+      @success_count = @files.inject(0) { |sum, n| sum += n.success_count }
+      @total_count = @files.inject(0) { |sum, n| sum += n.test_count }
+      @pending_count = @files.inject(0) { |sum, n| sum += n.pending_count }
+    end
+
+    def failure_count
+      total_count - success_count
+    end
+  end
+end

data/lib/tengu/runner.rb

@@ -0,0 +1,29 @@
+module Tengu
+  class Runner
+    def initialize(options = {})
+      @options = options
+      @overrides = []
+    end
+
+    def record_override(object, method)
+      @overrides << [object, method]
+    end
+
+    def reset_overrides
+      @overrides.reverse.each do |object, method|
+        object.instance_eval do
+          define_singleton_method method.name, method
+        end
+      end
+    end
+
+    def run(ios, formatters = [])
+      @files = ios.map { |io| Tengu::File.new(io) }
+      formatters.each { |formatter| formatter.notify(:started, self) }
+      @files.each { |file| file.run(self, formatters) }
+      result = Result.new(@files)
+      formatters.each { |formatter| formatter.notify(:finished, result) }
+      result
+    end
+  end
+end

data/lib/tengu/version.rb

@@ -0,0 +1,3 @@
+module Tengu
+  VERSION = "0.0.1"
+end

data/spec/allow_spec.rb

@@ -0,0 +1,12 @@
+describe Tengu::Allow do
+  include Tengu
+
+  it "sets up the receiver" do
+    runner = double
+    object = double
+    receiver = double
+    allow(receiver).to receive(:setup_allow).with(runner, object).and_return("expected")
+    tengu_allow = Allow.new(runner, object)
+    expect(tengu_allow.to(receiver)).to eq("expected")
+  end
+end

data/spec/base_formatter_spec.rb

@@ -0,0 +1,62 @@
+require "tengu"
+require "stringio"
+
+describe "BaseFormatter" do
+  it "prints . when notified of success" do
+    output = StringIO.new
+    formatter = Tengu::BaseFormatter.new(output)
+    formatter.notify(:success)
+    output.rewind
+    expect(output.read).to eq(".")
+  end
+
+  it "prints F when notified of failure" do
+    output = StringIO.new
+    formatter = Tengu::BaseFormatter.new(output)
+    formatter.notify(:failure)
+    output.rewind
+    expect(output.read).to eq("F")
+  end
+
+  it "prints P when notified of pending" do
+    output = StringIO.new
+    formatter = Tengu::BaseFormatter.new(output)
+    formatter.notify(:pending)
+    output.rewind
+    expect(output.read).to eq("P")
+  end
+
+  it "tracks the time" do
+    output = StringIO.new
+    formatter = Tengu::BaseFormatter.new(output)
+    allow(Time).to receive(:now).and_return(10)
+    formatter.notify(:started, nil)
+    allow(Time).to receive(:now).and_return(31)
+    result = OpenStruct.new(total_count: 0, failure_count: 0, pending_count: 0)
+    formatter.notify(:finished, result)
+    output.rewind
+    expect(output.read).to match(/Finished in 21.00000 seconds/)
+  end
+
+  it "tracks the example count" do
+    allow(Time).to receive(:now).and_return(10)
+    output = StringIO.new
+    formatter = Tengu::BaseFormatter.new(output)
+    formatter.notify(:started, nil)
+    result = OpenStruct.new(total_count: 5, failure_count: 0, pending_count: 0)
+    formatter.notify(:finished, result)
+    output.rewind
+    expect(output.read).to match(/5 examples/)
+  end
+
+  it "tracks the failure count" do
+    allow(Time).to receive(:now).and_return(10)
+    output = StringIO.new
+    formatter = Tengu::BaseFormatter.new(output)
+    formatter.notify(:started, nil)
+    result = OpenStruct.new(total_count: 0, failure_count: 3, pending_count: 0)
+    formatter.notify(:finished, result)
+    output.rewind
+    expect(output.read).to match(/3 failures/)
+  end
+end

data/spec/composite_matcher_spec.rb

@@ -0,0 +1,29 @@
+describe Tengu::CompositeMatcher do
+  include Tengu
+
+  it "will check existance" do
+    expect(CompositeMatcher.new.matches?("wombat")).to be
+  end
+
+  it "will check >" do
+    expect(5).to be > 4
+    expect(3).not_to be > 4
+  end
+
+  it "will check >=" do
+    expect(5).to be >= 4
+    expect(5).to be >= 5
+    expect(5).not_to be >= 6
+  end
+
+  it "will check <" do
+    expect(5).to be < 6
+    expect(6).not_to be < 6
+  end
+
+  it "will check <=" do
+    expect(5).to be <= 6
+    expect(6).to be <= 6
+    expect(7).not_to be <= 6
+  end
+end

data/spec/describe_block_spec.rb

@@ -0,0 +1,37 @@
+require "tengu"
+
+describe Tengu::DescribeBlock do
+  include Tengu
+
+  it "evaluates the code passed in" do
+    test = "foo"
+    code = -> (wombat) { test = wombat }
+    block = DescribeBlock.new("test", code)
+    expect(test).to eq block
+  end
+
+  it "will include modules" do
+    marsupial = Module.new
+    code = -> (wombat) { include marsupial }
+    wombat = DescribeBlock.new("test", code)
+    expect(wombat).to be_kind_of marsupial
+  end
+
+  it "runs before_hooks" do
+    expected = -> {}
+    allow(expected).to receive(:call)
+    allow(ItBlock).to receive(:new).and_return(double(ItBlock, run: true))
+    code = -> (wombat) { before &expected; it {} }
+    DescribeBlock.new("test", code).run(nil, [])
+    expect(expected).to have_received(:call)
+  end
+
+  it "runs after_hooks" do
+    expected = -> {}
+    allow(expected).to receive(:call)
+    allow(ItBlock).to receive(:new).and_return(double(ItBlock, run: true))
+    code = -> (wombat) { after &expected; it {} }
+    DescribeBlock.new("test", code).run(nil, [])
+    expect(expected).to have_received(:call)
+  end
+end

data/spec/double_spec.rb

@@ -0,0 +1,7 @@
+describe Tengu::Double do
+  include Tengu
+  it "creates methods when passed in" do
+    test_double = Double.new("test", animal: "wombat")
+    expect(test_double.animal).to eq "wombat"
+  end
+end

data/spec/expectation_spec.rb

@@ -0,0 +1,43 @@
+describe Tengu::Expectation do
+  include Tengu
+
+  it "sets success to true on postive match" do
+    expectation = Expectation.new("wombat")
+    matcher = double(Matcher, matches?: true)
+    expectation.to(matcher)
+    expect(expectation.success?).to be_true
+  end
+
+  it "sets success to false on postive mismatch" do
+    expectation = Expectation.new("wombat")
+    matcher = double(Matcher, matches?: false)
+    expectation.to(matcher)
+    expect(expectation.success?).to be_false
+  end
+
+  it "sets success to true on negative mismatch" do
+    expectation = Expectation.new("wombat")
+    matcher = double(Matcher, matches?: false)
+    expectation.not_to(matcher)
+    expect(expectation.success?).to be_true
+  end
+
+  it "sets success to false on negative match" do
+    expectation = Expectation.new("wombat")
+    matcher = double(Matcher, matches?: true)
+    expectation.not_to(matcher)
+    expect(expectation.success?).to be_false
+  end
+
+  it "returns a formatted positive message" do
+    expectation = Expectation.new("wombat")
+    expectation.to(double(Matcher, matches?: true, description: "win"))
+    expect(expectation.message).to eq 'expected "wombat" to win'
+  end
+
+  it "returns a formatted negative message" do
+    expectation = Expectation.new("numbat")
+    expectation.not_to(double(Matcher, matches?: true, description: "win"))
+    expect(expectation.message).to eq 'expected "numbat" not to win'
+  end
+end

data/spec/file_spec.rb

@@ -0,0 +1,39 @@
+require 'pry'
+
+describe Tengu::File do
+  include Tengu
+
+  it "reads the tests" do
+    code = double(File, read: "describe('test') {}")
+    file = File.new(code)
+    expect(code).to have_received(:read)
+  end
+
+  it "runs the tests" do
+    describe_block = double(DescribeBlock, run: true)
+    allow(DescribeBlock).to receive(:new).and_return(describe_block)
+    code = double(File, read: "describe('test') {}")
+    file = File.new(code)
+    runner = double
+    file.run(runner)
+    expect(describe_block).to have_received(:run).with(runner, [])
+  end
+
+  it "returns the success count" do
+    describe_block = double(DescribeBlock, run: true, success_count: 5)
+    allow(DescribeBlock).to receive(:new).and_return(describe_block)
+    code = double(File, read: "describe('test') {}")
+    file = File.new(code)
+    file.run(double)
+    expect(file.success_count).to eq 5
+  end
+
+  it "returns the test count" do
+    describe_block = double(DescribeBlock, run: true, test_count: 7)
+    allow(DescribeBlock).to receive(:new).and_return(describe_block)
+    code = double(File, read: "describe('test') {}")
+    file = File.new(code)
+    file.run(double)
+    expect(file.test_count).to eq 7
+  end
+end

data/spec/fixtures/example.rb

@@ -0,0 +1,23 @@
+$foo = "bar"
+
+describe "True" do
+  before do
+    $foo = "baz"
+  end
+
+  it "is true" do
+    expect($foo).to eq("baz")
+  end
+
+  it "includes pending" do
+    pending
+  end
+
+  xit "skips others" do
+    expect($foo).to eq("bar")
+  end
+
+  after do
+    $foo = "bar"
+  end
+end

data/spec/it_block_spec.rb

@@ -0,0 +1,21 @@
+describe Tengu::ItBlock do
+  it "runs the tests" do
+    pending
+  end
+
+  it "resets the overrides" do
+    pending
+  end
+
+  it "notifies the listeners" do
+    pending
+  end
+
+  it "returns success" do
+    pending
+  end
+
+  it "returns pending" do
+    pending
+  end
+end

data/spec/matcher_spec.rb

@@ -0,0 +1,7 @@
+describe Tengu::Matcher do
+  include Tengu
+
+  it "checks for matches" do
+    pending
+  end
+end

data/spec/receive_matcher_spec.rb

@@ -0,0 +1,7 @@
+describe Tengu::ReceiveMatcher do
+  include Tengu
+
+  it "checks for arguments" do
+    pending
+  end
+end

data/spec/receiver_spec.rb

@@ -0,0 +1,13 @@
+describe Tengu::Receiver do
+  it "specified which arguments are allowed" do
+    pending
+  end
+
+  it "sets the return value" do
+    pending
+  end
+
+  it "sets up the original object" do
+    pending
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,19 @@
+describe Tengu::Result do
+  include Tengu
+
+  it "determines the success count" do
+    pending
+  end
+
+  it "determines the total count" do
+    pending
+  end
+
+  it "determines the pending count" do
+    pending
+  end
+
+  it "determines the failure count" do
+    pending
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,19 @@
+describe Tengu::Runner do
+  include Tengu
+
+  it "records the overrides" do
+    pending
+  end
+
+  it "resets the overrides" do
+    pending
+  end
+
+  it "notifies the listeners" do
+    pending
+  end
+
+  it "runs the files" do
+    pending
+  end
+end

data/spec/tengu_spec.rb

@@ -0,0 +1,13 @@
+require "tengu"
+
+describe "Tengu" do
+  it "will .test a particular file" do
+    file_path = "test"
+    fake_file = double(::File)
+    fake_runner = double(Tengu::Runner)
+    allow(::File).to receive(:open).with(file_path, "r").and_return(fake_file)
+    allow(Tengu::Runner).to receive(:new).and_return(fake_runner)
+    allow(fake_runner).to receive(:run).with([fake_file], []).and_return("expected")
+    expect(Tengu.test(file_path)).to eq("expected")
+  end
+end

data/tengu.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tengu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tengu"
+  spec.version       = Tengu::VERSION
+  spec.authors       = ["halogenandtoast"]
+  spec.email         = ["halogenandtoast@gmail.com"]
+  spec.description   = %q{A truly object oriented testing library}
+  spec.summary       = %q{A truly object oriented testing library}
+  spec.homepage      = "http://github.com/halogenandtoast/tengu"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: tengu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- halogenandtoast
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A truly object oriented testing library
+email:
+- halogenandtoast@gmail.com
+executables:
+- tengu
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/tengu
+- lib/tengu.rb
+- lib/tengu/allow.rb
+- lib/tengu/base_formatter.rb
+- lib/tengu/composite_matcher.rb
+- lib/tengu/describe_block.rb
+- lib/tengu/double.rb
+- lib/tengu/expectation.rb
+- lib/tengu/file.rb
+- lib/tengu/it_block.rb
+- lib/tengu/matcher.rb
+- lib/tengu/matchers.rb
+- lib/tengu/rake_task.rb
+- lib/tengu/receive_matcher.rb
+- lib/tengu/receiver.rb
+- lib/tengu/result.rb
+- lib/tengu/runner.rb
+- lib/tengu/version.rb
+- spec/allow_spec.rb
+- spec/base_formatter_spec.rb
+- spec/composite_matcher_spec.rb
+- spec/describe_block_spec.rb
+- spec/double_spec.rb
+- spec/expectation_spec.rb
+- spec/file_spec.rb
+- spec/fixtures/example.rb
+- spec/it_block_spec.rb
+- spec/matcher_spec.rb
+- spec/receive_matcher_spec.rb
+- spec/receiver_spec.rb
+- spec/result_spec.rb
+- spec/runner_spec.rb
+- spec/tengu_spec.rb
+- tengu.gemspec
+homepage: http://github.com/halogenandtoast/tengu
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A truly object oriented testing library
+test_files:
+- spec/allow_spec.rb
+- spec/base_formatter_spec.rb
+- spec/composite_matcher_spec.rb
+- spec/describe_block_spec.rb
+- spec/double_spec.rb
+- spec/expectation_spec.rb
+- spec/file_spec.rb
+- spec/fixtures/example.rb
+- spec/it_block_spec.rb
+- spec/matcher_spec.rb
+- spec/receive_matcher_spec.rb
+- spec/receiver_spec.rb
+- spec/result_spec.rb
+- spec/runner_spec.rb
+- spec/tengu_spec.rb
+has_rdoc: