rsanheim-micronaut 0.1.3.2

data/lib/micronaut/matchers.rb

@@ -0,0 +1,148 @@
+require 'micronaut/matchers/generated_descriptions'
+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/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 (courtesy of RSpec and Micronaut) 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
+    
+    class MatcherError < StandardError; end
+    
+    private
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
+      return has(sym, *args) if sym.starts_with?("have_")
+      super
+    end
+      
+  end
+  
+end

data/lib/micronaut/mocking/with_absolutely_nothing.rb

@@ -0,0 +1,11 @@
+module Micronaut
+  module Mocking
+    module WithAbsolutelyNothing
+      
+      def _setup_mocks; end
+      def _verify_mocks; end
+      def _teardown_mocks; end
+      
+    end
+  end
+end

data/lib/micronaut/mocking/with_mocha.rb

@@ -0,0 +1,13 @@
+require 'mocha/standalone'
+require 'mocha/object'
+
+module Micronaut
+  module Mocking
+    module WithMocha
+      include Mocha::Standalone
+      alias :_setup_mocks :mocha_setup
+      alias :_verify_mocks :mocha_verify
+      alias :_teardown_mocks :mocha_teardown      
+    end
+  end
+end

data/lib/micronaut/mocking/with_rr.rb

@@ -0,0 +1,24 @@
+require 'rr'
+
+Micronaut.configuration.backtrace_clean_patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
+
+module Micronaut
+  module Mocking
+    module WithRR
+      include RR::Extensions::InstanceMethods
+
+      def _setup_mocks
+        RR::Space.instance.reset
+      end
+
+      def _verify_mocks
+        RR::Space.instance.verify_doubles
+      end
+
+      def _teardown_mocks
+        RR::Space.instance.reset
+      end
+
+    end
+  end
+end

data/lib/micronaut/mocking.rb

@@ -0,0 +1,7 @@
+require 'micronaut/mocking/with_absolutely_nothing'
+
+module Micronaut
+  module Mocking   
+
+  end
+end

data/lib/micronaut/runner.rb

@@ -0,0 +1,57 @@
+module Micronaut
+
+  class Runner
+
+    def self.installed_at_exit?
+      @installed_at_exit ||= false
+    end
+
+    def self.autorun
+      at_exit { Micronaut::Runner.new.run(ARGV) ? exit(0) : exit(1) } unless installed_at_exit?
+      @installed_at_exit = true
+    end
+
+    def options
+      Micronaut.configuration.options
+    end
+
+    def load_all_behaviours(files_from_args=[])
+      files_from_args.inject([]) { |files, arg| files.concat(Dir[arg].map { |g| Dir.glob(g) }.flatten) }.each do |file|
+        load file
+      end
+    end
+    
+    def run(args = [])
+      load_all_behaviours(args)
+      
+      behaviours_to_run = Micronaut::World.behaviours_to_run
+
+      total_examples = behaviours_to_run.inject(0) { |sum, b| sum + b.examples_to_run.size }
+
+      old_sync, options.formatter.output.sync = options.formatter.output.sync, true if options.formatter.output.respond_to?(:sync=)
+
+      options.formatter.start(total_examples)
+
+      suite_success = true
+
+      starts_at = Time.now
+      behaviours_to_run.each do |behaviour|
+        suite_success &= behaviour.run(options.formatter)
+      end
+      duration = Time.now - starts_at
+
+      options.formatter.start_dump
+      options.formatter.dump_pending
+      options.formatter.dump_failures
+
+      # TODO: Stop passing in the last two items, the formatter knows this info
+      options.formatter.dump_summary(duration, total_examples, options.formatter.failed_examples.size, options.formatter.pending_examples.size)
+
+      options.formatter.output.sync = old_sync if options.formatter.output.respond_to? :sync=
+
+      suite_success
+    end
+
+  end
+
+end

data/lib/micronaut/runner_options.rb

@@ -0,0 +1,33 @@
+module Micronaut
+  class RunnerOptions
+    
+    attr_accessor :color, :formatter
+    
+    def initialize(options={})
+      @color = options.delete(:color)
+      @formatter = options.delete(:formatter)
+    end
+    
+    def enable_color_in_output?
+      !textmate? && @color
+    end
+    
+    def textmate?
+      ENV.has_key?('TM_RUBY')
+    end
+    
+    def output
+      $stdout
+    end
+    
+    def formatter
+      @formatter_instance ||= case @formatter.to_s
+                              when 'documentation'
+                                Micronaut::Formatters::DocumentationFormatter.new(self, output)
+                              else
+                                Micronaut::Formatters::ProgressFormatter.new(self, output)
+                              end
+    end
+
+  end
+end

data/lib/micronaut/world.rb

@@ -0,0 +1,75 @@
+module Micronaut
+
+  class World
+
+    def self.reset
+      @behaviours = []
+    end
+
+    reset
+
+    def self.behaviours
+      @behaviours
+    end
+
+    def self.behaviours_to_run
+      filter_behaviours
+      number_of_behaviours_left = sum_behaviours
+      
+      if number_of_behaviours_left.zero?
+        if Micronaut.configuration.filters.empty?
+          add_all_examples
+        elsif Micronaut.configuration.run_all_when_everything_filtered?
+          puts "  Filter(s) produced no matches - running everything"
+          add_all_examples
+        else
+          puts "  Filter(s) matched no specs - your world is empty, desolate, and alone."
+        end
+      end
+      
+      behaviours
+    end
+    
+    def self.sum_behaviours
+      behaviours.inject(0) { |sum, b| sum += b.examples_to_run.size }
+    end
+    
+    def self.add_all_examples
+      behaviours.each do |behaviour|
+        behaviour.examples_to_run.concat(behaviour.examples)
+      end
+    end
+    
+    def self.filter_behaviours
+      return unless Micronaut.configuration.filters.any?
+      Micronaut.configuration.filters.each do |filter|
+        puts "  Run filtered using: #{filter.inspect}"
+        behaviours.each do |behaviour|
+          behaviour.examples_to_run.concat find(behaviour.examples, filter)
+        end
+      end
+      behaviours      
+    end
+
+    def self.find(collection, conditions={})
+      return [] if conditions.empty?
+
+      collection.select do |item|
+        conditions.all? do |key, value|
+          case value
+          when Hash
+            value.all? { |k, v| item.metadata[key][k] == v }
+          when Regexp
+            item.metadata[key] =~ value
+          when Proc
+            value.call(item.metadata[key]) rescue false
+          else
+            item.metadata[key] == value
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/micronaut.rb

@@ -0,0 +1,37 @@
+require 'micronaut/mocking'
+require 'micronaut/matchers'
+require 'micronaut/expectations'
+require 'micronaut/world'
+require 'micronaut/configuration'
+require 'micronaut/runner'
+require 'micronaut/runner_options'
+require 'micronaut/example'
+require 'micronaut/behaviour'
+require 'micronaut/kernel_extensions'
+require 'micronaut/formatters'
+
+module Micronaut
+  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
+  InstallDirectory = File.expand_path(File.dirname(File.dirname(file)) + "/lib")
+
+  def self.configuration
+    @configuration ||= Micronaut::Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+  
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: rsanheim-micronaut
+version: !ruby/object:Gem::Version 
+  version: 0.1.3.2
+platform: ruby
+authors: 
+- Chad Humphries
+autorequire: micronaut
+bindir: bin
+cert_chain: []
+
+date: 2008-12-18 00:00:00 -08:00
+default_executable: micronaut
+dependencies: []
+
+description: An excellent replacement for the wheel...
+email: chad@spicycode.com
+executables: 
+- micronaut
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- RSPEC-LICENSE
+files: 
+- LICENSE
+- README
+- RSPEC-LICENSE
+- Rakefile
+- lib/autotest
+- lib/autotest/discover.rb
+- lib/autotest/micronaut.rb
+- lib/micronaut
+- lib/micronaut/behaviour.rb
+- lib/micronaut/configuration.rb
+- lib/micronaut/example.rb
+- lib/micronaut/expectations
+- lib/micronaut/expectations/extensions
+- lib/micronaut/expectations/extensions/object.rb
+- lib/micronaut/expectations/extensions/string_and_symbol.rb
+- lib/micronaut/expectations/handler.rb
+- lib/micronaut/expectations/wrap_expectation.rb
+- lib/micronaut/expectations.rb
+- lib/micronaut/formatters
+- lib/micronaut/formatters/base_formatter.rb
+- lib/micronaut/formatters/base_text_formatter.rb
+- lib/micronaut/formatters/documentation_formatter.rb
+- lib/micronaut/formatters/progress_formatter.rb
+- lib/micronaut/formatters.rb
+- lib/micronaut/kernel_extensions.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/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_absolutely_nothing.rb
+- lib/micronaut/mocking/with_mocha.rb
+- lib/micronaut/mocking/with_rr.rb
+- lib/micronaut/mocking.rb
+- lib/micronaut/runner.rb
+- lib/micronaut/runner_options.rb
+- lib/micronaut/world.rb
+- lib/micronaut.rb
+- examples/example_helper.rb
+- examples/lib
+- examples/lib/micronaut
+- examples/lib/micronaut/behaviour_example.rb
+- examples/lib/micronaut/configuration_example.rb
+- examples/lib/micronaut/example_example.rb
+- examples/lib/micronaut/expectations
+- 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/formatters
+- examples/lib/micronaut/formatters/base_formatter_example.rb
+- examples/lib/micronaut/formatters/documentation_formatter_example.rb
+- examples/lib/micronaut/formatters/progress_formatter_example.rb
+- examples/lib/micronaut/kernel_extensions_example.rb
+- examples/lib/micronaut/matchers
+- examples/lib/micronaut/matchers/be_close_example.rb
+- examples/lib/micronaut/matchers/be_example.rb
+- examples/lib/micronaut/matchers/change_example.rb
+- examples/lib/micronaut/matchers/description_generation_example.rb
+- examples/lib/micronaut/matchers/eql_example.rb
+- examples/lib/micronaut/matchers/equal_example.rb
+- examples/lib/micronaut/matchers/handler_example.rb
+- examples/lib/micronaut/matchers/has_example.rb
+- examples/lib/micronaut/matchers/have_example.rb
+- examples/lib/micronaut/matchers/include_example.rb
+- examples/lib/micronaut/matchers/match_example.rb
+- examples/lib/micronaut/matchers/matcher_methods_example.rb
+- examples/lib/micronaut/matchers/operator_matcher_example.rb
+- examples/lib/micronaut/matchers/raise_error_example.rb
+- examples/lib/micronaut/matchers/respond_to_example.rb
+- examples/lib/micronaut/matchers/satisfy_example.rb
+- examples/lib/micronaut/matchers/simple_matcher_example.rb
+- examples/lib/micronaut/matchers/throw_symbol_example.rb
+- examples/lib/micronaut/runner_example.rb
+- examples/lib/micronaut/runner_options_example.rb
+- examples/lib/micronaut/world_example.rb
+- examples/lib/micronaut_example.rb
+- examples/resources
+- examples/resources/example_classes.rb
+- bin/micronaut
+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: []
+