rspec-core 2.99.2 → 3.0.0.beta1

data/lib/rspec/core/memoized_helpers.rb

@@ -5,8 +5,6 @@ module RSpec
       #   syntax embraced by shoulda matchers:
       #
       #       describe Widget do
-      #         it { is_expected.to validate_presence_of(:name) }
-      #         # or
       #         it { should validate_presence_of(:name) }
       #       end
       #
@@ -33,10 +31,8 @@ module RSpec
       #     end
       #   end
       #
-      #   # one-liner syntax - expectation is set on the subject
+      #   # one-liner syntax - should is invoked on subject
       #   describe Person do
-      #     it { is_expected.to be_eligible_to_vote }
-      #     # or
       #     it { should be_eligible_to_vote }
       #   end
       #
@@ -68,11 +64,6 @@ module RSpec
       #   end
       #
       # @see #subject
-      # @see #is_expected
-      #
-      # @note This only works if you are using rspec-expectations.
-      # @note If you are using RSpec's newer expect-based syntax you may
-      #       want to use `is_expected.to` instead of `should`.
       def should(matcher=nil, message=nil)
         RSpec::Expectations::PositiveExpectationHandler.handle_matcher(subject, matcher, message)
       end
@@ -87,34 +78,10 @@ module RSpec
       #   end
       #
       # @see #subject
-      # @see #is_expected
-      #
-      # @note This only works if you are using rspec-expectations.
-      # @note If you are using RSpec's newer expect-based syntax you may
-      #       want to use `is_expected.to_not` instead of `should_not`.
       def should_not(matcher=nil, message=nil)
         RSpec::Expectations::NegativeExpectationHandler.handle_matcher(subject, matcher, message)
       end
 
-      # Wraps the `subject` in `expect` to make it the target of an expectation.
-      # Designed to read nicely for one-liners.
-      #
-      # @example
-      #
-      #   describe [1, 2, 3] do
-      #     it { is_expected.to be_an Array }
-      #     it { is_expected.not_to include 4 }
-      #   end
-      #
-      # @see #subject
-      # @see #should
-      # @see #should_not
-      #
-      # @note This only works if you are using rspec-expectations.
-      def is_expected
-        expect(subject)
-      end
-
       private
 
       # @private
@@ -128,85 +95,61 @@ module RSpec
       # @private
       class AllHookMemoizedHash
         def self.isolate_for_all_hook(example_group_instance)
-          hash_type = self
+          hash = self
 
           example_group_instance.instance_eval do
-            @__memoized = hash_type.new(example_group_instance)
+            @__memoized = hash
 
             begin
               yield
             ensure
-              @__memoized.preserve_accessed_lets
               @__memoized = nil
             end
           end
         end
 
-        def initialize(example_group_instance)
-          @example_group_instance = example_group_instance
-          @hash = {}
-        end
-
-        def fetch(key, &block)
+        def self.fetch(key, &block)
           description = if key == :subject
             "subject"
           else
             "let declaration `#{key}`"
           end
 
-          ::RSpec.warn_deprecation <<-EOS
-DEPRECATION: #{description} accessed in #{article} #{hook_expression} hook at:
+          raise <<-EOS
+#{description} accessed in #{article} #{hook_expression} hook at:
   #{CallerFilter.first_non_rspec_line}
 
 `let` and `subject` declarations are not intended to be called
 in #{article} #{hook_expression} hook, as they exist to define state that
 is reset between each example, while #{hook_expression} exists to
 #{hook_intention}.
-
-This is deprecated behavior that will not be supported in RSpec 3.
 EOS
-          @hash.fetch(key, &block)
-        end
-
-        def []=(key, value)
-          @hash[key] = value
-        end
-
-        def preserve_accessed_lets
-          hash = @hash
-
-          @example_group_instance.class.class_eval do
-            hash.each do |key, value|
-              undef_method(key) if method_defined?(key)
-              define_method(key) { value }
-            end
-          end
         end
 
         class Before < self
-          def hook_expression
+          def self.hook_expression
             "`before(:all)`"
           end
 
-          def article
+          def self.article
             "a"
           end
 
-          def hook_intention
+          def self.hook_intention
             "define state that is shared across examples in an example group"
           end
         end
 
         class After < self
-          def hook_expression
+          def self.hook_expression
             "`after(:all)`"
           end
 
-          def article
+          def self.article
             "an"
           end
 
-          def hook_intention
+          def self.hook_intention
             "cleanup state that is shared across examples in an example group"
           end
         end
@@ -322,9 +265,8 @@ EOS
           before { __send__(name) }
         end
 
-        # Declares a `subject` for an example group which can then be wrapped
-        # with `expect` using `is_expected` to make it the target of an expectation
-        # in a concise, one-line example.
+        # Declares a `subject` for an example group which can then be the
+        # implicit receiver (through delegation) of calls to `should`.
         #
         # Given a `name`, defines a method with that name which returns the
         # `subject`. This lets you declare the subject once and access it
@@ -339,13 +281,13 @@ EOS
         #
         #   describe CheckingAccount, "with $50" do
         #     subject { CheckingAccount.new(Money.new(50, :USD)) }
-        #     it { is_expected.to have_a_balance_of(Money.new(50, :USD)) }
-        #     it { is_expected.not_to be_overdrawn }
+        #     it { should have_a_balance_of(Money.new(50, :USD)) }
+        #     it { should_not be_overdrawn }
         #   end
         #
         #   describe CheckingAccount, "with a non-zero starting balance" do
         #     subject(:account) { CheckingAccount.new(Money.new(50, :USD)) }
-        #     it { is_expected.not_to be_overdrawn }
+        #     it { should_not be_overdrawn }
         #     it "has a balance equal to the starting balance" do
         #       account.balance.should eq(Money.new(50, :USD))
         #     end
@@ -422,98 +364,6 @@ EOS
           subject(name, &block)
           before { subject }
         end
-
-        # Creates a nested example group named by the submitted `attribute`,
-        # and then generates an example using the submitted block.
-        #
-        # @example
-        #
-        #   # This ...
-        #   describe Array do
-        #     its(:size) { should eq(0) }
-        #   end
-        #
-        #   # ... generates the same runtime structure as this:
-        #   describe Array do
-        #     describe "size" do
-        #       it "should eq(0)" do
-        #         subject.size.should eq(0)
-        #       end
-        #     end
-        #   end
-        #
-        # The attribute can be a `Symbol` or a `String`. Given a `String`
-        # with dots, the result is as though you concatenated that `String`
-        # onto the subject in an expression.
-        #
-        # @example
-        #
-        #   describe Person do
-        #     subject do
-        #       Person.new.tap do |person|
-        #         person.phone_numbers << "555-1212"
-        #       end
-        #     end
-        #
-        #     its("phone_numbers.first") { should eq("555-1212") }
-        #   end
-        #
-        # When the subject is a `Hash`, you can refer to the Hash keys by
-        # specifying a `Symbol` or `String` in an array.
-        #
-        # @example
-        #
-        #   describe "a configuration Hash" do
-        #     subject do
-        #       { :max_users => 3,
-        #         'admin' => :all_permissions }
-        #     end
-        #
-        #     its([:max_users]) { should eq(3) }
-        #     its(['admin']) { should eq(:all_permissions) }
-        #
-        #     # You can still access to its regular methods this way:
-        #     its(:keys) { should include(:max_users) }
-        #     its(:count) { should eq(2) }
-        #   end
-        #
-        # Note that this method does not modify `subject` in any way, so if you
-        # refer to `subject` in `let` or `before` blocks, you're still
-        # referring to the outer subject.
-        #
-        # @example
-        #
-        #   describe Person do
-        #     subject { Person.new }
-        #     before { subject.age = 25 }
-        #     its(:age) { should eq(25) }
-        #   end
-        def its(attribute, &block)
-          RSpec.deprecate("Use of rspec-core's `its` method", :replacement => 'the rspec-its gem')
-
-          describe(attribute.to_s) do
-            if Array === attribute
-              let(:__its_subject) { subject[*attribute] }
-            else
-              let(:__its_subject) do
-                attribute_chain = attribute.to_s.split('.')
-                attribute_chain.inject(subject) do |inner_subject, attr|
-                  inner_subject.send(attr)
-                end
-              end
-            end
-
-            def should(matcher=nil, message=nil)
-              RSpec::Expectations::PositiveExpectationHandler.handle_matcher(__its_subject, matcher, message)
-            end
-
-            def should_not(matcher=nil, message=nil)
-              RSpec::Expectations::NegativeExpectationHandler.handle_matcher(__its_subject, matcher, message)
-            end
-
-            example(&block)
-          end
-        end
       end
 
       # @api private

data/lib/rspec/core/metadata.rb

@@ -25,9 +25,6 @@ module RSpec
     # @see Configuration#filter_run_including
     # @see Configuration#filter_run_excluding
     class Metadata < Hash
-      class << self
-        attr_accessor :line_number_filter_deprecation_issued
-      end
 
       def self.relative_path(line)
         line = line.sub(File.expand_path("."), ".")
@@ -39,6 +36,20 @@ module RSpec
       end
 
       # @private
+      # Used internally to build a hash from an args array.
+      # Symbols are converted into hash keys with a value of `true`.
+      # This is done to support simple tagging using a symbol, rather
+      # than needing to do `:symbol => true`.
+      def self.build_hash_from(args)
+        hash = args.last.is_a?(Hash) ? args.pop : {}
+
+        while args.last.is_a?(Symbol)
+          hash[args.pop] = true
+        end
+
+        hash
+      end
+
       module MetadataHash
 
         # @private
@@ -130,30 +141,6 @@ module RSpec
         include MetadataHash
 
         def described_class
-          warn_about_first_description_arg_behavioral_change_in_rspec_3
-
-          value_for_rspec_2 = described_class_for_rspec_2
-          value_for_rspec_3 = described_class_for_rspec_3
-
-          if value_for_rspec_2 != value_for_rspec_3
-            RSpec.warn_deprecation(<<-EOS.gsub(/^\s+\|/, ''))
-              |The semantics of `described_class` in a nested `describe <SomeClass>`
-              |example group are changing in RSpec 3. In RSpec 2.x, `described_class`
-              |would return the outermost described class (#{value_for_rspec_2.inspect}).
-              |In RSpec 3, it will return the innermost described class (#{value_for_rspec_3.inspect}).
-              |In general, we recommend not describing multiple classes or objects in a
-              |nested manner as it creates confusion.
-              |
-              |To make your code compatible with RSpec 3, change from `described_class` to a reference
-              |to `#{value_for_rspec_3.inspect}`, or change the arg of the inner `describe` to a string.
-              |(Called from #{CallerFilter.first_non_rspec_line})
-            EOS
-          end
-
-          value_for_rspec_2
-        end
-
-        def described_class_for_rspec_2
           container_stack.each do |g|
             [:described_class, :describes].each do |key|
               if g.has_key?(key)
@@ -171,33 +158,8 @@ module RSpec
           nil
         end
 
-        def described_class_for_rspec_3
-          container_stack.each do |g|
-            [:described_class, :describes].each do |key|
-              if g.has_key?(key)
-                value = g[key]
-                return value unless value.nil?
-              end
-            end
-
-            candidate = g[:description_args].first
-            return candidate unless NilClass === candidate || String === candidate || Symbol === candidate
-          end
-
-          nil
-        end
-
-        def warn_about_first_description_arg_behavioral_change_in_rspec_3
-          return unless behavior_change = self[:description_arg_behavior_changing_in_rspec_3]
-          RSpec.warn_deprecation(behavior_change.warning)
-        end
-
-        def first_description_arg
-          self[:description_args].first
-        end
-
         def full_description
-          build_description_from(*container_stack.reverse.map {|a| a[:description_args]}.flatten)
+          build_description_from(*FlatMap.flat_map(container_stack.reverse) {|a| a[:description_args]})
         end
 
         def container_stack
@@ -230,7 +192,6 @@ module RSpec
 
         self[:example_group].store(:description_args, args)
         self[:example_group].store(:caller, user_metadata.delete(:caller) || caller)
-        self[:example_group][:description_arg_behavior_changing_in_rspec_3] = user_metadata.delete(:description_arg_behavior_changing_in_rspec_3)
 
         update(user_metadata)
       end
@@ -253,16 +214,7 @@ module RSpec
       # @private
       def filter_applies?(key, value, metadata=self)
         return metadata.filter_applies_to_any_value?(key, value) if Array === metadata[key] && !(Proc === value)
-
-        if key == :line_numbers
-          unless Metadata.line_number_filter_deprecation_issued
-            RSpec.deprecate("Filtering by `:line_numbers`",
-                            :replacement => "filtering by `:locations`")
-          end
-
-          return metadata.line_number_filter_applies?(value)
-        end
-
+        return metadata.line_number_filter_applies?(value)       if key == :line_numbers
         return metadata.location_filter_applies?(value)          if key == :locations
         return metadata.filters_apply?(key, value)               if Hash === value
 

data/lib/rspec/core/option_parser.rb

@@ -14,7 +14,6 @@ module RSpec::Core
     def parse!(args)
       return {} if args.empty?
 
-      pre_parse(args)
       convert_deprecated_args(args)
 
       options = args.delete('--tty') ? {:tty => true} : {}
@@ -31,10 +30,9 @@ module RSpec::Core
       args.map! { |arg|
         case arg
         when "--formatter"
-          RSpec.deprecate("The `--formatter` option", :replacement => "-f or --format", :call_site => nil)
+          RSpec.deprecate("the --formatter option", :replacement => "-f or --format")
           "--format"
         when "--default_path"
-          RSpec.deprecate("The `--default_path` option", :replacement => "--default-path", :call_site => nil)
           "--default-path"
         when "--line_number"
           "--line-number"
@@ -65,35 +63,34 @@ module RSpec::Core
         end
 
         parser.on('--order TYPE[:SEED]', 'Run examples by the specified order type.',
-                  '  [defined] groups and examples are run in the order they are defined',
-                  '  [default] deprecated alias for defined',
-                  '  [rand]    randomize the order of files, groups and examples',
+                  '  [defined] examples and groups are run in the order they are defined',
+                  '  [rand]    randomize the order of groups and examples',
                   '  [random]  alias for rand',
                   '  [random:SEED] e.g. --order random:123') do |o|
-          options[:order] = if o == 'default'
-                              RSpec.deprecate("RSpec's `--order default` CLI option", :replacement => "`--order defined`", :call_site => nil)
-                              'defined'
-                            else
-                              o
-                            end
+          options[:order] = o
         end
 
         parser.on('--seed SEED', Integer, 'Equivalent of --order rand:SEED.') do |seed|
           options[:order] = "rand:#{seed}"
         end
 
-        parser.on('-d', '--debugger', 'Enable debugging.') do |o|
-          options[:debug] = :cli
-        end
-
         parser.on('--fail-fast', 'Abort the run on first failure.') do |o|
           options[:fail_fast] = true
         end
 
+        parser.on('--no-fail-fast', 'Do not abort the run on first failure.') do |o|
+          options[:fail_fast] = false
+        end
+
         parser.on('--failure-exit-code CODE', Integer, 'Override the exit code used when there are failing specs.') do |code|
           options[:failure_exit_code] = code
         end
 
+        parser.on('--dry-run', 'Print the formatter output of your suite without',
+                  '  running any examples or hooks') do |o|
+          options[:dry_run] = true
+        end
+
         parser.on('-X', '--[no-]drb', 'Run examples via DRb.') do |o|
           options[:drb] = o
         end
@@ -103,12 +100,13 @@ module RSpec::Core
         end
 
         parser.on('--init', 'Initialize your project with RSpec.') do |cmd|
+          require 'rspec/core/project_initializer'
           ProjectInitializer.new(cmd).run
           exit
         end
 
         parser.on('--configure', 'Deprecated. Use --init instead.') do |cmd|
-          warn "--configure is deprecated with no effect. Use --init instead."
+          RSpec.warning "--configure is deprecated with no effect. Use --init instead.", :call_site => nil
           exit
         end
 
@@ -118,7 +116,6 @@ module RSpec::Core
                 '  [p]rogress (default - dots)',
                 '  [d]ocumentation (group and example names)',
                 '  [h]tml',
-                '  [t]extmate',
                 '  [j]son',
                 '  custom formatter class name') do |o|
           options[:formatters] ||= []
@@ -134,11 +131,6 @@ module RSpec::Core
           options[:formatters].last << o
         end
 
-        parser.on('--deprecation-out FILE', 'Write deprecation warnings to a file instead of $stdout.') do |file|
-          # Handled in `pre_parse` so we can set the deprecation stream as early as
-          # possible in case any other options cause deprecations to be issued.
-        end
-
         parser.on('-b', '--backtrace', 'Enable full backtrace.') do |o|
           options[:full_backtrace] = true
         end
@@ -156,9 +148,10 @@ module RSpec::Core
                                          begin
                                            Integer(argument)
                                          rescue ArgumentError
-                                           Kernel.warn "Non integer specified as profile count, seperate " +
+                                           RSpec.warning "Non integer specified as profile count, seperate " +
                                                        "your path from options with -- e.g. " +
-                                                       "`rspec --profile -- #{argument}`"
+                                                       "`rspec --profile -- #{argument}`",
+                                                       :call_site => nil
                                            true
                                          end
                                        end
@@ -191,10 +184,6 @@ FILTERING
 
         parser.on('-l', '--line-number LINE', 'Specify line number of an example or group (may be',
                                               '  used more than once).') do |o|
-          Metadata.line_number_filter_deprecation_issued = true
-          RSpec.deprecate("The `--line-number`/`-l` CLI option",
-                          :replacement => "the `path/to/file.rb:num` form",
-                          :call_site => nil)
           (options[:line_numbers] ||= []) << o
         end
 
@@ -205,11 +194,21 @@ FILTERING
                   '  - TAG is always converted to a symbol') do |tag|
           filter_type = tag =~ /^~/ ? :exclusion_filter : :inclusion_filter
 
-          name,value = tag.gsub(/^(~@|~|@)/, '').split(':')
+          name,value = tag.gsub(/^(~@|~|@)/, '').split(':',2)
           name = name.to_sym
 
           options[filter_type] ||= {}
-          options[filter_type][name] = value.nil? ? true : eval(value) rescue value
+          options[filter_type][name] = case value
+                                         when  nil        then true # The default value for tags is true
+                                         when 'true'      then true
+                                         when 'false'     then false
+                                         when 'nil'       then nil
+                                         when /^:/        then value[1..-1].to_sym
+                                         when /^\d+$/     then Integer(value)
+                                         when /^\d+.\d+$/ then Float(value)
+                                       else
+                                         value
+                                       end
         end
 
         parser.on('--default-path PATH', 'Set the default path where RSpec looks for examples (can',
@@ -231,13 +230,5 @@ FILTERING
 
       end
     end
-
-    def pre_parse(args)
-      args.each_cons(2) do |arg, value|
-        if arg == "--deprecation-out"
-          RSpec.configuration.deprecation_stream = value
-        end
-      end
-    end
   end
 end