atto 0.9.0

data/README

@@ -0,0 +1,50 @@
+INTRODUCTION
+
+Atto is an ultra-tiny self-contained testing framework inspired by 
+and partially based on nanotest. It is self-contained in that it needs no 
+external libraries. Every file in this project is,and will remain under 100 
+lines long, comments included.
+
+
+USAGE
+
+To use it in your tests, for every ruby file lib/foo/bar.rb in your project,
+make a test file lib/foo/test_bar.rb and start it with: 
+
+require 'atto'
+include Atto::Test
+
+# Then you can add tests like this:
+assert "A test that will always suceed" do true end
+# Or like this :
+assert { Foo::Bar }
+
+Then run the command atto from your project directory and it will run the tests
+automatically, every time you change either the lib file or the test file. It 
+will also detect new files being added.
+
+LICENSE
+
+The MIT License
+
+Copyright (c) 2011 Beoran (beoran@rubyforge.org)
+
+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/Rakefile

@@ -0,0 +1,46 @@
+# Rakefile added by John Mair (banisterfiend)
+
+require 'rake/gempackagetask'
+require 'rake/clean'
+CLEAN.include("pkg/*.gem")
+
+
+ATTO_VERSION = "0.9.0"
+
+def apply_spec_defaults(s)
+end
+
+spec = Gem::Specification.new do |s|
+    s.name          = "atto"
+    s.summary       = "An ultra-tiny self-contained testing framework."
+    s.description   = s.summary + " "
+    s.version       = ATTO_VERSION
+    s.author        = "Beoran"
+    s.email         = 'beoran@rubyforge.org'
+    s.date          = Time.now.strftime '%Y-%m-%d'
+    s.require_path  = 'lib'
+    s.homepage      = "https://github.com/beoran/atto"
+    # s.platform    = Gem::Platform::CURRENT
+    s.files         = ["Rakefile"   , "README" ] +
+                       FileList["lib/atto.rb", "lib/atto/*.rb",
+                       "test/*.rb"  , "test/atto/*.rb" ].to_a
+    s.bindir        = "bin"
+    s.executables   = "atto"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+        pkg.need_zip = false
+        pkg.need_tar = false
+end
+
+
+task :test do
+  for file in FileList["test/*.rb"  , "test/atto/*.rb" ] do
+    puts("Running tests for #{file}:")
+    res = system("ruby -I lib #{file}")
+    puts res ? "OK!" : "Failed!"
+  end
+end
+
+task :default => :test
+

data/bin/atto

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'atto'
+
+Atto::Run.main

data/lib/atto/ansi.rb

@@ -0,0 +1,40 @@
+module Atto
+  # ANSI colors
+  module Ansi
+    extend self
+    
+    ATTRIBUTES = { 
+    :reset     => 0 , :bold     => 1 , :dark      => 2 , :underline => 4 ,
+    :blink     => 5 , :negative => 7 , :concealed => 8 , :black     => 30,
+    :red       => 31, :green    => 32, :yellow    => 33, :blue      => 34,
+    :magenta   => 35, :cyan     => 36, :white     => 37, :on_black  => 40,
+    :on_red    => 41, :on_green => 42, :on_yellow => 43, :on_blue   => 44,
+    :on_magenta=> 45, :on_cyan  => 46, :on_white  => 47,  }
+    
+    # Replaces symbols witch refer to ANSI escape codes with those escape codes.
+    def color(*args)
+      out = []
+      for arg in args
+        col = ATTRIBUTES[arg] 
+        if col  
+          out << "\e[#{col}m"
+        else
+          out << arg
+        end
+      end
+      out << "\e[0m"
+      return out
+    end
+    
+    # Replaces ansi codes and returns the joined string
+    def color_string(*args)
+      return color(*args).map { |e| e.to_s }.join
+    end   
+    
+    # puts output colored with ANSI escape codes
+    def puts(*args)
+      Kernel.puts(*self.color(*args))
+    end
+    
+  end
+end

data/lib/atto/run.rb

@@ -0,0 +1,93 @@
+module Atto
+  # Test autorunner
+  class Run
+    # Shortcut to run main
+    def self.main
+      return self.new.main
+    end
+    
+    # Find all Ruby all files under the named dir
+    def all_files(name)
+      return Dir.new(name).inject([]) do |res, e| 
+        full   = File.join(name, e)
+        if Dir.exist?(full) &&  e !='.' && e != '..'
+          res += all_files(full)
+        else
+          res << full if full =~ /\.rb\Z/
+        end
+        res
+      end
+    end
+    
+    # updates the timestamp info for files
+    def update_info(files)
+      return files.inject({}) do |res, name| 
+        stat      = File.stat(name)
+        res[name] = Struct.new(:mtime).new(stat.mtime)
+        res
+      end
+    end
+    
+    # matches libfiles wih testfiles
+    def match_files(libfiles, testfiles)
+      return libfiles.inject({}) do |res, libname| 
+        testname = libname.dup
+        where    = libname.rindex(File::Separator)
+        testname[where]= File::Separator + 'test_'
+        testname[File.join('','lib','')] = File.join('','test','')
+        res[libname] = testname if testfiles.member?(testname)
+        res
+      end
+    end
+    
+    # Runs a list of tests
+    def run_tests(list)
+      return list.inject({}) do |results, file|
+        puts("Running tests for #{file}:")
+        res = system("ruby -I #@libdir -I #@testdir #{file}")
+        puts res ? "OK!" : "Failed!"
+        results[file] = Time.now
+        results
+      end
+    end
+    
+    # Checks if a test file must run
+    def must_run(ran_tests, k, v)
+      ran_tests[k] ? ran_tests[k] <= v.mtime : true
+    end
+    
+    # updates all state info
+    def update_all
+      @libfiles  = all_files(@libdir)
+      @testfiles = all_files(@testdir)
+      @matchfiles= match_files(@libfiles, @testfiles)
+      @libinfo   = update_info(@libfiles)
+      @testinfo  = update_info(@testfiles)
+    end
+    
+    # Main, runs the tests when needed
+    def main
+      @projdir  = ARGV[0] || Dir.pwd
+      @libdir   = File.join(@projdir, ARGV[1] || 'lib')
+      @testdir  = File.join(@projdir, ARGV[2] || 'test')
+      update_all
+      @ran_tests = run_tests(@testfiles)
+      loop do
+        update_all
+        torun     = @testinfo.select do |k,v| 
+          must_run(@ran_tests, k, v)
+        end  
+        extra     = @libinfo.select  do |k,v| 
+          linked  = @matchfiles[k]
+          linked ? must_run(@ran_tests, linked, v) : false
+        end.map { |k,v| @matchfiles[k] }
+        run_tests(torun.keys + extra).each { |k,v| @ran_tests[k] = v }
+        sleep(1)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  Atto::Run.main
+end

data/lib/atto/test.rb

@@ -0,0 +1,80 @@
+require 'timeout'
+
+module Atto
+  # Tiny module for test driven development. Use with include Atto::Test.
+  module Test
+    extend self
+    @@failures, @@dots, @@messages = [], [], []
+    
+    # Returns the file and line of the calling context
+    def parse_stack(stack=caller)
+      return *(stack.first.match(/(.*):(\d+)/)[1..2])
+    end
+    
+    # Formats a message that reporst on any test failiures
+    def format_failure(message, stack = caller)
+      # file, line = 
+      return "(%s:%0.3d) %s" % [*parse_stack(stack), message]
+    end
+     
+    # Formats an exception backtrace to a string. 
+    def format_exception(raised, msg = "")
+      return msg + raised.to_s + "\n" + raised.backtrace.join("\n")
+    end
+    
+    # Creates a failiure for the given raised and result state
+    # Returns nil if no failure
+    def make_failure(res, raised, msg, stack)
+      return nil if res
+      if raised
+        return format_failure(msg || format_exception(raised, "Exception!\n"), stack)
+      end       
+      return format_failure(msg || "Assertion failed!", stack)
+    end
+    
+    # Makes a dot for the given raised and result state
+   def make_dot(res, raised)
+     return res ? '.' : ( raised ? 'E' : 'F')
+   end
+     
+   # Calls a block safely with a timeout
+   def run_block(delay = 10, &block)
+      res, raised = nil, nil
+      begin
+        Timeout.timeout(delay) do res = block.call ; end
+      rescue 
+        raised = $!
+      end
+      return res, raised 
+   end  
+    
+    # Test assertion. 
+    def assert(msg=nil, file=nil, line=nil, delay=10, stack=caller, &block)
+      res, raised = run_block(delay, &block)
+      @@dots     << make_dot(res, raised)
+      failure     = make_failure(res, raised, msg, stack)
+      @@failures << failure if failure
+      if msg         
+        @@messages << ( failure ?  msg + " (failed) " : msg)   
+      end
+      res
+    end
+
+    # Results of the tests
+    def self.results 
+      aid = @@dots.join + "\n" + @@failures.join("\n") + "\n"
+      col = @@failures.empty? ? :green : :red
+      aid << Atto::Ansi.color_string(col, "=" * 78)
+    end
+    
+    # Describes the tests
+    def self.describe_tests
+      @@messages.join(".\n") + ".\n"
+    end
+    
+    at_exit { 
+       puts results unless results.strip.empty?; 
+       exit @@failures.empty?
+    }
+  end
+end

data/lib/atto.rb

@@ -0,0 +1,9 @@
+# Atto is a tiny KISS library full of useful functionality for TDD and BDD.
+module Atto
+  # Ansi colors for red/green display after testing.
+  autoload :Ansi, 'atto/ansi'
+  # Testing
+  autoload :Test, 'atto/test'
+  # Autorunning tests
+  autoload :Run, 'atto/run'
+end 

data/test/atto/test_ansi.rb

@@ -0,0 +1,27 @@
+require 'atto'
+include Atto::Test
+
+assert("Ansi is defined") { Atto::Ansi }
+
+assert("Ansi::ATTRIBUTES  is defined") { Atto::Ansi::ATTRIBUTES }
+
+for attr, value in Atto::Ansi::ATTRIBUTES do
+  assert "Attribute #{attr} is colored correctly" do
+    Atto::Ansi.color(attr) == ["\e[#{value}m", "\e[0m"]
+  end
+end
+
+for attr, value in Atto::Ansi::ATTRIBUTES do
+  assert "Attribute with text #{attr} is colored correctly" do
+    Atto::Ansi.color(attr, "hello") == ["\e[#{value}m", "hello", "\e[0m"]
+  end
+end
+
+assert "Atto::Ansi#color_string works correctly" do
+  Atto::Ansi.color_string(:green, :on_yellow, "This works!") == 
+  "\e[32m\e[43mThis works!\e[0m"
+end
+
+assert "Atto::Ansi#puts works correctly" do
+  (Atto::Ansi.puts :green, :on_yellow, "This works!").nil?
+end

data/test/atto/test_test.rb

@@ -0,0 +1,22 @@
+require 'atto'
+include Atto::Test
+
+assert "Atto is defined"                        do Atto                      end 
+assert "Atto::Test is defined"                  do Atto::Test                end
+assert "Success can be detected"                do true                      end
+assert "Works with nexted asserts" do
+  assert "This is a nested assert"  do true end
+end
+
+assert "Works with empty description"           do assert  { true }          end
+
+assert "Nested asserts keep the return value" do
+  assert { 7 }  == 7
+end
+
+assert "Atto::Test#describe_tests is defined"   do Atto::Test.describe_tests end
+
+
+
+
+

data/test/test_atto.rb

@@ -0,0 +1,9 @@
+require 'atto'
+include Atto::Test
+
+assert { Atto } 
+assert { Atto::Ansi }
+assert { Atto::Test }
+# assert { Atto::Spec }
+
+

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: atto
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- Beoran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-07 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: "An ultra-tiny self-contained testing framework. "
+email: beoran@rubyforge.org
+executables: 
+- atto
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README
+- lib/atto.rb
+- lib/atto/ansi.rb
+- lib/atto/run.rb
+- lib/atto/test.rb
+- test/test_atto.rb
+- test/atto/test_ansi.rb
+- test/atto/test_test.rb
+- bin/atto
+has_rdoc: true
+homepage: https://github.com/beoran/atto
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An ultra-tiny self-contained testing framework.
+test_files: []
+