spicycode-micronaut 0.0.2

data/lib/micronaut/matchers/simple_matcher.rb

@@ -0,0 +1,132 @@
+module Micronaut
+  module Matchers
+    class SimpleMatcher
+      attr_writer :failure_message, :negative_failure_message, :description
+      
+      def initialize(description, &match_block)
+        @description = description
+        @match_block = match_block
+      end
+
+      def matches?(given)
+        @given = given
+        case @match_block.arity
+        when 2
+          @match_block.call(@given, self)
+        else
+          @match_block.call(@given)
+        end
+      end
+      
+      def description
+        @description || explanation
+      end
+
+      def failure_message
+        @failure_message || (@description.nil? ? explanation : %[expected #{@description.inspect} but got #{@given.inspect}])
+      end
+
+      def negative_failure_message
+        @negative_failure_message || (@description.nil? ? explanation : %[expected not to get #{@description.inspect}, but got #{@given.inspect}])
+      end
+
+      def explanation
+        "No description provided. See RDoc for simple_matcher()"
+      end
+    end
+  
+    # simple_matcher makes it easy for you to create your own custom matchers
+    # in just a few lines of code when you don't need all the power of a
+    # completely custom matcher object.
+    #
+    # The <tt>description</tt> argument will appear as part of any failure
+    # message, and is also the source for auto-generated descriptions.
+    #
+    # The <tt>match_block</tt> can have an arity of 1 or 2. The first block
+    # argument will be the given value. The second, if the block accepts it
+    # will be the matcher itself, giving you access to set custom failure
+    # messages in favor of the defaults.
+    #
+    # The <tt>match_block</tt> should return a boolean: <tt>true</tt>
+    # indicates a match, which will pass if you use <tt>should</tt> and fail
+    # if you use <tt>should_not</tt>. false (or nil) indicates no match,
+    # which will do the reverse: fail if you use <tt>should</tt> and pass if
+    # you use <tt>should_not</tt>.
+    #
+    # An error in the <tt>match_block</tt> will bubble up, resulting in a
+    # failure.
+    #
+    # == Example with default messages
+    #
+    #   def be_even
+    #     simple_matcher("an even number") { |given| given % 2 == 0 }
+    #   end
+    #                    
+    #   describe 2 do
+    #     it "should be even" do
+    #       2.should be_even
+    #     end
+    #   end
+    #
+    # Given an odd number, this example would produce an error message stating:
+    # expected "an even number", got 3.
+    #
+    # Unfortunately, if you're a fan of auto-generated descriptions, this will
+    # produce "should an even number." Not the most desirable result. You can
+    # control that using custom messages:
+    #
+    # == Example with custom messages
+    #
+    #   def rhyme_with(expected)
+    #     simple_matcher("rhyme with #{expected.inspect}") do |given, matcher|
+    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
+    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
+    #       given.rhymes_with? expected
+    #     end
+    #   end
+    #
+    #   # OR
+    #
+    #   def rhyme_with(expected)
+    #     simple_matcher do |given, matcher|
+    #       matcher.description = "rhyme with #{expected.inspect}"
+    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
+    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
+    #       given.rhymes_with? expected
+    #     end
+    #   end
+    #
+    #   describe "pecan" do
+    #     it "should rhyme with 'be gone'" do
+    #       nut = "pecan"
+    #       nut.extend Rhymer
+    #       nut.should rhyme_with("be gone")
+    #     end
+    #   end
+    #
+    # The resulting messages would be:
+    #   description:              rhyme with "be gone"
+    #   failure_message:          expected "pecan" to rhyme with "be gone"
+    #   negative failure_message: expected "pecan" not to rhyme with "be gone"
+    #
+    # == Wrapped Expectations
+    #
+    # Because errors will bubble up, it is possible to wrap other expectations
+    # in a SimpleMatcher.
+    #
+    #   def be_even
+    #     simple_matcher("an even number") { |given| (given % 2).should == 0 }
+    #   end
+    #
+    # BE VERY CAREFUL when you do this. Only use wrapped expectations for
+    # matchers that will always be used in only the positive
+    # (<tt>should</tt>) or negative (<tt>should_not</tt>), but not both.
+    # The reason is that is you wrap a <tt>should</tt> and call the wrapper
+    # with <tt>should_not</tt>, the correct result (the <tt>should</tt>
+    # failing), will fail when you want it to pass.
+    #
+    def simple_matcher(description=nil, &match_block)
+      SimpleMatcher.new(description, &match_block)
+    end
+  end
+end

data/lib/micronaut/matchers/throw_symbol.rb

@@ -0,0 +1,100 @@
+module Micronaut
+  module Matchers
+    
+    class ThrowSymbol #:nodoc:
+      def initialize(expected_symbol = nil, expected_arg=nil)
+        @expected_symbol = expected_symbol
+        @expected_arg = expected_arg
+        @caught_symbol = nil
+      end
+      
+      def matches?(given_proc)
+        begin
+          if @expected_symbol.nil?
+            given_proc.call
+          else
+            @caught_arg = catch :proc_did_not_throw_anything do
+              catch @expected_symbol do
+                given_proc.call
+                throw :proc_did_not_throw_anything, :nothing_thrown
+              end
+            end
+            @caught_symbol = @expected_symbol unless @caught_arg == :nothing_thrown
+          end
+        rescue NameError => e
+          raise e unless e.message =~ /uncaught throw/
+          @caught_symbol = e.name.to_sym
+        ensure
+          if @expected_symbol.nil?
+            return !@caught_symbol.nil?
+          else
+            if @expected_arg.nil?
+              return @caught_symbol == @expected_symbol
+            else
+              return @caught_symbol == @expected_symbol && @caught_arg == @expected_arg
+            end
+          end
+        end
+      end
+
+      def failure_message
+        if @caught_symbol
+          "expected #{expected}, got #{@caught_symbol.inspect}"
+        else
+          "expected #{expected} but nothing was thrown"
+        end
+      end
+      
+      def negative_failure_message
+        if @expected_symbol
+          "expected #{expected} not to be thrown"
+        else
+          "expected no Symbol, got :#{@caught_symbol}"
+        end
+      end
+      
+      def description
+        "throw #{expected}"
+      end
+      
+      private
+      
+        def expected
+          @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}"
+        end
+        
+        def args
+          @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}"
+        end
+      
+    end
+ 
+    # :call-seq:
+    #   should throw_symbol()
+    #   should throw_symbol(:sym)
+    #   should throw_symbol(:sym, arg)
+    #   should_not throw_symbol()
+    #   should_not throw_symbol(:sym)
+    #   should_not throw_symbol(:sym, arg)
+    #
+    # Given no argument, matches if a proc throws any Symbol.
+    #
+    # Given a Symbol, matches if the given proc throws the specified Symbol.
+    #
+    # Given a Symbol and an arg, matches if the given proc throws the
+    # specified Symbol with the specified arg.
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should throw_symbol
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky, culprit)
+    #
+    #   lambda { do_something_risky }.should_not throw_symbol
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky, culprit)
+    def throw_symbol(sym=nil)
+      Matchers::ThrowSymbol.new(sym)
+    end
+  end
+end

data/lib/micronaut/matchers.rb

@@ -0,0 +1,141 @@
+require 'micronaut/matchers/generated_descriptions'
+require 'micronaut/matchers/errors'
+require 'micronaut/matchers/method_missing'
+require 'micronaut/matchers/simple_matcher'
+require 'micronaut/matchers/be'
+require 'micronaut/matchers/be_close'
+require 'micronaut/matchers/change'
+require 'micronaut/matchers/eql'
+require 'micronaut/matchers/equal'
+require 'micronaut/matchers/exist'
+require 'micronaut/matchers/has'
+require 'micronaut/matchers/have'
+require 'micronaut/matchers/include'
+require 'micronaut/matchers/match'
+require 'micronaut/matchers/raise_error'
+require 'micronaut/matchers/respond_to'
+require 'micronaut/matchers/satisfy'
+require 'micronaut/matchers/throw_symbol'
+require 'micronaut/matchers/operator_matcher'
+
+module Micronaut
+
+  # We ship with a number of useful Expression Matchers. An Expression Matcher
+  # is any object that responds to the following methods:
+  #
+  #   matches?(actual)
+  #   failure_message
+  #   negative_failure_message #optional
+  #   description #optional
+  #
+  # See Micronaut::Expectations to learn how to use these as Expectation Matchers.
+  # See Micronaut::Mocks to learn how to use them as Mock Argument Constraints.
+  #
+  # == Predicates
+  #
+  # In addition to those Expression Matchers that are defined explicitly, we will
+  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
+  # a much more natural language feel. 
+  #
+  # A Ruby predicate is a method that ends with a "?" and returns true or false.
+  # Common examples are +empty?+, +nil?+, and +instance_of?+.
+  #
+  # All you need to do is write +should be_+ followed by the predicate without
+  # the question mark, and we will figure it out from there. For example:
+  #
+  #   [].should be_empty => [].empty? #passes
+  #   [].should_not be_empty => [].empty? #fails
+  #
+  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
+  # and "be_an_", making your specs read much more naturally:
+  #
+  #   "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
+  #
+  #   3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
+  #   3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
+  #   3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
+  #   3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
+  #
+  # We will also create custom matchers for predicates like +has_key?+. To
+  # use this feature, just state that the object should have_key(:key) and we will
+  # call has_key?(:key) on the target. For example:
+  #
+  #   {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
+  #   {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
+  #
+  # You can use this feature to invoke any predicate that begins with "has_", whether it is
+  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
+  #
+  # == Custom Expectation Matchers
+  #
+  # When you find that none of the stock Expectation Matchers provide a natural
+  # feeling expectation, you can very easily write your own.
+  #
+  # For example, imagine that you are writing a game in which players can
+  # be in various zones on a virtual board. To specify that bob should
+  # be in zone 4, you could say:
+  #
+  #   bob.current_zone.should eql(Zone.new("4"))
+  #
+  # But you might find it more expressive to say:
+  #
+  #   bob.should be_in_zone("4")
+  #
+  # and/or
+  #
+  #   bob.should_not be_in_zone("3")
+  #
+  # To do this, you would need to write a class like this:
+  #
+  #   class BeInZone
+  #     def initialize(expected)
+  #       @expected = expected
+  #     end
+  #     def matches?(target)
+  #       @target = target
+  #       @target.current_zone.eql?(Zone.new(@expected))
+  #     end
+  #     def failure_message
+  #       "expected #{@target.inspect} to be in Zone #{@expected}"
+  #     end
+  #     def negative_failure_message
+  #       "expected #{@target.inspect} not to be in Zone #{@expected}"
+  #     end
+  #   end
+  #
+  # ... and a method like this:
+  #
+  #   def be_in_zone(expected)
+  #     BeInZone.new(expected)
+  #   end
+  #
+  # And then expose the method to your specs. This is normally done
+  # by including the method and the class in a module, which is then
+  # included in your spec:
+  #
+  #   module CustomGameMatchers
+  #     class BeInZone
+  #       ...
+  #     end
+  #
+  #     def be_in_zone(expected)
+  #       ...
+  #     end
+  #   end
+  #
+  #   describe "Player behaviour" do
+  #     include CustomGameMatchers
+  #     ...
+  #   end
+  #
+  # or you can include in globally in a spec_helper.rb file <tt>require</tt>d
+  # from your spec file(s):
+  #
+  #   Micronaut::Runner.configure do |config|
+  #     config.include(CustomGameMatchers)
+  #   end
+  #
+  module Matchers
+  
+  end
+end

data/lib/micronaut/mocking/with_mocha.rb

@@ -0,0 +1,23 @@
+require 'mocha/standalone'
+require 'mocha/object'
+
+module Micronaut
+  module Mocking
+    module WithMocha
+      include Mocha::Standalone
+    
+      def setup_mocks
+        mocha_setup
+      end
+    
+      def verify_mocks
+        mocha_verify
+      end
+    
+      def teardown_mocks
+        mocha_teardown
+      end
+      
+    end
+  end
+end

data/lib/micronaut.rb

@@ -0,0 +1,42 @@
+require 'micronaut/mocking/with_mocha'
+require 'micronaut/exceptions'
+require 'micronaut/matchers'
+require 'micronaut/expectations'
+require 'micronaut/example_world'
+require 'micronaut/example_runner'
+require 'micronaut/example_group'
+require 'micronaut/extensions/kernel'
+
+module Micronaut
+  VERSION = "0.0.2"
+
+  file = if RUBY_VERSION =~ /^1\.9/ then  # bt's expanded, but __FILE__ isn't :(
+           File.expand_path __FILE__
+         elsif  __FILE__ =~ /^[^\.]/ then # assume both relative
+           require 'pathname'
+           pwd = Pathname.new(Dir.pwd)
+           path_name = Pathname.new(File.expand_path(__FILE__))
+           path_name = File.join(".", path_name.relative_path_from(pwd)) unless path_name.relative?
+           path_name.to_s
+         else                             # assume both are expanded
+           __FILE__
+         end
+
+  # './lib' in project dir, or '/usr/local/blahblah' if installed
+  MICRONAUT_DIR = File.expand_path(File.dirname(File.dirname(file)))
+
+  def self.filter_backtrace(backtrace)
+    return ["No backtrace"] unless backtrace
+
+    new_backtrace = []
+    backtrace.each_with_index do |line, index|
+      break if line.rindex(MICRONAUT_DIR, 0) && index > 2
+      new_backtrace << line
+    end
+
+    new_backtrace = backtrace.reject { |line| line.rindex(MICRONAUT_DIR, 0) } if new_backtrace.empty?
+    new_backtrace = backtrace.dup if new_backtrace.empty?
+    new_backtrace
+  end
+  
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: spicycode-micronaut
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Chad Humphries
+autorequire: micronaut
+bindir: bin
+cert_chain: []
+
+date: 2008-11-21 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: An excellent replacement for the wheel...
+email: chad@spicycode.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/autotest
+- lib/autotest/discover.rb
+- lib/autotest/micronaut.rb
+- lib/micronaut
+- lib/micronaut/example_group.rb
+- lib/micronaut/example_runner.rb
+- lib/micronaut/example_world.rb
+- lib/micronaut/exceptions.rb
+- lib/micronaut/expectations
+- lib/micronaut/expectations/differs
+- lib/micronaut/expectations/differs/default.rb
+- lib/micronaut/expectations/handler.rb
+- lib/micronaut/expectations/object_extensions.rb
+- lib/micronaut/expectations/string_and_symbol_extensions.rb
+- lib/micronaut/expectations/wrap_expectation.rb
+- lib/micronaut/expectations.rb
+- lib/micronaut/extensions
+- lib/micronaut/extensions/kernel.rb
+- lib/micronaut/matchers
+- lib/micronaut/matchers/be.rb
+- lib/micronaut/matchers/be_close.rb
+- lib/micronaut/matchers/change.rb
+- lib/micronaut/matchers/eql.rb
+- lib/micronaut/matchers/equal.rb
+- lib/micronaut/matchers/errors.rb
+- lib/micronaut/matchers/exist.rb
+- lib/micronaut/matchers/generated_descriptions.rb
+- lib/micronaut/matchers/has.rb
+- lib/micronaut/matchers/have.rb
+- lib/micronaut/matchers/include.rb
+- lib/micronaut/matchers/match.rb
+- lib/micronaut/matchers/method_missing.rb
+- lib/micronaut/matchers/operator_matcher.rb
+- lib/micronaut/matchers/raise_error.rb
+- lib/micronaut/matchers/respond_to.rb
+- lib/micronaut/matchers/satisfy.rb
+- lib/micronaut/matchers/simple_matcher.rb
+- lib/micronaut/matchers/throw_symbol.rb
+- lib/micronaut/matchers.rb
+- lib/micronaut/mocking
+- lib/micronaut/mocking/with_mocha.rb
+- lib/micronaut.rb
+- examples/example_helper.rb
+- examples/lib
+- examples/lib/micronaut
+- examples/lib/micronaut/example_group_example.rb
+- examples/lib/micronaut/example_runner_example.rb
+- examples/lib/micronaut/expectations
+- examples/lib/micronaut/expectations/differs
+- examples/lib/micronaut/expectations/differs/default_example.rb
+- examples/lib/micronaut/expectations/extensions
+- examples/lib/micronaut/expectations/extensions/object_example.rb
+- examples/lib/micronaut/expectations/fail_with_example.rb
+- examples/lib/micronaut/expectations/wrap_expectation_example.rb
+- examples/lib/micronaut/matchers
+- examples/lib/micronaut_example.rb
+has_rdoc: true
+homepage: http://spicycode.com
+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.2.0
+signing_key: 
+specification_version: 2
+summary: An excellent replacement for the wheel...
+test_files: []
+