speccify 0.3.0

data/README.markdown

@@ -0,0 +1,269 @@
+# Speccify
+
+## A lightweight alternative to RSpec.
+
+
+
+## Features:
+
+### Nested Contexts
+
+### Custom matchers are no-brainers with def_matcher
+
+### Blazing Fast
+
+### 100% Ruby 1.9 and 1.8 compatible
+
+### Rails out of the box!
+
+### Sophisticated Expectations/Matchers System
+
+### < 300 LOC 
+
+
+
+## Install Speccify:
+
+> sudo gem install speccify
+
+## Using Speccify
+
+Create a testfile:
+    
+			# test_object.rb  
+			
+			require "rubygems"  
+			require "speccify"  
+
+			describe Object do  
+			  before do  
+			    @obj = Object.new  
+			  end 
+			
+			  it "is not nil" do
+			    @obj.should_not be_nil
+			  end
+			  
+			  it "can be frozen" do
+			    @obj.freeze
+			    @obj.should be_frozen
+			  end
+			end
+			
+Run it with the ruby command:
+			
+> $ ruby test_object.rb   
+>Loaded suite -  
+>Started  
+>..  
+>Finished in 0.001820 seconds.  
+> 
+>2 tests, 2 assertions, 0 failures, 0 errors
+
+
+## Using Speccify with autotest
+
+1. Name your testfiles test_whatever.rb
+2. Start autotest
+3. There is no step three ...
+
+## Using Speccify with Rails
+
+Use the default rails test directory/structure, testhelpers, assertions and infrastructure.
+
+1. sudo use_minitest yes
+2. require 'speccify' in test_helper.rb
+3. There is no step three ...
+
+Tell Speccify what kind of test he is, by passing one of the following options to the describe method:
+
+* :type => ActiveSupport::TestCase 
+* :type => ActionController::TestCase 
+* :type => ActionMailer::TestCase 
+* :type => ActionView::TestCase 
+
+### Example, Functional Test:
+
+		describe HorstsController, :type => ActionController::TestCase do
+		  it "should get index" do
+		    get :index
+		    @response.should be_success
+		    assigns(:horsts).should_not be_nil
+		  end
+			describe "Whatever" do
+			  # I'm still a ActionController::TestCase
+			  it "should get index" do
+			    get :index
+			    @response.should be_success
+			    assigns(:horsts).should_not be_nil
+			  end
+			end
+		end
+					
+I'm not sure if I should wrap all the rails assertions in matchers.
+Using the default rails assertions works fine.
+
+
+## Built in matchers
+
+* be_something, for any arbitrary something:  
+      
+        @obj.should be_something
+        # passes if @obj.something? is true
+       
+
+* have(n).somethings, for any arbitrary something:
+
+        @obj.should have(3).somethings
+        # passes if @obj.somethings.length == 3
+
+* change {something}
+
+        lambda {@var+=1}.should change {@var}
+        # passes
+        lambda { }.should change {@var}
+        # fails
+        @var = 1
+        lambda {@var+=1}.should change {@var}.from(1).to(2)
+        # passes
+    
+* more
+
+## DEF_MATCHER
+
+### A simple example first:
+
+	    def_matcher :be_nil do |given, matcher, args|
+	      given.nil?
+	    end
+	    nil.should be_nil
+	
+	
+The `def_matcher` method is really simple to use.  
+You just provide it the name of your matcher and attach a block that defines it's behavior.
+The return value of the block is a boolean that 
+actually will be expected (should) or not expected (`should_not`).
+
+There are three arguments available inside the matcher block:
+
+### given
+
+  This is the object that has received the should or `should_not`.
+
+### matcher
+  
+This is the matcher object. You can set the failure messages as attributes on this object:
+   
+          def_matcher :matcher_name do |given, matcher, args|
+            matcher.positive_msg = "You can see me if I am applied to should and I return a false value"
+            matcher.negative_msg = "You can see me if I am applied to should_not and I return a true value"
+          end 
+
+It holds a list of all methods that have been called on the matcher (for chaining):
+  
+          obj.should matcher_name.some_method(4,5,6) {"and a block"}.second
+          def_matcher :matcher_name do |given, matcher, args|
+            # this is an ostruct that holds all information about the first method 'some_method'
+            matcher.msgs[0] 
+            # this is an ostruct that holds all information about the second method 'second'
+            matcher.msgs[1] 
+            # this is the name of the first method:
+            matcher.msgs[0].name  #=> :some_method
+						# this is a list of arguments that have been passed to the first method:
+            matcher.msgs[0].args  #=> [4,5,6]
+						# this is the block that was attached:
+            matcher.msgs[0].block #=> proc {"and a block"}
+          end
+
+If there is a failure, it knows where:
+
+          def_matcher :matcher_name do |given, matcher, args|
+            matcher.loc #=> "./some/where.rb:55 ... "
+          end
+
+### args
+  This is a list of all arguments that have been applied to the matcher. Like the 6 in: 
+        
+         (3*3).should_not be(6)
+
+## More def_matcher examples
+
+### A little more complex:
+
+			def_matcher :be_in_range do |given, matcher, args|
+			  range = args[1] ? (args[0]..args[1]) : args[0]
+			  matcher.positive_msg = "expected #{given} to be in range (#{range})"
+			  matcher.negative_msg = "expected #{given} not to be in range (#{range})"
+			  range.include?(given)
+			end
+			2.should be_in_range(1,3)
+			"m".should be_in_range("a".."z")
+			
+### Matchers may receive messages:
+
+			def_matcher :have do |given, matcher, args|
+			  number = args[0]
+			  actual = given.send(matcher.msgs[0].name).length
+			  matcher.positive_msg = "Expected #{given} to have #{actual}, but found #{number} "
+			  actual == number
+			end
+			class Thing
+			  def widgets
+			    @widgets ||= []
+			  end
+			end
+			@thing.should have(3).widgets
+
+
+## Speccify vs. RSpec
+
+### Speccify provides the parts of RSpec that actually matter (to me):
+
+* **The familiar describe/it syntax**
+* **nested contexts**
+* **should/should_not**
+* **matchers and custom matchers**
+
+### Things that actually doesn't matter (to me):
+
+* **/spec directory instead of /test**
+* **`whatever_spec.rb` instead of `test_whatever.rb`**
+* **custom formatters**
+* **custom runners**
+* **html output**
+* **special commandline tools**
+* **shared example groups**
+* **pending examples**
+* **`before_all, after_all, before_suite, after_suite`**
+ 
+
+## Contribution
+
+* Idea?, Feature Request?, Bug? -> [Lighthouse](http://300.lighthouseapp.com/projects/24443/home)
+* source -> [GitHub](http://github.com/mhennemeyer/speccify)
+* talk? -> [GoogleGroup](http://groups.google.de/group/speccify)
+
+## License
+
+(The MIT License)
+
+Copyright (c) Matthias Hennemeyer
+
+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/lib/speccify.rb

@@ -0,0 +1,201 @@
+require 'test/unit'
+
+
+unless defined?(MiniTest)
+  Test::Unit::TestCase.class_eval do 
+    def default_test
+      instance_eval { @_result.instance_eval { @run_count ||= 0; @run_count -= 1} if defined?(@_result)}
+    end
+  end # Test::Unit::TestCase
+end
+
+module Speccify
+  module ExampleGroupClassMethods
+    attr_accessor :desc, :setup_chained, :teardown_chained
+    @desc ||= ""
+    
+    def setup_chained
+      @setup_chained || lambda {}
+    end
+    
+    def teardown_chained
+      @teardown_chained || lambda {}
+    end
+
+    def before(type = :each, &block)
+      raise "unsupported before type: #{type}" unless type == :each
+      passed_through_setup = self.setup_chained
+      self.setup_chained = lambda { instance_eval(&passed_through_setup);instance_eval(&block) }
+      define_method :setup, &self.setup_chained
+    end
+
+    def after(type = :each, &block)
+      raise "unsupported after type: #{type}" unless type == :each
+      passed_through_teardown = self.teardown_chained
+      self.teardown_chained = lambda {instance_eval(&block);instance_eval(&passed_through_teardown) }
+      define_method :teardown, &self.teardown_chained
+    end
+    
+    def describe desc, &block
+      cls = Class.new(self.superclass)
+      Object.const_set self.name + desc.to_s.split(/\W+/).map { |s| s.capitalize }.join, cls
+      cls.setup_chained = self.setup_chained
+      cls.teardown_chained = self.teardown_chained
+      cls.desc = self.desc + " " + desc
+      cls.tests($1.constantize) if defined?(Rails) && self.name =~ /^(.*Controller)Test/
+      cls.class_eval(&block)
+    end
+    
+    def it desc, &block
+      self.before {}
+      define_method "test_#{desc.gsub(/\W+/, '_').downcase}", &lambda {$current_spec = self; instance_eval(&block)} if block_given?
+      self.after {}
+    end
+  end # ExampleGroupClassMethods
+  
+  module ExampleGroupMethods
+    def method_missing(name, *args, &block)
+      if (name.to_s =~ /^be_(.+)/)
+        Speccify::Functions::build_matcher(name, args) do |given, matcher, args|
+          given.send(($1 + "?").to_sym)
+        end
+      else
+        raise NoMethodError.new(name.to_s)
+      end
+    end
+  end # ExampleGroupMethods
+  
+  module Functions   
+    def self.determine_class_name(name)
+      name.to_s.split(/\W+/).map { |s| s[0..0].upcase + s[1..-1] }.join 
+    end
+    
+    def self.build_matcher(matcher_name, args, &block)
+      match_block = lambda do |actual, matcher|
+        block.call(actual, matcher, args)
+      end
+      body = lambda do |klass|
+        @matcher_name = matcher_name.to_s
+        def self.matcher_name
+          @matcher_name
+        end
+        
+        attr_accessor :positive_msg, :negative_msg, :msgs, :loc
+        def initialize match_block
+          @match_block = match_block
+        end
+        
+        def method_missing id, *args, &block
+          require 'ostruct'
+          (self.msgs ||= []) << OpenStruct.new( "name" => id, "args" => args, "block" => block ) 
+          self
+        end
+
+        def matches? given
+          @positive_msg ||= Speccify::Functions::message("#{given} should #{self.class.matcher_name}", "no match", self.class.matcher_name , self.loc || "") 
+          @negative_msg ||= Speccify::Functions::message("#{given} should not #{self.class.matcher_name}", "match", self.class.matcher_name , self.loc || "")
+          @match_block.call(given, self)
+        end
+      end
+      Class.new(&body).new(match_block)
+    end
+    
+    def self.message(expected, actual, op, location) 
+            """
+              Expected: #{expected.to_s}
+                   got: #{actual.to_s} 
+       comparison with: #{op.to_s}
+              location: (#{location})
+            """
+    end
+  end # Functions
+
+  class OperatorMatcherProxy
+    def self.create given, loc, type = true
+      body = lambda do |klass|
+        define_method(:initialize) do |given|
+          @given = given
+        end
+
+        ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+          define_method(operator) do |actual|
+            print_given  = (@given == nil) ? "nil" : @given
+            print_actual = (type ? "" : "not ") + (actual.nil? ? "nil" : actual.to_s)
+            msg = Speccify::Functions::message(print_actual, print_given, operator, loc)
+            $current_spec.assert(type == @given.send(operator,actual), msg)
+          end
+        end
+      end
+
+      return Class.new(&body).new(given)
+    end
+  end # OperatorMatcherProxy
+
+  Object.class_eval do
+    def should matcher = nil
+      if matcher
+        matcher.loc = caller[0]
+        $current_spec.assert(matcher.matches?(self), matcher.positive_msg)
+      else
+        OperatorMatcherProxy.create(self,caller[0])
+      end
+    end
+
+    def should_not matcher = nil
+      if matcher
+        matcher.loc = caller[0]
+        $current_spec.assert(!matcher.matches?(self), matcher.negative_msg)
+      else 
+        OperatorMatcherProxy.create(self,caller[0], false)
+      end
+    end
+  end # Object
+    
+  module Extension
+    def def_matcher(matcher_name, &block)
+      self.class.send :define_method, matcher_name do |*args|
+        Speccify::Functions::build_matcher(matcher_name, args, &block)
+      end
+    end
+  end # Extension
+  
+  module ::Kernel
+    def describe *args, &block
+      super_class = (Hash === args.last && (args.last[:type] || args.last[:testcase])) || Test::Unit::TestCase 
+      super_class.class_eval {extend ExampleGroupClassMethods; include ExampleGroupMethods}
+      cls = Class.new(super_class)
+      cnst, desc = args
+      Object.const_set Speccify::Functions::determine_class_name(cnst.to_s + "Test"), cls
+      cls.desc = String === desc ? desc : cnst.to_s
+      cls.class_eval(&block)
+    end
+    private :describe
+  end # Kernel
+end # Speccify
+include Speccify::Extension
+
+# A few matchers:
+def_matcher :be do |given, matcher, args|
+  given == args[0]
+end
+
+def change(&block)
+  Speccify::Functions::build_matcher(:change, []) do |given, matcher, args|
+    before = block.call
+    given.call
+    after = block.call
+    comparison = after != before
+    if list = matcher.msgs
+      comparison = case list[0].name
+        # todo provide meaningful messages
+      when :by          then (after == before + list[0].args[0] || after == before - list[0].args[0])
+      when :by_at_least then (after >= before + list[0].args[0] || after <= before - list[0].args[0])
+      when :by_at_most  then (after <= before + list[0].args[0] && after >= before - list[0].args[0])
+      when :from        then (before == list[0].args[0]) && (after == list[1].args[0])
+      end
+    end
+    matcher.positive_msg = "given block didn't alter the block attached to change, #{matcher.loc}"
+    matcher.negative_msg = "given block did alter the block attached to change, #{matcher.loc}"
+    comparison
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+name: speccify
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Matthias Hennemeyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-01 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Speccify is a lightweight alternative to RSpec.
+email: mhennemeyer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.markdown
+- lib/speccify.rb
+has_rdoc: false
+homepage: http://github.com/mhennemeyer/speccify
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Speccify is a lightweight alternative to RSpec.
+test_files: []
+