attest 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+vendor
+.bundle

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    attest (0.1.0)
+      trollop
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    trollop (1.16.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  attest!
+  trollop

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Alan Skorkin
+
+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.rdoc

@@ -0,0 +1,150 @@
+= Attest 
+
+    attest (vb) - to affirm the correctness or truth of
+
+Attest allows you to define spec-like tests inline (within the same file as your actual code) which means almost non-existant overheads to putting some tests around your code. Of course that is just a feature that I wanted, you can just as easily put the tests into a separate file for a more traditional experience. Overall, attest tries to not be too prescriptive regarding the 'right' way to test. You want to test private methods - go ahead, access unexposed instance variables - no worries, pending and disabled tests are first class citizens. Don't like the output format, use a different one or write your own (at least that the plan for the future, currently there is only one output writer :P). You should be allowed to test your code the way you want to, not the way someone else says you have to!
+
+== A Quick Example
+
+Currently the functionality is pretty minimal, almost fully described by the example below. But as you can see the features are complete enough to make it a fully fledged testing framework. The upside is, there is not a lot to remember/learn :P. Anyways, here is an example:
+
+  class MagicCalculator 
+    def remember_value(value)
+      @value_in_memory = value
+    end
+
+    def increment(value)
+      value + 1
+    end
+
+    def divide(numerator, denominator)
+      numerator/denominator
+    end
+
+    def add(value1, value2)
+      value1 + value2
+    end
+
+    private
+    def multiply(x, y)
+      x * y
+    end
+  end
+
+  if ENV["attest"]
+    this_tests MagicCalculator do
+      before_all{@calculator = MagicCalculator.new}
+      after_all{@calculator = nil}
+
+      test("a pending test")
+      test("deliberately fail the test"){should_fail}
+      test("a successful empty test"){}
+      test("should NOT raise an error") {should_not_raise{@calculator.increment 4}}
+      test("it should raise an error, don't care what kind") {should_raise {@calculator.divide 5, 0}}
+      test("it should raise a ZeroDivisionError error with a message"){should_raise(ZeroDivisionError){@calculator.divide 5, 0}.with_message(/divided by.*/)}
+      test("adding 5 and 2 does not equal 8") { should_not_be_true{ @calculator.add(5,2) == 8 } } 
+      test("this test will be an error when non-existant method called") {should_be_true{ @calculator.non_existant }}
+      test("should be able to call a private method like it was public"){should_be_true{@calculator.multiply(2,2) == 4}}
+
+      test "access an instance variable without explicitly exposing it" do
+        @calculator.remember_value(5)
+        should_be_true {@calculator.value_in_memory == 5}
+      end
+
+      test("multiple expectations in one test") do
+        should_not_raise{@calculator.increment 4}
+        should_raise{ @calculator.non_existant }
+      end
+      test("should not have access to calculator instance since run without setup", nosetup){should_be_true{@calculator == nil}}
+    end
+  end
+
+Here are a few things to note. All of that stuff would live in the same file and you would execute it in the following fashion:
+
+  attest -f my_ruby_file.rb
+
+The if statement with the ENV is necessary so that the test code is comlpetely ignored unless you're running it via the 'attest' executable. If anyone can think of a better way of doing it, I am open to ideas. If you have a bunch of files that live in a directory and you want to run the test that live in all of them:
+
+  attest -d directory_with_ruby_files
+
+As per usual, to get some help:
+
+  attest --help
+
+If your file needs other ruby files for it to function (as they often do :)), you will need to set up the requires yourself within the 'if ENV' block. I'll give it more smarts in this area at a later date.
+
+If you want to put the tests in a separate file, you can do that, but you will still need to wrap them in an 'if ENV' block and set up the 'requires' yourself as well, once again more smarts will hopefully appear at a later date.
+
+Currently the output produces when running will look something like this:
+
+  >~/projects/attest$ bin/attest -f examples/magic_calculator.rb 
+  /home/yellow/projects/attest/examples/magic_calculator.rb:
+   MagicCalculator
+    - a pending test [PENDING]
+    - deliberately fail the test [FAILURE]
+    - a successful empty test
+    - should NOT raise an error
+    - it should raise an error, don't care what kind
+    - it should raise a ZeroDivisionError error with a message
+    - adding 5 and 2 does not equal 8
+    - this test will be an error when non-existant method called [ERROR]
+
+       NoMethodError: undefined method `non_existant' for #<MagicCalculator:0x00000003097b60>
+
+    - should be able to call a private method like it was public
+    - access an instance variable without explicitly exposing it
+    - multiple expectations in one test
+    - should not have access to calculator instance since run without setup
+
+
+  Ran 12 tests: 9 successful, 1 failed, 1 errors, 1 pending
+
+Currently that's the only kind of output format, I'll whip up some more output formats at a later date and/or give ability to supply your own.
+
+== Current And Upcoming Features
+
+- define tests inline
+- call private methods as if they were public
+- access instance variables as if they were exposed
+- a basic output writer
+- only a few expectation types, should_fail, should_be_true, should_not_be_true, should_raise, should_not_raise - that's it for the moment
+- setup and teardown for all tests, but can connfigure a test so that no setup is run for it
+- automatically create a class that includes a module which methods you want to test (if you have a module called MyModule and you want to test its methods buy only after the module has been included in a class, a class called MyModuleClass will be automatically created and will include your module, an object of this new class will be instantiated for you to play with) e.g:
+
+    before_all do
+      @module_class = create_and_include(MyModule)
+    end
+
+- tries not to pollute core objects too much
+
+I've got a few things I want to try out in the future, I've already mentioned some of them such as more output writers and ability to define your own as well as giving it more smarts in various areas. More specifically here are some things that are high on my radar:
+
+- integrating with Mocha to provide at least some test double (i.e. mocking/stubbing) functionality
+- writing my own test double project in the same general style as attest and integrating with it as well to give another more seamless mock/stub option
+- default rake task for ability to run via rake rather than having to use the attest executable
+- output the expectation count, not just the test count in the output report 
+- more smarts around classes that define their own method missing
+- ability to disable tests and have the output list them as such 
+- write some basic unit tests for the framework using itself as the test framework (i.e. eating own dogfood style)
+- allow for multiple setup and teardown blocks and ability to specify which tests they are relevant for
+- haven't yet decided if I nested contexts are a good idea, I find they tend to confuse things
+- maybe ability to do shared contexts, once again haven't decided if they are a good idea
+- more types of expectations for convenience, e.g. should_equal etc.
+- look at providing convenience stuff for web testing since that seems to be a big deal these days, ditto file system testing (requires mucho more thought)
+
+
+== More Examples
+
+Go to the examples directory in the code, it contains the above example as well as a couple of others, reasonably easy to understand, as I said not a lot to remember at the moment.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally. (Ok, you can't really do that as yet, but it's coming up :))
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Alan Skorkin. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "attest"
+    gem.summary = %Q{An inline unit testing/spec framework that doesn't force you to follow arbitrary rules}
+    gem.description = %Q{Attest allows you to define spec-like tests inline (within the same file as your actual code) which means almost non-existant overheads to putting some tests around your code. It also tries to not be too prescriptive regarding the 'right' way to test. You want to test private methods - go ahead, access unexposed instance variables - no worries, pending and disabled tests are first class citizens. Don't like the output format, use a different one or write your own. Infact you don't even have to define you tests inline if you prefer the 'traditional' way, separate directory and all. You should be allowed to test your code the way you want to, not the way someone else says you have to!}
+    gem.email = "alan@skorks.com"
+    gem.homepage = "http://github.com/skorks/attest"
+    gem.authors = ["Alan Skorkin"]
+    gem.add_runtime_dependency "trollop"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "attest #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/attest.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{attest}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alan Skorkin"]
+  s.date = %q{2010-11-29}
+  s.default_executable = %q{attest}
+  s.description = %q{Attest allows you to define spec-like tests inline (within the same file as your actual code) which means almost non-existant overheads to putting some tests around your code. It also tries to not be too prescriptive regarding the 'right' way to test. You want to test private methods - go ahead, access unexposed instance variables - no worries, pending and disabled tests are first class citizens. Don't like the output format, use a different one or write your own. Infact you don't even have to define you tests inline if you prefer the 'traditional' way, separate directory and all. You should be allowed to test your code the way you want to, not the way someone else says you have to!}
+  s.email = %q{alan@skorks.com}
+  s.executables = ["attest"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "attest.gemspec",
+     "bin/attest",
+     "doodle.txt",
+     "examples/magic_calculator.rb",
+     "examples/more/placeholder.rb",
+     "examples/standard_calculator.rb",
+     "lib/attest.rb",
+     "lib/attest/attest_error.rb",
+     "lib/attest/config.rb",
+     "lib/attest/core_ext/kernel.rb",
+     "lib/attest/core_ext/object.rb",
+     "lib/attest/execution_context.rb",
+     "lib/attest/expectation_result.rb",
+     "lib/attest/itself.rb",
+     "lib/attest/output/basic_output_writer.rb",
+     "lib/attest/test_container.rb",
+     "lib/attest/test_object.rb",
+     "lib/attest/test_parser.rb"
+  ]
+  s.homepage = %q{http://github.com/skorks/attest}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{An inline unit testing/spec framework that doesn't force you to follow arbitrary rules}
+  s.test_files = [
+    "examples/more/placeholder.rb",
+     "examples/magic_calculator.rb",
+     "examples/standard_calculator.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<trollop>, [">= 0"])
+    else
+      s.add_dependency(%q<trollop>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<trollop>, [">= 0"])
+  end
+end
+

data/bin/attest

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+#need this so that bundler doesn't throw an error after library has been installed as gem and the executable is called
+ENV["BUNDLE_GEMFILE"] = File.expand_path(File.dirname(__FILE__) + "/../Gemfile")
+ENV["attest"] = "true"
+require File.expand_path(File.dirname(__FILE__) + "/../lib/attest")
+
+opts = Trollop::options do
+  banner <<-EOS
+Usage:
+       attest [options] <filenames>+
+where [options] are:
+EOS
+
+  opt :file, "Ruby file with inline tests that should be executed", :type => String
+  opt :directory, "Directory with ruby files which contain inline tests to be executed", :type => String, :default => nil
+end
+Trollop::die :file, "Must exist" unless File.exist?(opts[:file]) if opts[:file]
+Trollop::die :directory, "Must exist" unless File.exist?(opts[:directory]) && File.directory?(opts[:directory]) if opts[:directory]
+
+Attest.configure do |config|
+  config.output_writer = Attest::Output::BasicOutputWriter.new
+end
+
+if opts[:file]
+  Attest.config.current_file = File.join(File.expand_path(opts[:file]))
+  load opts[:file] 
+end
+
+if opts[:directory]
+  Dir[File.join(File.expand_path(opts[:directory]), "**/*.rb")].each do |file|
+    Attest.config.current_file = file
+    load file 
+  end
+end
+
+Attest.output_writer.summary

data/doodle.txt

@@ -0,0 +1,142 @@
+rough features 
+
+able to write single test in the same file as code under test, should not be able to accidentally run the test code
+able to go through all the ruby files in the project and run any tests that are found 
+able to print progress to the commandline as tests are being run 
+do not pollute the core classes unnecessarily
+
+able to go through all the ruby files in supplied directory running tests when found
+
+
+
+
+
+passing a ruby file to attest should print out whether or not there may be any inline tests in the ruby file
+
+
+most basic
+- setup and teardown DONE
+- specify test for regular public method DONE
+- specify test for a private method DONE
+- ability to read instance variable of object under test without having to specify a reader DONE
+- the most basic result output DONE
+- able to detect when test expectation fails DONE
+- execute tests for single ruby file if any present DONE
+- able to detect when test errors out and gracefully say so in output DONE
+- all object to have a should_equal expectation method DONE
+- all objects should have a should_not_equal expectation method DONE
+
+- should be able to specify a test anonymously without providing description
+- ability to give a test an id as well as description
+- ability to specify that no setup or teardown should be run for the test
+- ability to specify multiple setups and teardowns and register specific setups and teardowns to run for specific tests
+- ability to magically include module in an object and test its methods while it is included in an object
+- should provide the error message if test errors out  DONE
+- should provide the error trace if a test has errored DONE
+- all objects have access to a should_raise expectation DONE
+- should be able to produce a summary of execution at the end, with count of successes, failures and errors DONE
+- should be able to produce shorthand output while running with a summary at the end (test unit style shorthand), controlled by cli parameter
+- should have a should_fail expectation, possibly for tests that haven't been implemented aliased to not_implemented, not_implemented_failing, not_implemented_passing
+- should have a should_be_true expectation type for more flexibility DONE
+- test that are defined without a block should be tagged as not implemented in the output and in the summary
+- you can require the library without augmenting objects with extra methods, only when you call do objects get augmented and should test for the fact that a method we're trying to augment with already exists, alternatively, don't ever require this library directly then we don't have an issue DONE
+
+- the should methods should return an expectation object (itself) DONE
+- when deliberately failing should not actually print an error but should be a failure with a message instead DONE
+- the output writer should be a separate class to allow for different writers DONE
+- work out what methods need to be on the output writer class and hook them in where tests are run DONE
+- work out what other expectations need to be on the execution context intself (should_raise, should_be_true) DONE
+- work out how to easily implement negation of the positive expectations on the execution context
+- hook in configuration into the framework DONE
+- make it configurable via configuration and command line the name of the method that begins a test context (this_tests)
+- make it configurable via config and command line the name of the method that would produce an expectation object (itself or should), these are the only methods that extend core for now
+- try to execute existing method missing and if still an error then execute my method missing and fall back to existing method missing, so that don't accidentally kill method missing functionality that people wrote themselves
+- produce a short format output writer as well as a basic long format one to make sure that have ability to hook in different output writers
+- should be able to configure attest via file (attest.config in same directory, or give location of config as command line param, or via .attest file in home dir or via a configuration block in a file under test, each level can override the other)
+- what expectation methods are actaully needed on the objects in the test methods themselves (should_be_true, should_equal etc) work out negation for these ones as well 
+- what methods should the expectation object have and how to allow to chain the methods and have everything work 
+- all test context should have an id and if one is not provided it should be generated
+- all test methods should have an id and if one is not provided it should be generated 
+- before and after blocks should be able to refer to tests they are targeting by the test id
+- test should be able to specify if they don't want the befores and afters to be run for them (this will take precedence over everything else)
+- need to have a should_fail execution context method, with alias of fail  
+- should be able to call should_be empty on an object where empty is a method on the object, should_equal size 5 where size is a method on the object, i.e. boolean method on the objects gets used as a predicate
+- a expectation that this object as the same as another object, i.e. exactly the same object not an equal one
+- for exceptions, should_raise(XyzError) {x.some_call}.with_message(/some message regex/), the XyzError and the regex should be optional DONE
+- test methods in a module that is built for class inclusion
+- test free floating methods that don't belong to a class or a module
+- an anonymous test without description similat to the test pile below but still for only one thing
+- a test pile method where you want to test random methods or do lots of assertions at the same time without having to think of a name for it, should introspect somehow what is/will be run and work out descriptions from that
+- ability to define matchers as lambdas would be good i.e. obj.should_be happy where happy is a lambda that returns a boolean value
+
+
+
+- a rake task to run the tests instead of a separate executable, configuration should be done through the rake task
+- ability to mock stuff out using some of the popular mocking frameworks, ability to plug in different one by config, including my own by default which hasn't been written yet
+- potentially later on think about doing nested contexts as well as shared contexts
+- some way to potentially work out if files are ruby even if no .rb extension or alternatively pass a glob on the command line to match files
+- allow redefining of the name of the main context method through the command line(e.g. rather than this_tests allow person to name it whatever they want)
+
+
+- kill the This class and turn it back into a this_tests method on Kernel DONE
+- merge everything into Master DONE
+- branch master into a Hooks branch and leave to have a look at later DONE
+- remove the hooks stuff from master DONE
+- add the file in which the tests were found to the output of the tests DONE
+- add functionality to allow a directory with ruby files to be parsed for tests and all tests to be run if any are found, non-recursively DONE
+- add functionality to allow a directory to be parsed for tests recursively DONE
+- allow multiple context within the same file to work properly and execute properly DONE
+- make sure can test methods in a module not just in a class, magically included in a class DONE
+- make sure can test class methods DONE
+- make sure can test methods that don't belong to a module or a class DONE
+- when multiple contexts in the same file, only print the name of the file to the command line once DONE
+- don't print summaries after every context, only a totals summary at the end DONE
+- make it so that tests can take an options hash and one of the options should be to not run setup or teardown for the test, perhaps make it not part of the opts hash DONE
+- should be able to specify a test without a body for it to appear in the output as pending DONE
+- refactor all example code so it is a bit nicer and more representative
+- once all the above are done, create some RDOC documentation to describe the basic features and usage of the framework
+- also fix up the description and extended description, make sure everything looks proper as far as doco is concerned on github etc.
+- if everything is ok at this point, do a first public release of the gem (give it an appropriately betaish version number)
+- make sure the gem is available through rubyforge as well as wherever else is appropriate, e.g. gemcutter
+
+
+- when committing need to make sure there is a valid gemspec
+- when used with bundler dependencies like trollop don't come trhough so can't execute attest properly get an error instead need to detect if being used via bundler and do a bundle setup etc.
+
+next release
+
+- integrate mocha so that can mock using mocha 
+- output calculations of expectations not just tests
+- allow expectations to be specified directly as tests (perhaps failures should contain the block that has failed)
+- create a failures only output writer and allow it to be configured
+- create a test/unit style output writer and allow it to be configured
+- test out with method missing defined on the class, does it still work ok
+- make sure if method missing is defined it is tried out first before the new_method_missing on kernel takes over
+- should be able to disable a test so that it is not executed, but is listed as disabled in the output
+
+next release 2
+
+- write and integrate own test double framework (look at rr for syntax suggestions)
+- create some tests using the framework itself around the framework classes (minimal test suite)
+- allow expectations to be made on objects themselves
+- allow for tests to be given ids as well as descriptions
+- allow for multiple before and after blocks should specify which test to run this block for using ids of tests as parameters
+
+next release 3
+- come up with some more useful expectations, both on object and as standalone methods of test
+- look into rails stuff regarding expectations and idioms etc
+- should somehow be able to require all the necessary ruby files that are needed when a test is run for the test not to fail, e.g. because ruby files depend on other ruby files
+
+
+
+what to say in readme
+give an example of usage
+talk about how to define tests inline
+talk about how to execute the tests in one file or directory etc
+list the currently supported expectations
+talk about pendind tests
+talk about the fact that other output writers are coming
+talk about the fact that you can disable setup for particular tests
+talk about how to test modules within an included class
+no nested context as yet, but can define multiple top level ones, no shared tests or contexts as yet
+mention the examples directory but it is currently crappy

data/examples/magic_calculator.rb

@@ -0,0 +1,50 @@
+class MagicCalculator 
+  def remember_value(value)
+    @value_in_memory = value
+  end
+
+  def increment(value)
+    value + 1
+  end
+
+  def divide(numerator, denominator)
+    numerator/denominator
+  end
+
+  def add(value1, value2)
+    value1 + value2
+  end
+
+  private
+  def multiply(x, y)
+    x * y
+  end
+end
+
+if ENV["attest"]
+  this_tests MagicCalculator do
+    before_all{@calculator = MagicCalculator.new}
+    after_all{@calculator = nil}
+
+    test("a pending test")
+    test("deliberately fail the test"){should_fail}
+    test("a successful empty test"){}
+    test("should NOT raise an error") {should_not_raise{@calculator.increment 4}}
+    test("it should raise an error, don't care what kind") {should_raise {@calculator.divide 5, 0}}
+    test("it should raise a ZeroDivisionError error with a message"){should_raise(ZeroDivisionError){@calculator.divide 5, 0}.with_message(/divided by.*/)}
+    test("adding 5 and 2 does not equal 8") { should_not_be_true{ @calculator.add(5,2) == 8 } } 
+    test("this test will be an error when non-existant method called") {should_be_true{ @calculator.non_existant }}
+    test("should be able to call a private method like it was public"){should_be_true{@calculator.multiply(2,2) == 4}}
+
+    test "access an instance variable without explicitly exposing it" do
+      @calculator.remember_value(5)
+      should_be_true {@calculator.value_in_memory == 5}
+    end
+
+    test("multiple expectations in one test") do
+      should_not_raise{@calculator.increment 4}
+      should_raise{ @calculator.non_existant }
+    end
+    test("should not have access to calculator instance since run without setup", nosetup){should_be_true{@calculator == nil}}
+  end
+end

data/examples/more/placeholder.rb

@@ -0,0 +1,28 @@
+class Placeholder1
+  def divide(x,y)
+    x/y
+  end
+end
+
+class Placeholder2
+  def multiply(x,y)
+    x*y
+  end
+end
+
+def random_method(x)
+  x+x
+end
+
+if ENV["attest"]
+  this_tests Placeholder1 do
+    test("divide successful"){should_be_true{Placeholder1.new.divide(16, 4) == 4}}
+    test("divide by zero"){should_raise{Placeholder1.new.divide(5,0)}}
+  end
+  this_tests Placeholder2 do
+    test("multiply") {should_be_true{Placeholder2.new.multiply(2,3)==6}}
+  end
+  this_tests "random methods" do
+    test("random method"){should_be_true{random_method("abc") == "abcabc"}}
+  end
+end

data/examples/standard_calculator.rb

@@ -0,0 +1,28 @@
+class StandardCalculator
+  def self.plus(x, y)
+    x + y
+  end
+
+  def self.minus(x, y)
+    x - y
+  end
+end
+
+module CalcMethods
+  def double(x)
+    2 * x
+  end
+end
+
+if ENV["attest"]
+  this_tests "another class with claculations" do
+    test("adding two numbers") {should_be_true{StandardCalculator.plus(5,11) == 16}}
+    test("subtracting two numbers"){should_not_be_true{StandardCalculator.minus(10,5) == 4}}
+  end
+
+  this_tests CalcMethods do
+    before_all { @module_class = create_and_include(CalcMethods) }
+
+    test("magically instance of a class that will include the module"){should_be_true{@module_class.double(5)==10}}
+  end
+end

data/lib/attest.rb

@@ -0,0 +1,38 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default)
+
+require "trollop"
+require "singleton"
+require 'attest/config'
+require 'attest/core_ext/kernel'
+require 'attest/core_ext/object'
+
+require 'attest/expectation_result'
+require 'attest/test_container'
+require 'attest/test_object'
+require 'attest/execution_context'
+require 'attest/test_parser'
+require 'attest/itself'
+require 'attest/attest_error'
+
+require 'attest/output/basic_output_writer'
+
+module Attest
+  class << self
+    def configure
+      config = Attest::Config.instance
+      block_given? ? yield(config) : config
+    end
+
+    alias :config :configure
+
+    Attest::Config.public_instance_methods(false).each do |name|
+      self.class_eval <<-EOT
+        def #{name}(*args)
+          configure.send("#{name}", *args)
+        end
+      EOT
+    end
+  end
+end

data/lib/attest/attest_error.rb

@@ -0,0 +1,7 @@
+module Attest
+  class AttestError < RuntimeError
+    def initialize(message)
+      super message
+    end
+  end
+end

data/lib/attest/config.rb

@@ -0,0 +1,12 @@
+module Attest
+  class Config
+    include Singleton
+
+    attr_accessor :output_writer, :current_file
+
+    def initialize
+      @output_writer = Attest::Output::BasicOutputWriter.new
+    end
+
+  end
+end

data/lib/attest/core_ext/kernel.rb

@@ -0,0 +1,34 @@
+module Kernel
+  def new_method_missing(name, *args, &block)
+    private_method = false
+    instance_variable = false
+    private_methods.each do |meth|
+      private_method = true if meth == name
+    end
+    instance_variable = true if instance_variable_defined?("@#{name}".to_sym)
+    if private_method
+      send(name, *args, &block)
+    elsif instance_variable
+      self.class.class_eval do
+        attr_reader name.to_sym
+      end
+      send(name, *args, &block)
+    else
+      old_method_missing(name, *args, &block) 
+    end
+  end
+  alias_method :old_method_missing, :method_missing
+  alias_method :method_missing, :new_method_missing
+
+  private
+  def this_tests(description="anonymous", &block)
+    container = Attest::TestParser.new(description, block).parse
+    container.execute_all
+  end
+  def current_method
+    caller[0][/`([^']*)'/, 1]
+  end
+  def calling_method
+    caller[1][/`([^']*)'/, 1]
+  end
+end

data/lib/attest/core_ext/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def itself 
+    Attest::Itself.new(self)
+  end
+end

data/lib/attest/execution_context.rb

@@ -0,0 +1,84 @@
+module Attest
+  class ExecutionContext
+    attr_reader :results
+
+    def initialize
+      @results = []
+      @subject = self
+    end
+
+    def should_raise(type=nil, &block)
+      result = Attest::ExpectationResult.new
+      begin
+        if block_given?
+          yield
+        end
+      rescue => e
+        result.update(:expected_error => e)
+        if type && type == e.class
+          result.success
+        else
+          result.success
+        end
+      end
+      unless result.success?
+        result.failure 
+      end
+      @results << result
+      self
+    end
+
+    def with_message(regex)
+      result = @results.last
+      if result.success? && result.attributes[:expected_error]
+        if !(result.attributes[:expected_error].message =~ regex)
+          result.failure
+        end
+      end
+      self
+    end
+
+    def should_fail
+      result = Attest::ExpectationResult.new
+      result.failure
+      @results << result
+      self
+    end
+
+    def should_be_true(&block)
+      result = Attest::ExpectationResult.new
+      block_return = yield
+      block_return ? result.success : result.failure
+      @results << result
+      self
+    end
+
+    def should_not_raise(&block)
+      should_raise(&block)
+      result = @results.last
+      result.success? ? result.failure : result.success
+      self
+    end
+
+    def should_not_be_true(&block)
+      should_be_true(&block)
+      result = @results.last
+      result.success? ? result.failure : result.success
+      self
+    end
+
+    #worker methods
+    def create_and_include(module_class)
+      class_name = "#{module_class}Class"
+      class_instance = Class.new
+      Object.const_set class_name, class_instance
+      Object.const_get(class_name).include(Object.const_get("#{module_class}"))
+      klass = Object.const_get(class_name)
+      klass.new
+    end
+
+    def nosetup
+      true
+    end
+  end
+end

data/lib/attest/expectation_result.rb

@@ -0,0 +1,28 @@
+module Attest
+  class ExpectationResult
+    attr_reader :attributes
+    def initialize(attributes={})
+      @outcome = nil
+      @attributes = attributes
+    end
+
+    [:success, :failure, :error, :pending].each do |status|
+      eval <<-EOT
+        def #{status}
+          @outcome = current_method
+        end
+        def #{status}?
+          current_method.chop == @outcome
+        end
+      EOT
+    end
+
+    def status
+      @outcome
+    end
+
+    def update(attributes={})
+      @attributes.merge!(attributes)
+    end
+  end
+end

data/lib/attest/itself.rb

@@ -0,0 +1,34 @@
+module Attest
+  class Itself
+
+    def initialize(object)
+      @itself = object
+      @state = state
+    end
+
+    #when error is set, if it is a child of an exception or is an exception itself then with_message is available, otherwise it is not and shoudl throw a no method
+
+    #def with_message(regex)
+      #raise NoMethodError if !@itself.kind_of?(Exception)
+      #if @itself.message =~ regex
+        #@state = Attest::Itself.STATES[:success]
+      #end
+    #end
+
+    #def should_equal(another_object)
+      #@itself == another_object
+    #end
+
+    #def should_not_equal(another_object)
+      #@itself != another_object
+    #end
+
+    #should_be_true
+    #should_not_be_true
+    #should_equal
+    #should_not_equal
+    #should_be_same
+    #should_not_be_same
+    #with_message if itself is an error object
+  end
+end

data/lib/attest/output/basic_output_writer.rb

@@ -0,0 +1,73 @@
+module Attest
+  module Output
+    class BasicOutputWriter
+      def initialize
+        @containers = []
+      end
+
+      def before_everything
+      end
+
+      def before_context(container)
+        previous_container = @containers.last
+        @containers << container
+        puts "#{container.file}:" unless previous_container && previous_container.file == container.file
+        puts " #{ container.description }"
+      end
+
+      def before_test(test_object)
+        print "  - #{test_object.description}"
+      end
+
+      def after_test(test_object)
+        relevant_result = nil
+        test_object.results.each do |result|
+          relevant_result = result if !result.success?
+        end
+        print " [#{relevant_result.status.upcase}]" if relevant_result
+        if relevant_result && relevant_result.error?
+          e = relevant_result.attributes[:unexpected_error]
+          2.times { puts } 
+          puts "     #{e.class}: #{e.message}"
+          e.backtrace.each do |line|
+            break if line =~ /lib\/attest/
+              puts "     #{line} "
+          end
+        end
+        puts
+      end
+
+      def after_context
+        puts 
+      end
+
+      def summary
+        return unless @containers.size >= 1
+        tests, success, failure, error, pending = 0, 0, 0, 0, 0
+        @containers.each do |container|
+          container.test_objects.each do |test_object|
+            tests += 1
+            test_object.results.each do |result|
+              if result.success?
+                success += 1
+              elsif result.failure?
+                failure += 1
+              elsif result.error?
+                error += 1
+              elsif result.pending?
+                pending += 1
+              else
+                raise "Errr, WTF!!!"
+              end
+            end
+          end
+        end
+        puts
+        puts "Ran #{tests} tests: #{success} successful, #{failure} failed, #{error} errors, #{pending} pending"
+      end
+
+      def after_everything
+      end
+    end
+  end
+end

data/lib/attest/test_container.rb

@@ -0,0 +1,24 @@
+module Attest
+  class TestContainer
+
+    attr_reader :description, :test_objects, :file
+
+    def initialize(description)
+      @file = Attest.current_file
+      @description = description
+      @test_objects = []
+    end
+
+    def add(test)
+      @test_objects << test
+    end
+
+    def execute_all
+      Attest.output_writer.before_context(self)
+      @test_objects.each do |test_object|
+        test_object.run
+      end
+      Attest.output_writer.after_context
+    end
+  end
+end

data/lib/attest/test_object.rb

@@ -0,0 +1,59 @@
+module Attest
+  class TestObject
+    attr_reader :description, :results
+    attr_accessor :nosetup
+    def initialize(description, test_block)
+      @description = description
+      @test_block = test_block
+      @before = nil
+      @after = nil
+      @results = nil
+    end
+
+    def add_setup(block)
+      @before = block
+    end
+
+    def add_cleanup(block)
+      @after = block
+    end
+
+    def run
+      Attest.output_writer.before_test(self)
+      error = nil
+      context = Attest::ExecutionContext.new
+      begin
+       Object.class_eval do
+         define_method :itself do
+           subject = self
+           context.instance_eval {@subject = subject}
+           context
+         end
+       end
+       context.instance_eval(&@before) if @before && !nosetup
+       context.instance_eval(&@test_block) if @test_block
+       context.instance_eval(&@after) if @after && !nosetup
+      rescue => e
+        error = e
+      ensure
+        @results = context.results
+        add_unexpected_error_result(error) if error
+        add_pending_result unless @test_block
+      end
+      Attest.output_writer.after_test(self)
+    end
+
+    private
+    def add_unexpected_error_result(error)
+      result = Attest::ExpectationResult.new(:unexpected_error => error)
+      result.error
+      @results << result
+    end
+
+    def add_pending_result
+      result = Attest::ExpectationResult.new
+      result.pending
+      @results << result
+    end
+  end
+end

data/lib/attest/test_parser.rb

@@ -0,0 +1,38 @@
+module Attest
+  class TestParser
+    def initialize(description, block)
+      @description = description
+      @block = block
+      @before = nil
+      @after = nil
+      @tests = {}
+      @nosetup = {}
+    end
+
+    def parse
+      self.instance_eval(&@block)
+      test_container = Attest::TestContainer.new(@description)
+      @tests.each_pair do |description, test_block|
+        test_object = TestObject.new(description, test_block)
+        test_object.nosetup = true if @nosetup[description]
+        test_object.add_setup(@before)
+        test_object.add_cleanup(@after)
+        test_container.add(test_object)
+      end
+      test_container
+    end
+
+    def before_all(&block)
+      @before = block 
+    end
+
+    def after_all(&block)
+      @after = block
+    end
+
+    def test(description, nosetup=false, &block)
+      @tests[description] = block
+      @nosetup[description] = true if nosetup
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: attest
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alan Skorkin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-29 00:00:00 +11:00
+default_executable: attest
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Attest allows you to define spec-like tests inline (within the same file as your actual code) which means almost non-existant overheads to putting some tests around your code. It also tries to not be too prescriptive regarding the 'right' way to test. You want to test private methods - go ahead, access unexposed instance variables - no worries, pending and disabled tests are first class citizens. Don't like the output format, use a different one or write your own. Infact you don't even have to define you tests inline if you prefer the 'traditional' way, separate directory and all. You should be allowed to test your code the way you want to, not the way someone else says you have to!
+email: alan@skorks.com
+executables: 
+- attest
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- attest.gemspec
+- bin/attest
+- doodle.txt
+- examples/magic_calculator.rb
+- examples/more/placeholder.rb
+- examples/standard_calculator.rb
+- lib/attest.rb
+- lib/attest/attest_error.rb
+- lib/attest/config.rb
+- lib/attest/core_ext/kernel.rb
+- lib/attest/core_ext/object.rb
+- lib/attest/execution_context.rb
+- lib/attest/expectation_result.rb
+- lib/attest/itself.rb
+- lib/attest/output/basic_output_writer.rb
+- lib/attest/test_container.rb
+- lib/attest/test_object.rb
+- lib/attest/test_parser.rb
+has_rdoc: true
+homepage: http://github.com/skorks/attest
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An inline unit testing/spec framework that doesn't force you to follow arbitrary rules
+test_files: 
+- examples/more/placeholder.rb
+- examples/magic_calculator.rb
+- examples/standard_calculator.rb