rspec 1.0.0 → 1.3.1

data/lib/spec/mocks/proxy.rb

@@ -4,77 +4,142 @@ module Spec
       DEFAULT_OPTIONS = {
         :null_object => false,
       }
+      
+      @@warn_about_expectations_on_nil = true
+      
+      def self.allow_message_expectations_on_nil
+        @@warn_about_expectations_on_nil = false
+        
+        # ensure nil.rspec_verify is called even if an expectation is not set in the example
+        # otherwise the allowance would effect subsequent examples
+        $rspec_mocks.add(nil) unless $rspec_mocks.nil?
+      end
 
-      def initialize(target, name, options={})
+      def initialize(target, name=nil, options={})
         @target = target
         @name = name
-        @error_generator = ErrorGenerator.new target, name
+        @error_generator = ErrorGenerator.new target, name, options
         @expectation_ordering = OrderGroup.new @error_generator
         @expectations = []
         @messages_received = []
         @stubs = []
         @proxied_methods = []
         @options = options ? DEFAULT_OPTIONS.dup.merge(options) : DEFAULT_OPTIONS
+        @already_proxied_respond_to = false
       end
 
       def null_object?
         @options[:null_object]
       end
+      
+      def as_null_object
+        @options[:null_object] = true
+        @target
+      end
 
-      def add_message_expectation(expected_from, sym, opts={}, &block)
-        __add expected_from, sym, block
-        @expectations << MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts)
+      def add_message_expectation(expected_from, sym, opts={}, &block)        
+        __add sym
+        warn_if_nil_class sym
+        @expectations << build_expectation(expected_from, sym, opts, &block)
         @expectations.last
       end
 
+      def build_expectation(expected_from, sym, opts, &block)
+        if stub = find_matching_method_stub(sym) 
+          stub.build_child(expected_from, block_given?? block : nil, 1, opts)
+        else
+          MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts)
+        end
+      end
+
       def add_negative_message_expectation(expected_from, sym, &block)
-        __add expected_from, sym, block
+        __add sym
+        warn_if_nil_class sym
         @expectations << NegativeMessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
         @expectations.last
       end
 
-      def add_stub(expected_from, sym)
-        __add expected_from, sym, nil
-        @stubs.unshift MethodStub.new(@error_generator, @expectation_ordering, expected_from, sym, nil)
+      def add_stub(expected_from, sym, opts={}, &implementation)
+        __add sym
+        @stubs.unshift MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, nil, :any, opts, &implementation)
         @stubs.first
       end
 
-      def verify #:nodoc:
-        begin
-          verify_expectations
-        ensure
-          reset
+      def remove_stub(message)
+        message = message.to_sym
+        if stub_to_remove = @stubs.detect { |s| s.matches_name?(message) }
+          reset_proxied_method(message)
+          @stubs.delete(stub_to_remove)
+        else
+          raise MockExpectationError, "The method `#{message}` was not stubbed or was already unstubbed"
         end
       end
+      
+      def verify #:nodoc:
+        verify_expectations
+      ensure
+        reset
+      end
 
       def reset
         clear_expectations
         clear_stubs
         reset_proxied_methods
         clear_proxied_methods
+        reset_nil_expectations_warning
       end
 
       def received_message?(sym, *args, &block)
-        return true if @messages_received.find {|array| array == [sym, args, block]}
-        return false
+        @messages_received.any? {|array| array == [sym, args, block]}
       end
 
       def has_negative_expectation?(sym)
-        @expectations.detect {|expectation| expectation.negative_expectation_for?(sym)}
+        @expectations.any? {|expectation| expectation.negative_expectation_for?(sym)}
+      end
+      
+      def record_message_received(sym, args, block)
+        @messages_received << [sym, args, block]
       end
 
       def message_received(sym, *args, &block)
-        if expectation = find_matching_expectation(sym, *args)
-          expectation.invoke(args, block)
-        elsif stub = find_matching_method_stub(sym)
-          stub.invoke([], block)
+        expectation = find_matching_expectation(sym, *args)
+        stub = find_matching_method_stub(sym, *args)
+
+        if ok_to_invoke_stub?(stub, expectation)
+          record_stub(stub, sym, args, &block)
+        elsif expectation
+          invoke_expectation(expectation, *args, &block)
         elsif expectation = find_almost_matching_expectation(sym, *args)
-          raise_unexpected_message_args_error(expectation, *args) unless has_negative_expectation?(sym) unless null_object?
+          record_almost_matching_expectation(expectation, sym, *args, &block)
+        elsif @target.is_a?(Class)
+          @target.superclass.send(sym, *args, &block)
         else
-          @target.send :method_missing, sym, *args, &block
+          @target.__send__ :method_missing, sym, *args, &block
+        end
+      end
+
+      def record_stub(stub, sym, args, &block)
+        almost_matching_expectation(sym, *args) do |e|
+          e.advise(args, block)
+        end
+        stub.invoke(*args, &block)
+      end
+
+      def invoke_expectation(expectation, *args, &block)
+        expectation.invoke(*args, &block)
+      end
+
+      def record_almost_matching_expectation(expectation, sym, *args, &block)
+        expectation.advise(args, block)
+        unless (null_object? or has_negative_expectation?(sym))
+          raise_unexpected_message_args_error(expectation, *args)
         end
       end
 
+      def ok_to_invoke_stub?(stub, expectation)
+        stub && (!expectation || expectation.called_max_times?)
+      end
+
       def raise_unexpected_message_args_error(expectation, *args)
         @error_generator.raise_unexpected_message_args_error expectation, *args
       end
@@ -83,34 +148,62 @@ module Spec
         @error_generator.raise_unexpected_message_error sym, *args
       end
       
+      def find_matching_method_stub(sym, *args)
+        @stubs.find {|stub| stub.matches(sym, args)}
+      end
+      
     private
 
-      def __add(expected_from, sym, block)
-        $rspec_mocks.add(@target)
+      def __add(sym)
+        $rspec_mocks.add(@target) unless $rspec_mocks.nil?
         define_expected_method(sym)
       end
       
-      def define_expected_method(sym)
-        if target_responds_to?(sym) && !@proxied_methods.include?(sym)
-          @proxied_methods << sym
-          metaclass.__send__(:alias_method, munge(sym), sym)
+      def warn_if_nil_class(sym)
+        if proxy_for_nil_class? & @@warn_about_expectations_on_nil          
+          Kernel.warn("An expectation of :#{sym} was set on nil. Called from #{caller[2]}. Use allow_message_expectations_on_nil to disable warnings.")
         end
-
-        metaclass_eval(<<-EOF, __FILE__, __LINE__)
-          def #{sym}(*args, &block)
-            __mock_proxy.message_received :#{sym}, *args, &block
+      end
+      
+      def define_expected_method(sym)
+        unless @proxied_methods.include?(sym)
+          visibility_string = "#{visibility(sym)} :#{sym}"
+          if target_responds_to?(sym)
+            munged_sym = munge(sym)
+            target_metaclass.instance_eval do
+              alias_method munged_sym, sym if method_defined?(sym)
+            end
+            @proxied_methods << sym
           end
-        EOF
+          target_metaclass.class_eval(<<-EOF, __FILE__, __LINE__)
+            def #{sym}(*args, &block)
+              __mock_proxy.message_received :#{sym}, *args, &block
+            end
+            #{visibility_string}
+          EOF
+        end
       end
 
       def target_responds_to?(sym)
-        return @target.send(munge(:respond_to?),sym) if @already_proxied_respond_to
+        return @target.__send__(munge(:respond_to?),sym) if @already_proxied_respond_to
         return @already_proxied_respond_to = true if sym == :respond_to?
-        return @target.respond_to?(sym)
+        return @target.respond_to?(sym, true)
+      end
+
+      def visibility(sym)
+        if Mock === @target
+          'public'
+        elsif target_metaclass.private_method_defined?(sym)
+          'private'
+        elsif target_metaclass.protected_method_defined?(sym)
+          'protected'
+        else
+          'public'
+        end
       end
 
       def munge(sym)
-        "proxied_by_rspec__#{sym.to_s}".to_sym
+        "proxied_by_rspec__#{sym}"
       end
 
       def clear_expectations
@@ -125,39 +218,51 @@ module Spec
         @proxied_methods.clear
       end
 
-      def metaclass_eval(str, filename, lineno)
-        metaclass.class_eval(str, filename, lineno)
-      end
-      
-      def metaclass
-        (class << @target; self; end)
+      def target_metaclass
+        class << @target; self; end
       end
 
       def verify_expectations
-        @expectations.each do |expectation|
-          expectation.verify_messages_received
-        end
+        @expectations.map {|e| e.verify_messages_received}
       end
 
       def reset_proxied_methods
-        @proxied_methods.each do |sym|
-          metaclass.__send__(:alias_method, sym, munge(sym))
-          metaclass.__send__(:undef_method, munge(sym))
+        @proxied_methods.map {|sym| reset_proxied_method(sym)}
+      end
+
+      def reset_proxied_method(sym)
+        munged_sym = munge(sym)
+        target_metaclass.instance_eval do
+          remove_method sym
+          if method_defined?(munged_sym)
+            alias_method sym, munged_sym
+            remove_method munged_sym
+          end
         end
       end
+      
+      def proxy_for_nil_class?
+        @target.nil?
+      end
+      
+      def reset_nil_expectations_warning
+        @@warn_about_expectations_on_nil = true if proxy_for_nil_class?
+      end
 
       def find_matching_expectation(sym, *args)
+        @expectations.find {|expectation| expectation.matches(sym, args) && !expectation.called_max_times?} || 
         @expectations.find {|expectation| expectation.matches(sym, args)}
       end
 
-      def find_almost_matching_expectation(sym, *args)
-        @expectations.find {|expectation| expectation.matches_name_but_not_args(sym, args)}
+      def almost_matching_expectation(sym, *args, &block)
+        if e = find_almost_matching_expectation(sym, *args)
+          yield e
+        end
       end
 
-      def find_matching_method_stub(sym)
-        @stubs.find {|stub| stub.matches(sym, [])}
+      def find_almost_matching_expectation(sym, *args)
+        @expectations.find {|expectation| expectation.matches_name_but_not_args(sym, args)}
       end
-
     end
   end
-end
+end

data/lib/spec/mocks/space.rb

@@ -2,7 +2,7 @@ module Spec
   module Mocks
     class Space
       def add(obj)
-        mocks << obj unless mocks.include?(obj)
+        mocks << obj unless mocks.detect {|m| m.equal? obj}
       end
 
       def verify_all
@@ -25,4 +25,4 @@ module Spec
       end
     end
   end
-end
+end

data/lib/spec/mocks.rb

@@ -1,16 +1,5 @@
-require 'spec/mocks/methods'
-require 'spec/mocks/argument_constraint_matchers'
-require 'spec/mocks/spec_methods'
-require 'spec/mocks/proxy'
-require 'spec/mocks/mock'
-require 'spec/mocks/argument_expectation'
-require 'spec/mocks/message_expectation'
-require 'spec/mocks/order_group'
-require 'spec/mocks/errors'
-require 'spec/mocks/error_generator'
+require 'spec/mocks/framework'
 require 'spec/mocks/extensions/object'
-require 'spec/mocks/space'
-
 
 module Spec
   # == Mocks and Stubs
@@ -116,11 +105,11 @@ module Spec
   #   my_mock.should_receive(:sym).with(*args)
   #   my_mock.should_not_receive(:sym).with(*args)
   #
-  # == Argument Constraints using Expression Matchers
+  # == Argument Matchers
   #
   # Arguments that are passed to #with are compared with actual arguments received
   # using == by default. In cases in which you want to specify things about the arguments
-  # rather than the arguments themselves, you can use any of the Expression Matchers.
+  # rather than the arguments themselves, you can use any of RSpec's Expression Matchers.
   # They don't all make syntactic sense (they were primarily designed for use with
   # Spec::Expectations), but you are free to create your own custom Spec::Matchers.
   #
@@ -129,13 +118,12 @@ module Spec
   # In addition, Spec::Mocks adds some keyword Symbols that you can use to
   # specify certain kinds of arguments:
   #
-  #   my_mock.should_receive(:sym).with(:no_args)
-  #   my_mock.should_receive(:sym).with(:any_args)
-  #   my_mock.should_receive(:sym).with(1, :numeric, "b") #2nd argument can any type of Numeric
-  #   my_mock.should_receive(:sym).with(1, :boolean, "b") #2nd argument can true or false
-  #   my_mock.should_receive(:sym).with(1, :string, "b") #2nd argument can be any String
+  #   my_mock.should_receive(:sym).with(no_args())
+  #   my_mock.should_receive(:sym).with(any_args())
+  #   my_mock.should_receive(:sym).with(1, kind_of(Numeric), "b") #2nd argument can any kind of Numeric
+  #   my_mock.should_receive(:sym).with(1, boolean(), "b") #2nd argument can true or false
   #   my_mock.should_receive(:sym).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
-  #   my_mock.should_receive(:sym).with(1, :anything, "b") #2nd argument can be anything at all
+  #   my_mock.should_receive(:sym).with(1, anything(), "b") #2nd argument can be anything at all
   #   my_mock.should_receive(:sym).with(1, ducktype(:abs, :div), "b")
   #                            #2nd argument can be object that responds to #abs and #div
   #                                                                       
@@ -171,7 +159,9 @@ module Spec
   #     #error can be an instantiated object or a class
   #     #if it is a class, it must be instantiable with no args
   #   my_mock.should_receive(:sym).and_throw(:sym)
-  #   my_mock.should_receive(:sym).and_yield([array,of,values,to,yield])
+  #   my_mock.should_receive(:sym).and_yield(values,to,yield)
+  #   my_mock.should_receive(:sym).and_yield(values,to,yield).and_yield(some,other,values,this,time)
+  #     # for methods that yield to a block multiple times
   #
   # Any of these responses can be applied to a stub as well, but stubs do
   # not support any qualifiers about the message received (i.e. you can't specify arguments
@@ -181,7 +171,8 @@ module Spec
   #   my_mock.stub!(:sym).and_return(value1, value2, value3)
   #   my_mock.stub!(:sym).and_raise(error)
   #   my_mock.stub!(:sym).and_throw(:sym)
-  #   my_mock.stub!(:sym).and_yield([array,of,values,to,yield])
+  #   my_mock.stub!(:sym).and_yield(values,to,yield)
+  #   my_mock.stub!(:sym).and_yield(values,to,yield).and_yield(some,other,values,this,time)
   #
   # == Arbitrary Handling
   #
@@ -206,4 +197,4 @@ module Spec
   #   my_mock.should_receive(:<<).with("illegal value").once.and_raise(ArgumentError)
   module Mocks
   end
-end
+end

data/lib/spec/rake/spectask.rb

@@ -8,10 +8,10 @@ require 'rake/tasklib'
 module Spec
   module Rake
 
-    # A Rake task that runs a set of RSpec contexts.
+    # A Rake task that runs a set of specs.
     #
     # Example:
-    #  
+    #
     #   Spec::Rake::SpecTask.new do |t|
     #     t.warning = true
     #     t.rcov = true
@@ -21,7 +21,46 @@ module Spec
     #
     #   rake spec
     #
+    # If rake is invoked with a "SPEC=filename" command line option,
+    # then the list of spec files will be overridden to include only the
+    # filename specified on the command line.  This provides an easy way
+    # to run just one spec.
+    #
+    # If rake is invoked with a "SPEC_OPTS=options" command line option,
+    # then the given options will override the value of the +spec_opts+
+    # attribute.
+    #
+    # If rake is invoked with a "RCOV_OPTS=options" command line option,
+    # then the given options will override the value of the +rcov_opts+
+    # attribute.
+    #
+    # Examples:
+    #
+    #   rake spec                                      # run specs normally
+    #   rake spec SPEC=just_one_file.rb                # run just one spec file.
+    #   rake spec SPEC_OPTS="--diff"                   # enable diffing
+    #   rake spec RCOV_OPTS="--aggregate myfile.txt"   # see rcov --help for details
+    #
+    # Each attribute of this task may be a proc. This allows for lazy evaluation,
+    # which is sometimes handy if you want to defer the evaluation of an attribute value
+    # until the task is run (as opposed to when it is defined).
+    #
+    # This task can also be used to run existing Test::Unit tests and get RSpec
+    # output, for example like this:
+    #
+    #   require 'spec/rake/spectask'
+    #   Spec::Rake::SpecTask.new do |t|
+    #     t.ruby_opts = ['-rtest/unit']
+    #     t.spec_files = FileList['test/**/*_test.rb']
+    #   end
+    #
     class SpecTask < ::Rake::TaskLib
+      def self.attr_accessor(*names)
+        super(*names)
+        names.each do |name|
+          module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs
+        end
+      end
 
       # Name of spec task. (default is :spec)
       attr_accessor :name
@@ -35,21 +74,20 @@ module Spec
       attr_accessor :warning
 
       # Glob pattern to match spec files. (default is 'spec/**/*_spec.rb')
+      # Setting the SPEC environment variable overrides this.
       attr_accessor :pattern
 
       # Array of commandline options to pass to RSpec. Defaults to [].
+      # Setting the SPEC_OPTS environment variable overrides this.
       attr_accessor :spec_opts
 
-      # Where RSpec's output is written. Defaults to STDOUT.
-      # DEPRECATED. Use --format FORMAT:WHERE in spec_opts.
-      attr_accessor :out
-
       # Whether or not to use RCov (default is false)
       # See http://eigenclass.org/hiki.rb?rcov
       attr_accessor :rcov
-      
+
       # Array of commandline options to pass to RCov. Defaults to ['--exclude', 'lib\/spec,bin\/spec'].
       # Ignored if rcov=false
+      # Setting the RCOV_OPTS environment variable overrides this.
       attr_accessor :rcov_opts
 
       # Directory where the RCov report is written. Defaults to "coverage"
@@ -63,82 +101,89 @@ module Spec
       # Defaults to true.
       attr_accessor :fail_on_error
 
-      # A message to print to stdout when there are failures.
+      # A message to print to stderr when there are failures.
       attr_accessor :failure_message
 
+      # Where RSpec's output is written. Defaults to $stdout.
+      # DEPRECATED. Use --format FORMAT:WHERE in spec_opts.
+      attr_accessor :out
+
       # Explicitly define the list of spec files to be included in a
-      # spec.  +list+ is expected to be an array of file names (a
+      # spec.  +spec_files+ is expected to be an array of file names (a
       # FileList is acceptable).  If both +pattern+ and +spec_files+ are
       # used, then the list of spec files is the union of the two.
-      def spec_files=(list)
-        @spec_files = list
-      end
+      # Setting the SPEC environment variable overrides this.
+      attr_accessor :spec_files
+
+      # Use verbose output. If this is set to true, the task will print
+      # the executed spec command to stdout. Defaults to false.
+      attr_accessor :verbose
 
-      # Create a specing task.
+      # Explicitly define the path to the ruby binary, or its proxy (e.g. multiruby)
+      attr_accessor :ruby_cmd
+
+      # Defines a new task, using the name +name+.
       def initialize(name=:spec)
         @name = name
-        @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
+        @libs = ['lib']
         @pattern = nil
         @spec_files = nil
         @spec_opts = []
         @warning = false
         @ruby_opts = []
-        @out = nil
         @fail_on_error = true
         @rcov = false
         @rcov_opts = ['--exclude', 'lib\/spec,bin\/spec,config\/boot.rb']
         @rcov_dir = "coverage"
 
         yield self if block_given?
-        @pattern = 'spec/**/*_spec.rb' if @pattern.nil? && @spec_files.nil?
+        @pattern = 'spec/**/*_spec.rb' if pattern.nil? && spec_files.nil?
         define
       end
 
-      def define
-        spec_script = File.expand_path(File.dirname(__FILE__) + '/../../../bin/spec')
+      def define # :nodoc:
+        spec_script = File.expand_path(File.join(File.dirname(__FILE__),"..","..","..","bin","spec"))
 
-        lib_path = @libs.join(File::PATH_SEPARATOR)
+        lib_path = libs.join(File::PATH_SEPARATOR)
         actual_name = Hash === name ? name.keys.first : name
         unless ::Rake.application.last_comment
-          desc "Run RSpec for #{actual_name}" + (@rcov ? " using RCov" : "")
+          desc "Run specs" + (rcov ? " using RCov" : "")
         end
-        task @name do
-          RakeFileUtils.verbose(@verbose) do
+        task name do
+          RakeFileUtils.verbose(verbose) do
             unless spec_file_list.empty?
-              # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- [spec_opts] examples
+              # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- examples [spec_opts]
               # or
-              # ruby [ruby_opts] -Ilib bin/spec [spec_opts] examples
-              cmd = "ruby "
-
-              ruby_opts = @ruby_opts.clone
-              ruby_opts << "-I\"#{lib_path}\""
-              ruby_opts << "-S rcov" if @rcov
-              ruby_opts << "-w" if @warning
-              cmd << ruby_opts.join(" ")
-              cmd << " "
-              cmd << rcov_option_list
-              cmd << %[ -o "#{@rcov_dir}" ] if @rcov
-              cmd << %Q|"#{spec_script}"|
-              cmd << " "
-              cmd << "-- " if @rcov
-              cmd << spec_file_list.collect { |fn| %["#{fn}"] }.join(' ')
-              cmd << " "
-              cmd << spec_option_list
-              cmd << " "
-              cmd << %Q| > "#{@out}"| if @out
-
+              # ruby [ruby_opts] -Ilib bin/spec examples [spec_opts]
+              cmd_parts = [ruby_cmd || RUBY]
+              cmd_parts += ruby_opts
+              cmd_parts << %[-I"#{lib_path}"]
+              cmd_parts << "-S rcov" if rcov
+              cmd_parts << "-w" if warning
+              cmd_parts << rcov_option_list
+              cmd_parts << %[-o "#{rcov_dir}"] if rcov
+              cmd_parts << %["#{spec_script}"]
+              cmd_parts << "--" if rcov
+              cmd_parts += spec_file_list.collect { |fn| %["#{fn}"] }
+              cmd_parts << spec_option_list
+              if out
+                cmd_parts << %[> "#{out}"]
+                STDERR.puts "The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead."
+              end
+              cmd = cmd_parts.join(" ")
+              puts cmd if verbose
               unless system(cmd)
-               puts @failure_message if @failure_message
-               raise("Command #{cmd} failed") if @fail_on_error
+                STDERR.puts failure_message if failure_message
+                raise("Command #{cmd} failed") if fail_on_error
               end
             end
           end
         end
 
-        if @rcov
+        if rcov
           desc "Remove rcov products for #{actual_name}"
           task paste("clobber_", actual_name) do
-            rm_r @rcov_dir rescue nil
+            rm_r rcov_dir rescue nil
           end
 
           clobber_task = paste("clobber_", actual_name)
@@ -150,12 +195,23 @@ module Spec
       end
 
       def rcov_option_list # :nodoc:
-        return "" unless @rcov
-        ENV['RCOVOPTS'] || @rcov_opts.join(" ") || ""
+        if rcov
+          ENV['RCOV_OPTS'] || rcov_opts.join(" ") || ""
+        else
+          ""
+        end
       end
 
       def spec_option_list # :nodoc:
-        ENV['RSPECOPTS'] || @spec_opts.join(" ") || ""
+        STDERR.puts "RSPECOPTS is DEPRECATED and will be removed in a future version. Use SPEC_OPTS instead." if ENV['RSPECOPTS']
+        ENV['SPEC_OPTS'] || ENV['RSPECOPTS'] || spec_opts.join(" ") || ""
+      end
+
+      def evaluate(o) # :nodoc:
+        case o
+          when Proc then o.call
+          else o
+        end
       end
 
       def spec_file_list # :nodoc:
@@ -163,8 +219,8 @@ module Spec
           FileList[ ENV['SPEC'] ]
         else
           result = []
-          result += @spec_files.to_a if @spec_files
-          result += FileList[ @pattern ].to_a if @pattern
+          result += spec_files.to_a if spec_files
+          result += FileList[ pattern ].to_a if pattern
           FileList[result]
         end
       end
@@ -172,4 +228,3 @@ module Spec
     end
   end
 end
-