mac_bacon 1.1.21

data/Rakefile

@@ -0,0 +1,145 @@
+# Rakefile for Bacon.  -*-ruby-*-
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+
+desc "Run all the tests"
+task :default => [:test]
+
+desc "Do predistribution stuff"
+task :predist => [:chmod, :changelog, :rdoc]
+
+
+desc "Make an archive as .tar.gz"
+task :dist => [:test, :predist] do
+  sh "git archive --format=tar --prefix=#{release}/ HEAD^{tree} >#{release}.tar"
+  sh "pax -waf #{release}.tar -s ':^:#{release}/:' RDOX ChangeLog doc"
+  sh "gzip -f -9 #{release}.tar"
+end
+
+# Helper to retrieve the "revision number" of the git tree.
+def git_tree_version
+  if File.directory?(".git")
+    @tree_version ||= `git describe`.strip.sub('-', '.')
+    @tree_version << ".0"  unless @tree_version.count('.') == 2
+  else
+    #$: << "lib"
+    #require 'mac_bacon'
+    #@tree_version = Bacon::VERSION
+    @tree_version = "1.1"
+  end
+  @tree_version
+end
+
+def gem_version
+  git_tree_version.gsub(/-.*/, '')
+end
+
+def release
+  "macbacon-#{git_tree_version}"
+end
+
+def manifest
+  `git ls-files`.split("\n") - [".gitignore"]
+end
+
+
+desc "Make binaries executable"
+task :chmod do
+  Dir["bin/*"].each { |binary| File.chmod(0775, binary) }
+end
+
+desc "Generate a ChangeLog"
+task :changelog do
+  File.open("ChangeLog", "w") { |out|
+    `git log -z`.split("\0").map { |chunk|
+      author = chunk[/Author: (.*)/, 1].strip
+      date = chunk[/Date: (.*)/, 1].strip
+      desc, detail = $'.strip.split("\n", 2)
+      detail ||= ""
+      detail = detail.gsub(/.*darcs-hash:.*/, '')
+      detail.rstrip!
+      out.puts "#{date}  #{author}"
+      out.puts "  * #{desc.strip}"
+      out.puts detail  unless detail.empty?
+      out.puts
+    }
+  }
+end
+
+
+desc "Generate RDox"
+task "RDOX" do
+  sh "macruby -Ilib bin/macbacon --automatic --specdox >RDOX"
+end
+
+desc "Run all the tests"
+task :test do
+  sh "macruby -Ilib bin/macbacon --automatic --quiet"
+end
+
+
+begin
+  $" << "sources"  if defined? FromSrc
+  require 'rubygems'
+
+  require 'rake'
+  require 'rake/clean'
+  require 'rake/packagetask'
+  require 'rake/gempackagetask'
+  require 'fileutils'
+rescue LoadError
+  # Too bad.
+else
+  spec = Gem::Specification.new do |s|
+    s.name            = "mac_bacon"
+    s.version         = gem_version
+    s.platform        = Gem::Platform::RUBY
+    s.summary         = "a small RSpec clone for MacRuby"
+
+    s.description = <<-EOF
+Bacon is a small RSpec clone weighing less than 350 LoC but
+nevertheless providing all essential features.
+
+This MacBacon fork differs with regular Bacon in that it operates
+properly in a NSRunloop based environment. I.e. MacRuby/Objective-C.
+
+https://github.com/alloy/MacBacon
+    EOF
+
+    s.files           = manifest + %w(RDOX ChangeLog)
+    s.bindir          = 'bin'
+    s.executables     << 'macbacon'
+    s.require_path    = 'lib'
+    s.has_rdoc        = true
+    s.extra_rdoc_files = ['README', 'RDOX']
+    s.test_files      = []
+
+    s.author          = 'Eloy Durán'
+    s.email           = 'eloy.de.enige@gmail.com'
+    s.homepage        = 'https://github.com/alloy/MacBacon'
+  end
+
+  #task :gem => [:chmod, :changelog]
+  task :gem => [:chmod]
+
+  Rake::GemPackageTask.new(spec) do |p|
+    p.gem_spec = spec
+    p.need_tar = false
+    p.need_zip = false
+  end
+end
+
+desc "Generate RDoc documentation"
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.options << '--line-numbers' << '--inline-source' <<
+    '--main' << 'README' <<
+    '--title' << 'Bacon Documentation' <<
+    '--charset' << 'utf-8'
+  rdoc.rdoc_dir = "doc"
+  rdoc.rdoc_files.include 'README'
+  rdoc.rdoc_files.include 'COPYING'
+  rdoc.rdoc_files.include 'RDOX'
+  rdoc.rdoc_files.include('lib/mac_bacon.rb')
+end
+task :rdoc => ["RDOX"]

data/bin/macbacon

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+
+require 'optparse'
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib/')
+module Bacon; end
+
+automatic = false
+output = 'SpecDoxOutput'
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: macbacon [options] [files | -a] [-- untouched arguments]"
+
+  opts.separator ""
+  opts.separator "Ruby options:"
+
+  lineno = 1
+  opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
+    eval line, TOPLEVEL_BINDING, "-e", lineno
+    lineno += 1
+  }
+
+  opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
+    $DEBUG = true
+  }
+  opts.on("-w", "--warn", "turn warnings on for your script") {
+    $-w = true
+  }
+
+  opts.on("-I", "--include PATH",
+          "specify $LOAD_PATH (may be used more than once)") { |path|
+    $LOAD_PATH.unshift(*path.split(":"))
+  }
+
+  opts.on("-r", "--require LIBRARY",
+          "require the library, before executing your script") { |library|
+    require library
+  }
+
+  opts.separator ""
+  opts.separator "bacon options:"
+
+  opts.on("-s", "--specdox", "do AgileDox-like output (default)") {
+    output = 'SpecDoxOutput'
+  }
+  opts.on("-q", "--quiet",   "do Test::Unit-like non-verbose output") {
+    output = 'TestUnitOutput'
+  }
+  opts.on("-p", "--tap",     "do TAP (Test Anything Protocol) output") {
+    output = 'TapOutput'
+  }
+  opts.on("-k", "--knock",   "do Knock output") {
+    output = 'KnockOutput'
+  }
+
+  opts.on("-o", "--output FORMAT",
+          "do FORMAT (SpecDox/TestUnit/Tap) output") { |format|
+    output = format + "Output" 
+  }
+  opts.on("-Q", "--no-backtrace", "don't print backtraces") {
+    Bacon.const_set :Backtraces, false
+  }
+
+  opts.on("-a", "--automatic", "gather tests from ./test/, include ./lib/") {
+    $LOAD_PATH.unshift "lib"  if File.directory? "lib"
+    automatic = true
+  }
+
+  opts.on('-n', '--name NAME', String,
+          "runs tests matching regexp NAME") { |n|
+    Bacon.const_set :RestrictName, Regexp.new(n)
+  }
+  
+  opts.on('-t', '--testcase TESTCASE', String,
+          "runs tests in TestCases matching regexp TESTCASE") { |t|
+    Bacon.const_set :RestrictContext, Regexp.new(t)
+  }
+
+  opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("--version", "Show version") do
+    require 'mac_bacon'
+    puts "bacon #{Bacon::VERSION}"
+    exit
+  end
+
+  opts.parse! ARGV
+}
+
+files = ARGV
+
+if automatic
+  files.concat Dir["test/**/test_*.rb"]
+  files.concat Dir["test/**/spec_*.rb"]
+  files.concat Dir["spec/**/spec_*.rb"]
+  files.concat Dir["spec/**/*_spec.rb"]
+end
+
+if files.empty?
+  puts opts.banner
+  exit 1
+end
+
+require 'mac_bacon'
+
+Bacon.extend Bacon.const_get(output) rescue abort "No such formatter: #{output}"
+
+files.each { |file|
+  load file
+}
+
+Bacon.run

data/lib/mac_bacon.rb

@@ -0,0 +1,450 @@
+# Bacon -- small RSpec clone.
+#
+# "Truth will sooner come out from error than from confusion." ---Francis Bacon
+
+# Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+#
+# Bacon is freely distributable under the terms of an MIT-style license.
+# See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+framework "Cocoa"
+
+module Bacon
+  VERSION = "1.1"
+
+  Counter = Hash.new(0)
+  ErrorLog = ""
+  Shared = Hash.new { |_, name|
+    raise NameError, "no such context: #{name.inspect}"
+  }
+
+  RestrictName    = //  unless defined? RestrictName
+  RestrictContext = //  unless defined? RestrictContext
+
+  Backtraces = true  unless defined? Backtraces
+
+  module SpecDoxOutput
+    def handle_specification_begin(name)
+      puts spaces + name
+    end
+
+    def handle_specification_end
+      puts if Counter[:context_depth] == 1
+    end
+
+    def handle_requirement_begin(description)
+      print "#{spaces}  - #{description}"
+    end
+
+    def handle_requirement_end(error)
+      puts error.empty? ? "" : " [#{error}]"
+    end
+
+    def handle_summary
+      print ErrorLog  if Backtraces
+      puts "%d specifications (%d requirements), %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+
+    def spaces
+      "  " * (Counter[:context_depth] - 1)
+    end
+  end
+
+  module TestUnitOutput
+    def handle_specification_begin(name); end
+    def handle_specification_end        ; end
+
+    def handle_requirement_begin(description) end
+    def handle_requirement_end(error)
+      if error.empty?
+        print "."
+      else
+        print error[0..0]
+      end
+    end
+
+    def handle_summary
+      puts "", "Finished in #{Time.now - @timer} seconds."
+      puts ErrorLog  if Backtraces
+      puts "%d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  module TapOutput
+    def handle_specification_begin(name); end
+    def handle_specification_end        ; end
+
+    def handle_requirement_begin(description)
+      ErrorLog.replace ""
+    end
+
+    def handle_requirement_end(error)
+      if error.empty?
+        puts "ok %-3d - %s" % [Counter[:specifications], description]
+      else
+        puts "not ok %d - %s: %s" %
+          [Counter[:specifications], description, error]
+        puts ErrorLog.strip.gsub(/^/, '# ')  if Backtraces
+      end
+    end
+
+    def handle_summary
+      puts "1..#{Counter[:specifications]}"
+      puts "# %d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  module KnockOutput
+    def handle_specification_begin(name); end
+    def handle_specification_end        ; end
+
+    def handle_requirement_begin(description)
+      ErrorLog.replace ""
+    end
+
+    def handle_requirement_end(error)
+      if error.empty?
+        puts "ok - %s" % [description]
+      else
+        puts "not ok - %s: %s" % [description, error]
+        puts ErrorLog.strip.gsub(/^/, '# ')  if Backtraces
+      end
+    end
+
+    def handle_summary;  end
+  end
+
+  extend SpecDoxOutput          # default
+
+  class Error < RuntimeError
+    attr_accessor :count_as
+
+    def initialize(count_as, message)
+      @count_as = count_as
+      super message
+    end
+  end
+
+  class Specification
+    attr_reader :description
+
+    def initialize(context, description, block, before_filters, after_filters)
+      @context, @description, @block = context, description, block
+      @before_filters, @after_filters = before_filters.dup, after_filters.dup
+
+      @postponed_blocks_count = 0
+      @exception_occurred = false
+      @error = ""
+    end
+
+    def run_before_filters
+      @before_filters.each { |f| @context.instance_eval(&f) }
+    end
+
+    def run_after_filters
+      @after_filters.each { |f| @context.instance_eval(&f) }
+    end
+
+    def run
+      Bacon.handle_requirement_begin(@description)
+      execute_block do
+        Counter[:depth] += 1
+        run_before_filters
+        @number_of_requirements_before = Counter[:requirements]
+        @context.instance_eval(&@block)
+      end
+
+      finalize if @postponed_blocks_count == 0
+    end
+
+    def postpone_block(seconds, &block)
+      # If an exception occurred, we definitely don't need to schedule any more blocks
+      unless @exception_occurred
+        @postponed_blocks_count += 1
+        performSelector("run_postponed_block:", withObject:block, afterDelay:seconds)
+      end
+    end
+
+    def run_postponed_block(block)
+      # If an exception occurred, we definitely don't need execute any more blocks
+      execute_block(&block) unless @exception_occurred
+      @postponed_blocks_count -= 1
+      finalize if @postponed_blocks_count == 0
+    end
+
+    def finalize
+      if Counter[:requirements] == @number_of_requirements_before
+        # the specification did not contain any requirements, so it flunked
+        # TODO ugh, exceptions for control flow, need to clean this up
+        execute_block { raise Error.new(:missing, "empty specification: #{@context.name} #{@description}") }
+      end
+
+      execute_block { run_after_filters }
+
+      Counter[:depth] -= 1
+      Bacon.handle_requirement_end(@error)
+      @context.specification_did_finish(self)
+    end
+
+    def execute_block
+      begin
+        yield
+      rescue Object => e
+        @exception_occurred = true
+
+        ErrorLog << "#{e.class}: #{e.message}\n"
+        e.backtrace.find_all { |line| line !~ /bin\/bacon|\/bacon\.rb:\d+/ }.
+          each_with_index { |line, i|
+          ErrorLog << "\t#{line}#{i==0 ? ": #{@context.name} - #{@description}" : ""}\n"
+        }
+        ErrorLog << "\n"
+
+        @error = if e.kind_of? Error
+          Counter[e.count_as] += 1
+          e.count_as.to_s.upcase
+        else
+          Counter[:errors] += 1
+          "ERROR: #{e.class}"
+        end
+      end
+    end
+  end
+
+  def self.add_context(context)
+    (@contexts ||= []) << context
+  end
+
+  def self.current_context_index
+    @current_context_index ||= 0
+  end
+
+  def self.current_context
+    @contexts[current_context_index]
+  end
+
+  def self.run
+    @timer ||= Time.now
+    Counter[:context_depth] += 1
+    handle_specification_begin(current_context.name)
+    current_context.performSelector("run", withObject:nil, afterDelay:0)
+    NSApplication.sharedApplication.run
+  end
+
+  def self.context_did_finish(context)
+    handle_specification_end
+    Counter[:context_depth] -= 1
+    if (@current_context_index + 1) < @contexts.size
+      @current_context_index += 1
+      run
+    else
+      # DONE
+      handle_summary
+      NSApplication.sharedApplication.terminate(self)
+    end
+  end
+
+  class Context
+    attr_reader :name, :block
+    
+    def initialize(name, before = nil, after = nil, &block)
+      @name = name
+      @before, @after = (before ? before.dup : []), (after ? after.dup : [])
+      @block = block
+      @specifications = []
+      @current_specification_index = 0
+
+      Bacon.add_context(self)
+
+      instance_eval(&block)
+    end
+
+    def run
+      # TODO
+      #return  unless name =~ RestrictContext
+      if spec = current_specification
+        spec.performSelector("run", withObject:nil, afterDelay:0)
+      else
+        Bacon.context_did_finish(self)
+      end
+    end
+
+    def current_specification
+      @specifications[@current_specification_index]
+    end
+
+    def specification_did_finish(spec)
+      if (@current_specification_index + 1) < @specifications.size
+        @current_specification_index += 1
+        run
+      else
+        Bacon.context_did_finish(self)
+      end
+    end
+
+    def before(&block); @before << block; end
+    def after(&block);  @after << block; end
+
+    def behaves_like(*names)
+      names.each { |name| instance_eval(&Shared[name]) }
+    end
+
+    def it(description, &block)
+      return  unless description =~ RestrictName
+      block ||= lambda { should.flunk "not implemented" }
+      Counter[:specifications] += 1
+      @specifications << Specification.new(self, description, block, @before, @after)
+    end
+    
+    def should(*args, &block)
+      if Counter[:depth]==0
+        it('should '+args.first,&block)
+      else
+        super(*args,&block)
+      end
+    end
+
+    def describe(*args, &block)
+      context = Bacon::Context.new(args.join(' '), @before, @after, &block)
+      (parent_context = self).methods(false).each {|e|
+        class<<context; self end.send(:define_method, e) {|*args| parent_context.send(e, *args)}
+      }
+      context
+    end
+
+    def wait(seconds, &block)
+      current_specification.postpone_block(seconds, &block)
+    end
+
+    def raise?(*args, &block); block.raise?(*args); end
+    def throw?(*args, &block); block.throw?(*args); end
+    def change?(*args, &block); block.change?(*args); end
+  end
+end
+
+
+class Object
+  def true?; false; end
+  def false?; false; end
+end
+
+class TrueClass
+  def true?; true; end
+end
+
+class FalseClass
+  def false?; true; end
+end
+
+class Proc
+  def raise?(*exceptions)
+    call
+  rescue *(exceptions.empty? ? RuntimeError : exceptions) => e
+    e
+  else
+    false
+  end
+
+  def throw?(sym)
+    catch(sym) {
+      call
+      return false
+    }
+    return true
+  end
+
+  def change?
+    pre_result = yield
+    called = call
+    post_result = yield
+    pre_result != post_result
+  end
+end
+
+class Numeric
+  def close?(to, delta)
+    (to.to_f - self).abs <= delta.to_f  rescue false
+  end
+end
+
+
+class Object
+  def should(*args, &block)    Should.new(self).be(*args, &block)         end
+end
+
+module Kernel
+  private
+  def describe(*args, &block) Bacon::Context.new(args.join(' '), &block)  end
+  def shared(name, &block)    Bacon::Shared[name] = block                 end
+end
+
+class Should
+  # Kills ==, ===, =~, eql?, equal?, frozen?, instance_of?, is_a?,
+  # kind_of?, nil?, respond_to?, tainted?
+  instance_methods.each { |name| undef_method name  if name =~ /\?|^\W+$/ }
+
+  def initialize(object)
+    @object = object
+    @negated = false
+  end
+
+  def not(*args, &block)
+    @negated = !@negated
+
+    if args.empty?
+      self
+    else
+      be(*args, &block)
+    end
+  end
+
+  def be(*args, &block)
+    if args.empty?
+      self
+    else
+      block = args.shift  unless block_given?
+      satisfy(*args, &block)
+    end
+  end
+
+  alias a  be
+  alias an be
+
+  def satisfy(*args, &block)
+    if args.size == 1 && String === args.first
+      description = args.shift
+    else
+      description = ""
+    end
+
+    r = yield(@object, *args)
+    if Bacon::Counter[:depth] > 0
+      Bacon::Counter[:requirements] += 1
+      raise Bacon::Error.new(:failed, description)  unless @negated ^ r
+      r
+    else
+      @negated ? !r : !!r
+    end
+  end
+
+  def method_missing(name, *args, &block)
+    name = "#{name}?"  if name.to_s =~ /\w[^?]\z/
+
+    desc = @negated ? "not " : ""
+    desc << @object.inspect << "." << name.to_s
+    desc << "(" << args.map{|x|x.inspect}.join(", ") << ") failed"
+
+    satisfy(desc) { |x| x.__send__(name, *args, &block) }
+  end
+
+  def equal(value)         self == value      end
+  def match(value)         self =~ value      end
+  def identical_to(value)  self.equal? value  end
+  alias same_as identical_to
+
+  def flunk(reason="Flunked")
+    raise Bacon::Error.new(:failed, reason)
+  end
+end