peck 0.1.0

data/COPYING

@@ -0,0 +1,21 @@
+Copyright (c)
+  2007 - 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+  2011 - 2012 Eloy Durán <eloy.de.enige@gmail.com>
+  2012        Manfred Stienstra, Fingertips <manfred@fngtps.com>
+
+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,127 @@
+# Peck
+
+Peck is a concurrent spec framework.
+
+[![Build Status](https://secure.travis-ci.org/Fingertips/Peck.png?branch=master)](http://travis-ci.org/Fingertips/Peck)
+
+## Getting Started
+
+You can install Peck as a gem.
+
+    $ gem install peck
+
+Write a little test.
+
+    require 'peck/flavors/vanilla'
+
+    describe MicroMachine do
+      it "drives really fast" do
+        MicroMachine.should.drives(:fast)
+      end
+    end
+
+And enjoy the output.
+
+    ruby -rubygems spec/micro_machine_spec.rb -e ''
+    .
+    1 spec, 0 failures, finished in 0.0 seconds.
+
+## Why another framework/test library/spec language?
+
+I guess that's something you will have to find out for yourself. For us a spec
+framework needs two things: a good way to describe intention of the specs and
+flexibility to work with the different types of project we work on.
+
+We really like Bacon and test/spec but we've found that they're to limiting
+in some of our projects. Bacon doesn't work really well with Rails and
+test/spec needs test/unit, which will be gone in Ruby 1.9.
+
+In some projects we find that we have an enormous amount of little specs which
+beg to be run concurrently.
+
+Peck tries to be what we, and maybe you, need it to be. Within reason of
+course.
+
+### Peck can be concurrent
+
+Peck has two run modes: serial and concurrent. Right now that's a global
+setting for the whole suite.
+
+    Peck.concurrency = 9
+
+Some projects don't allow concurrency because either the code or the test
+suite aren't thread safe. We've also found that some suites actually run
+slower in threads.
+
+### Peck can host your own spec syntax
+
+When implementing your own spec syntax you only have to add expectations
+to a little accessor when they run and raise Peck::Error when something
+fails.
+
+    describe "Fish" do
+      it "breathes with water" do
+        # If you don't like .should, you can write your own assertion
+        # DSL
+        expects {
+          Fish.breathes == water
+        }
+      end
+    end
+
+With a bit of work you could make Peck run your Rspec tests.
+
+### Peck has a pluggable notification system
+
+You can write your own notifiers and register them with Peck's delegate
+system.
+
+    class Remotifier < Peck::Notifiers::Base
+      def finished
+        HTTP.post("https://ci.lan/runs?ran=#{Peck.counter.ran}" +
+          "&failures=#{Peck.counter.failed}")
+      end
+    end
+    Remotifier.use
+
+### Peck is extensible
+
+Expect opening up Peck classes you can also extend during runtime with the
+`once` callback. This callback is ran when a new context (describe) is
+created.
+
+    Peck::Context.once do |context|
+      context.class_eval do
+        attr_accessor :controller_class
+
+        before do
+          @controller = controller_class.new
+        end
+      emd
+    end
+
+## Documentation
+
+Peck is still very much in flux and will probably change a lot in the coming
+months. Currently we support a small number of assertions:
+
+  * should, should.not, and should.be
+  * should.equal
+  * should.raise([exception]) { }
+  * should.change([expression]) { }
+  * should.satisfy { |object| }
+
+If you want to learn more you're probably best of reading the code
+documentation.
+
+## Copying
+
+Peck inherits a lot of ideas, concepts and even some implementation from both
+Bacon and MacBacon. Both of these projects have been released under the terms
+of an MIT-style license.
+
+Copyright (C) 2007 - 2012 Christian Neukirchen http://purl.org/net/chneukirchen
+Copyright (C) 2011 - 2012 Eloy Durán eloy.de.enige@gmail.com
+Copyright (C) 2012        Manfred Stienstra, Fingertips <manfred@fngtps.com>
+
+Peck is freely distributable under the terms of an MIT-style license. See COPYING or http://www.opensource.org/licenses/mit-license.php.

data/lib/peck/context.rb

@@ -0,0 +1,106 @@
+class Peck
+  class Context
+    attr_reader :specification
+
+    def initialize(specification)
+      @specification = specification
+    end
+
+    def describe(*args, &block)
+      self.class.describe(*args, &block)
+    end
+
+    class << self
+      FILENAME_WITHOUT_LINE_RE = /^(.+?):\d+/
+      
+      attr_reader :description, :block, :specs, :source_file
+      attr_accessor :timeout
+
+      def init(before, after, *description, &block)
+        # Find the first file in the backtrace which is not this file
+        source_file = caller.find { |line| line[0,__FILE__.size] != __FILE__ }
+        if source_file
+          source_file = source_file.match(FILENAME_WITHOUT_LINE_RE)[1]
+          source_file = File.expand_path(source_file)
+        else
+          log("Unable to determine the file in which the context is defined.")
+        end
+
+        context = Class.new(self) do
+          @before      = before.dup
+          @after       = after.dup
+          @source_file = source_file
+          @description = description
+          @block       = block
+          @specs       = []
+        end
+
+        if @setup
+          @setup.each { |b| b.call(context) }
+        end
+
+        Peck.contexts << context
+        context.class_eval(&block)
+        context
+      end
+
+      def label
+        Peck.join_description(description)
+      end
+
+      def describe(*description, &block)
+        if Peck.context_selector.match(Peck.join_description(*description))
+          init(@before, @after, *description, &block)
+        end
+      end
+      
+      # Is only ran once for every context when it's initialized. Great place
+      # to hook in test suite specific functionality.
+      #
+      #   Peck::Context.once { |context| context.before { @name = 'Mary' } }
+      def once(&block)
+        @setup ||= []
+        @setup << block
+      end
+      
+      def before(*args, &block)
+        add_callback(@before, *args, &block)
+      end
+      alias setup before
+
+      def after(*args, &block)
+        add_callback(@after, *args, &block)
+      end
+      alias teardown after
+
+      private
+
+      def add_callback(chain, *args, &block)
+        args.each do |method|
+          Peck.log("Adding method `#{method}' to callback chain")
+          chain << Proc.new { send(method) }
+        end
+        if block_given?
+          chain << block
+        end
+      end
+    end
+  end
+
+  PECK_PART_RE = /Peck/
+  def self.join_description(description)
+    description.map do |part|
+      part = part.to_s
+      part = nil if part =~ PECK_PART_RE
+      part
+    end.compact.join(' ')
+  end
+end
+
+module Kernel
+  private
+
+  def describe(*description, &block)
+    Peck::Context.init([], [], *description, &block)
+  end
+end

data/lib/peck/counter.rb

@@ -0,0 +1,48 @@
+class Peck
+  class << self
+    attr_accessor :counter
+  end
+
+  class Counter
+    def self.instance
+      @instance ||= new
+    end
+
+    attr_accessor :ran, :passed, :failed, :pending, :missing, :events
+
+    def initialize
+      @ran = @passed = @failed = 0
+      @pending = []
+      @missing = []
+      @events  = []
+      $stdout.sync = true
+    end
+
+    def finished_specification(spec)
+      @ran += 1
+      if spec.passed?
+        @passed += 1
+      elsif spec.failed?
+        @failed += 1
+      end
+    end
+
+    def received_pending(label)
+      @pending << label
+    end
+
+    def received_missing(spec)
+      @missing << spec
+    end
+
+    def received_exception(spec, exception)
+      @events << exception
+    end
+  end
+
+  self.counter = Counter.instance
+
+  if respond_to?(:delegates)
+    self.delegates << self.counter
+  end
+end

data/lib/peck/debug.rb

@@ -0,0 +1,14 @@
+class Peck
+  def self.logger
+    @logger ||= begin
+      require 'logger'
+      logger = Logger.new($stdout)
+      logger.formatter = Logger::Formatter.new
+      logger
+    end
+  end
+
+  def self.log(message)
+    logger.debug(message)
+  end
+end

data/lib/peck/delegates.rb

@@ -0,0 +1,44 @@
+require 'set'
+
+class Peck
+  class Delegates < Set
+    def self.instance
+      @instance ||= new
+    end
+
+    MESSAGES = %w(
+      started
+      finished
+      started_specification
+      finished_specification
+      received_missing
+      received_exception
+    ).freeze
+
+    def supported_messages
+      MESSAGES
+    end
+
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if supported_messages.include?(method)
+        each do |delegate|
+          if delegate.respond_to?(method)
+            delegate.send(method, *args, &block)
+          end
+        end
+      else
+        super
+      end
+    end
+  end
+
+  class << self
+    # This can be used by a `client' to receive status updates.
+    #
+    #   Peck.delegates << Notifier.new
+    attr_reader :delegates
+  end
+
+  @delegates = Peck::Delegates.instance
+end

data/lib/peck/error.rb

@@ -0,0 +1,14 @@
+class Peck
+  class Error < RuntimeError
+    attr_accessor :type
+
+    def initialize(type, message)
+      @type = type.to_s
+      super message
+    end
+
+    def count_as?(type)
+      @type == type.to_s
+    end
+  end
+end

data/lib/peck/expectations.rb

@@ -0,0 +1,115 @@
+require 'peck/error'
+
+class Peck
+  class Should
+    # Kills ==, ===, =~, eql?, equal?, frozen?, instance_of?, is_a?,
+    # kind_of?, nil?, respond_to?, tainted?
+    KILL_METHODS_RE = /\?|^\W+$/
+    instance_methods.each do |name|
+      undef_method(name) if name =~ KILL_METHODS_RE
+    end
+
+    def initialize(this)
+      @this = this
+      @negated = false
+      Thread.current['peck-spec'].expectations << self
+    end
+
+    def not
+      @negated = !@negated
+      self
+    end
+
+    def be(*args, &block)
+      if args.empty?
+        self
+      else
+        block = args.shift unless block_given?
+        satisfy(*args, &block)
+      end
+    end
+
+    def satisfy(*args, &block)
+      if args.size == 1 && String === args.first
+        description = args.shift
+      else
+        description = ""
+      end
+
+      result = yield(@this, *args)
+      unless @negated ^ result
+        Kernel.raise Peck::Error.new(:failed, description)
+      end
+      result
+    end
+
+    def change(expression, change=nil)
+      if @negated
+        description = "#{expression} changed"
+        description << " by #{actual}" if change
+      else
+        description = "#{expression} didn't change"
+        description << " by #{change}" if change
+      end
+
+      satisfy(description) do |x|
+        difference = change || 1
+        binding = x.send(:binding)
+
+        before = eval(expression, binding)
+        result = @this.call
+        after = eval(expression, binding)
+
+        after == before + difference
+      end
+    end
+
+    def raise(exception_class=nil)
+      exception = nil
+      begin
+        @this.call
+      rescue Exception => e
+        exception = e
+      end
+
+      description = if exception_class
+        if @negated
+          "expected `#{exception_class}' to not be raised"
+        else
+          "expected `#{exception_class}' to be raised, but got a `#{exception.class}'"
+        end
+      else
+        if @negated
+          "expected nothing to be raised, but got `#{exception.inspect}'"
+        else
+          "expected an exception, but nothing was raised"
+        end
+      end
+
+      satisfy(description) do
+        if exception_class
+          exception.kind_of?(exception_class)
+        else
+          !exception.nil?
+        end
+      end
+    end
+
+    PREDICATE_METHOD_RE = /\w[^?]\z/
+    def method_missing(name, *args, &block)
+      name = "#{name}?" if name.to_s =~ PREDICATE_METHOD_RE
+
+      desc = @negated ? "not " : ""
+      desc << @this.inspect << "." << name.to_s
+      desc << "(" << args.map{|x|x.inspect}.join(", ") << ") failed"
+
+      satisfy(desc) { |x| x.__send__(name, *args, &block) }
+    end
+  end
+end
+
+class Object
+  def should(*args, &block)
+    Peck::Should.new(self).be(*args, &block)
+  end
+end

data/lib/peck/flavors/quiet.rb

@@ -0,0 +1,8 @@
+require 'peck'
+require 'peck/delegates'
+require 'peck/counter'
+require 'peck/context'
+require 'peck/specification'
+require 'peck/expectations'
+
+Peck.run_at_exit

data/lib/peck/flavors/vanilla.rb

@@ -0,0 +1,10 @@
+require 'peck'
+require 'peck/delegates'
+require 'peck/counter'
+require 'peck/context'
+require 'peck/specification'
+require 'peck/expectations'
+require 'peck/notifiers/default'
+
+Peck::Notifiers::Default.use
+Peck.run_at_exit

data/lib/peck/notifiers/base.rb

@@ -0,0 +1,39 @@
+class Peck
+  class Notifiers
+    class Base
+      # When a file starts with this path, it's in the Peck library
+      PECK_PATH = File.expand_path('../../../../', __FILE__)
+
+      # Matches: `block (2 levels) in <top (required)>'
+      ANONYMOUS_BLOCK_RE = /`block/
+
+      def self.use
+        @instance ||= begin
+          notifier = new
+          notifier.install_at_exit
+          Peck.delegates << notifier
+          notifier
+        end
+      end
+
+      protected
+
+      def pluralize(count, stem)
+        count == 1 ? stem : "#{stem}s"
+      end
+
+      def clean_backtrace(backtrace)
+        stripped = []
+        backtrace.each do |line|
+          if line.start_with?(PECK_PATH) || line.start_with?("<")
+          elsif line =~ ANONYMOUS_BLOCK_RE
+            stripped << line.split(':')[0,2].join(':')
+          else
+            stripped << line
+          end
+        end
+        stripped.empty? ? backtrace : stripped
+      end
+    end
+  end
+end

data/lib/peck/notifiers/default.rb

@@ -0,0 +1,68 @@
+require 'peck/notifiers/base'
+
+class Peck
+  class Notifiers
+    class Default < Peck::Notifiers::Base
+      def initialize
+        @started_at = @finished_at = Time.now
+      end
+
+      def started
+        @started_at = Time.now
+      end
+
+      def finished
+        @finished_at = Time.now
+      end
+
+      def finished_specification(spec)
+        if spec.passed?
+          $stdout.write('.')
+        elsif spec.failed?
+          $stdout.write('f')
+        end
+      end
+
+      def write_exeception(number, event)
+        puts "  #{number}) #{event.spec.label}\n\n"
+        backtrace = clean_backtrace(event.exception.backtrace)
+        puts "  #{event.exception.message}\n\n\t#{backtrace.join("\n\t")}\n\n"
+      end
+      
+      def write_event(number, event)
+        case event.exception
+        when Exception
+          write_exeception(number, event)
+        else
+          raise ArgumentError, "Don't know how to display event `#{event.expectation.class.name}'"
+        end
+      end
+
+      def write_events
+        Peck.all_events.each_with_index do |event, index|
+          number = index + 1
+          write_event(number, event)
+        end
+      end
+
+      def runtime_in_seconds
+        runtime = @finished_at - @started_at
+        (runtime * 100).round / 100.0
+      end
+
+      def write_stats
+        puts "#{Peck.counter.ran} #{pluralize(Peck.counter.ran, 'spec')}, #{Peck.counter.failed} #{pluralize(Peck.counter.failed, 'failure')}, finished in #{runtime_in_seconds} seconds."
+      end
+
+      def write
+        puts if Peck.counter.ran > 0
+        write_events
+        write_stats
+      end
+
+      def install_at_exit
+        at_exit { write }
+      end
+    end
+  end
+end

data/lib/peck/specification.rb

@@ -0,0 +1,85 @@
+class Peck
+  class Context
+    def self.it(description, &block)
+      return unless Peck.spec_selector.match(label)
+      specification = Specification.new(self, @before, @after, description, &block)
+      @specs << specification
+      specification
+    end
+
+    def self.pending(description)
+      return unless Peck.spec_selector.match(label)
+      delegates.received_pending(description)
+    end
+  end
+
+  class Event
+    attr_accessor :exception, :spec
+
+    def initialize(exception, spec)
+      @exception = exception
+      @spec = spec
+    end
+  end
+
+  class Specification
+    attr_reader :description, :context
+    attr_reader :expectations, :events
+
+    def initialize(context, before, after, description, &block)
+      @context      = context.new(self)
+      @before       = before.dup
+      @after        = after.dup
+      @description  = description
+      @block        = block
+
+      @expectations = []
+      @events       = []
+    end
+
+    def label
+      "#{@context.class.label} #{@description}"
+    end
+
+    def synchronized(&block)
+      if semaphore = Thread.current['peck-semaphore']
+        semaphore.synchronize(&block)
+      else
+        block.call
+      end
+    end
+
+    def run
+      if @block
+        @before.each { |cb| @context.instance_eval(&cb) }
+        begin
+          synchronized do
+            Thread.current['peck-spec'] = self
+            @context.instance_eval(&@block)
+            Thread.current['peck-spec'] = nil
+          end
+          Peck.delegates.received_missing(self) if empty?
+        ensure
+          @after.each { |cb| @context.instance_eval(&cb) }
+        end
+      else
+        Peck.delegates.received_missing(self)
+      end
+    rescue Object => e
+      Peck.delegates.received_exception(self, e)
+      @events << Event.new(e, self)
+    end
+
+    def empty?
+      @expectations.empty?
+    end
+
+    def failed?
+      !@events.empty?
+    end
+
+    def passed?
+      !failed? && !empty?
+    end
+  end
+end

data/lib/peck.rb

@@ -0,0 +1,124 @@
+class Peck
+  VERSION = "0.1.0"
+  
+  class << self
+    # Returns all the defined contexts.
+    attr_reader :contexts
+
+    # Used to select which contexts should be run. The match method will be
+    # called on these with the label of the context as argument. You can use
+    # a regular expression or a custom class to match what needs to be run.
+    #
+    #   module ContextMatcher
+    #     def self.match(label)
+    #       label =~ /^Birds/
+    #     end
+    #   end
+    #   Peck.context_selector = ContextMatcher
+    attr_accessor :context_selector
+
+    # Used to select which specs should be run. See Peck.select_context
+    # for more information.
+    attr_accessor :spec_selector
+
+    # Sets the level of concurrency.
+    attr_accessor :concurrency
+  end
+
+  # A no-op unless you require 'peck/debug'
+  def self.log(message)
+  end
+
+  # Returns true if the suite should run concurrent.
+  def self.concurrent?
+    concurrency && concurrency > 1
+  end
+
+  def self.reset!
+    @contexts = []
+  end
+
+  @context_selector = //
+  @spec_selector = //
+
+  reset!
+
+  def self.all_specs
+    contexts.inject([]) do |all, context|
+      all.concat(context.specs)
+    end
+  end
+
+  def self.all_events
+    contexts.inject([]) do |all, context|
+      context.specs.inject(all) do |events, spec|
+        events.concat(spec.events)
+      end
+    end
+  end
+
+  def self.run
+    delegates.started
+    concurrent? ? run_concurrent : run_serial
+    delegates.finished
+  end
+
+  def self.run_at_exit
+    at_exit do
+      run
+      exit Peck.counter.failed
+    end
+  end
+
+  def self.run_serial
+    Peck.log("Running specs in serial")
+    Thread.current['peck-semaphore'] = Mutex.new
+    contexts.each do |context|
+      context.specs.each do |specification|
+        delegates.started_specification(specification)
+        specification.run
+        delegates.finished_specification(specification)
+      end
+    end
+  rescue Exception => e
+    log("An error bubbled up from the context, this should never happen and is possibly a bug.")
+    raise e
+  end
+
+  def self.run_concurrent
+    Peck.log("Running specs concurrently")
+    current_spec = -1
+    specs = all_specs
+    threaded do |nr|
+      Thread.current['peck-semaphore'] = Mutex.new
+      loop do
+        spec_index = Thread.exclusive { current_spec += 1 }
+        if specification = specs[spec_index]
+          delegates.started_specification(specification)
+          specification.run
+          delegates.finished_specification(specification)
+        else
+          break
+        end
+      end
+    end
+
+    delegates.finished
+  end
+
+  def self.threaded
+    threads = []
+    Peck.concurrency.times do |nr|
+      threads[nr] = Thread.new do
+        yield nr
+      end
+    end
+
+    threads.compact.each do |thread|
+      begin
+        thread.join
+      rescue Interrupt
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: peck
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Manfred Stienstra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-26 00:00:00.000000000 Z
+dependencies: []
+description: ! '    Concurrent spec framework.
+
+'
+email: manfred@fngtps.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- COPYING
+files:
+- lib/peck/context.rb
+- lib/peck/counter.rb
+- lib/peck/debug.rb
+- lib/peck/delegates.rb
+- lib/peck/error.rb
+- lib/peck/expectations.rb
+- lib/peck/flavors/quiet.rb
+- lib/peck/flavors/vanilla.rb
+- lib/peck/notifiers/base.rb
+- lib/peck/notifiers/default.rb
+- lib/peck/specification.rb
+- lib/peck.rb
+- COPYING
+- README.md
+homepage: 
+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
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Peck is a concurrent spec framework which inherits a lot from the fabulous
+  Bacon and MacBacon. We call it a framework because it was designed to be used in
+  parts and is easily extended.
+test_files: []