puppet 0.23.2 → 0.24.0

data/test/lib/spec/expectations/differs/default.rb

@@ -1,62 +0,0 @@
-begin
-  require 'rubygems'
-  require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
-  require 'diff/lcs/hunk'
-rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
-
-require 'pp'
-
-module Spec
-  module Expectations
-    module Differs
-
-      # TODO add colour support
-      # TODO add some rdoc
-      class Default
-        def initialize(format=:unified,context_lines=nil,colour=nil)
-
-          context_lines ||= 3
-          colour        ||= false
-
-          @format,@context_lines,@colour = format,context_lines,colour
-        end
-
-        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-        def diff_as_string(data_old, data_new)
-          data_old = data_old.split(/\n/).map! { |e| e.chomp }
-          data_new = data_new.split(/\n/).map! { |e| e.chomp }
-          output = ""
-          diffs = Diff::LCS.diff(data_old, data_new)
-          return output if diffs.empty?
-          oldhunk = hunk = nil  
-          file_length_difference = 0
-          diffs.each do |piece|
-            begin
-              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @context_lines,
-                                         file_length_difference)
-              file_length_difference = hunk.file_length_difference      
-              next unless oldhunk      
-              # Hunks may overlap, which is why we need to be careful when our
-              # diff includes lines of context. Otherwise, we might print
-              # redundant lines.
-              if (@context_lines > 0) and hunk.overlaps?(oldhunk)
-                hunk.unshift(oldhunk)
-              else
-                output << oldhunk.diff(@format)
-              end
-            ensure
-              oldhunk = hunk
-              output << "\n"
-            end
-          end  
-          #Handle the last remaining hunk
-          output << oldhunk.diff(@format) << "\n"
-        end  
-
-        def diff_as_object(target,expected)
-          diff_as_string(PP.pp(target,""), PP.pp(expected,""))
-        end
-      end
-    end
-  end
-end

data/test/lib/spec/expectations/errors.rb

@@ -1,6 +0,0 @@
-module Spec
-  module Expectations
-    class ExpectationNotMetError < StandardError
-    end
-  end
-end

data/test/lib/spec/expectations/extensions.rb

@@ -1,3 +0,0 @@
-require 'spec/expectations/extensions/object'
-require 'spec/expectations/extensions/proc'
-require 'spec/expectations/extensions/string_and_symbol'

data/test/lib/spec/expectations/extensions/object.rb

@@ -1,109 +0,0 @@
-module Spec
-  module Expectations
-    # rspec adds #should and #should_not to every Object (and,
-    # implicitly, every Class).
-    module ObjectExpectations
-
-      # :call-seq:
-      #   should(matcher)
-      #   should == expected
-      #   should =~ expected
-      #
-      #   receiver.should(matcher)
-      #     => Passes if matcher.matches?(receiver)
-      #
-      #   receiver.should == expected #any value
-      #     => Passes if (receiver == expected)
-      #
-      #   receiver.should =~ regexp
-      #     => Passes if (receiver =~ regexp)
-      #
-      # See Spec::Matchers for more information about matchers
-      #
-      # == Warning
-      #
-      # NOTE that this does NOT support receiver.should != expected.
-      # Instead, use receiver.should_not == expected
-      def should(matcher=nil, &block)
-        return ExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
-        Should::Should.new(self)
-      end
-
-      # :call-seq:
-      #   should_not(matcher)
-      #   should_not == expected
-      #   should_not =~ expected
-      #
-      #   receiver.should_not(matcher)
-      #     => Passes unless matcher.matches?(receiver)
-      #
-      #   receiver.should_not == expected
-      #     => Passes unless (receiver == expected)
-      #
-      #   receiver.should_not =~ regexp
-      #     => Passes unless (receiver =~ regexp)
-      #
-      # See Spec::Matchers for more information about matchers
-      def should_not(matcher=nil, &block)
-        return NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
-        should.not
-      end
-
-      deprecated do
-        # Deprecated: use should have(n).items (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_have(expected)
-          should.have(expected)
-        end
-        alias_method :should_have_exactly, :should_have
-
-        # Deprecated: use should have_at_least(n).items (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_have_at_least(expected)
-          should.have.at_least(expected)
-        end
-      
-        # Deprecated: use should have_at_most(n).items (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_have_at_most(expected)
-          should.have.at_most(expected)
-        end
-
-        # Deprecated: use should include(expected) (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_include(expected)
-          should.include(expected)
-        end
-
-        # Deprecated: use should_not include(expected) (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_not_include(expected)
-          should.not.include(expected)
-        end
-
-        # Deprecated: use should be(expected) (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_be(expected = :___no_arg)
-          should.be(expected)
-        end
-      
-        # Deprecated: use should_not be(expected) (see Spec::Matchers)
-        # This will be removed in 0.9
-        def should_not_be(expected = :___no_arg)
-          should_not.be(expected)
-        end
-      end
-    end
-  end
-end
-
-class Object
-  include Spec::Expectations::ObjectExpectations
-  deprecated do
-    include Spec::Expectations::UnderscoreSugar
-  end
-end
-
-deprecated do
-  Object.handle_underscores_for_rspec!
-end

data/test/lib/spec/expectations/extensions/proc.rb

@@ -1,57 +0,0 @@
-module Spec
-  module Expectations
-    module ProcExpectations
-      # Given a receiver and a message (Symbol), specifies that the result
-      # of sending that message that receiver should change after
-      # executing the proc.
-      #
-      #   lambda { @team.add player }.should_change(@team.players, :size)
-      #   lambda { @team.add player }.should_change(@team.players, :size).by(1)
-      #   lambda { @team.add player }.should_change(@team.players, :size).to(23)
-      #   lambda { @team.add player }.should_change(@team.players, :size).from(22).to(23)
-      #
-      # You can use a block instead of a message and receiver.
-      #
-      #   lambda { @team.add player }.should_change{@team.players.size}
-      #   lambda { @team.add player }.should_change{@team.players.size}.by(1)
-      #   lambda { @team.add player }.should_change{@team.players.size}.to(23)
-      #   lambda { @team.add player }.should_change{@team.players.size}.from(22).to(23)
-      def should_change(receiver=nil, message=nil, &block)
-        should.change(receiver, message, &block)
-      end
-  
-      # Given a receiver and a message (Symbol), specifies that the result
-      # of sending that message that receiver should NOT change after
-      # executing the proc.
-      #
-      #   lambda { @team.add player }.should_not_change(@team.players, :size)
-      #
-      # You can use a block instead of a message and receiver.
-      #
-      #   lambda { @team.add player }.should_not_change{@team.players.size}
-      def should_not_change(receiver, message)
-        should.not.change(receiver, message)
-      end
-
-      def should_raise(exception=Exception, message=nil)
-        should.raise(exception, message)
-      end
-      
-      def should_not_raise(exception=Exception, message=nil)
-        should.not.raise(exception, message)
-      end
-      
-      def should_throw(symbol)
-        should.throw(symbol)
-      end
-      
-      def should_not_throw(symbol=:___this_is_a_symbol_that_will_likely_never_occur___)
-        should.not.throw(symbol)
-      end
-    end
-  end
-end
-
-class Proc
-  include Spec::Expectations::ProcExpectations
-end

data/test/lib/spec/expectations/extensions/string_and_symbol.rb

@@ -1,17 +0,0 @@
-module Spec
-  module Expectations
-    module StringHelpers
-      def starts_with?(prefix)
-        to_s[0..(prefix.length - 1)] == prefix
-      end
-    end
-  end
-end
-
-class String
-  include Spec::Expectations::StringHelpers
-end
-
-class Symbol
-  include Spec::Expectations::StringHelpers
-end

data/test/lib/spec/expectations/handler.rb

@@ -1,47 +0,0 @@
-module Spec
-  module Expectations
-    
-    module MatcherHandlerHelper
-      def describe(matcher)
-        matcher.respond_to?(:description) ? matcher.description : "[#{matcher.class.name} does not provide a description]"
-      end
-    end
-    
-    class ExpectationMatcherHandler
-      class << self
-        include MatcherHandlerHelper
-        def handle_matcher(actual, matcher, &block)
-          unless matcher.nil?
-            match = matcher.matches?(actual, &block)
-            ::Spec::Matchers.generated_description = "should #{describe(matcher)}"
-            Spec::Expectations.fail_with(matcher.failure_message) unless match
-          end
-        end
-      end
-    end
-
-    class NegativeExpectationMatcherHandler
-      class << self
-        include MatcherHandlerHelper
-        def handle_matcher(actual, matcher, &block)
-          unless matcher.nil?
-            unless matcher.respond_to?(:negative_failure_message)
-              Spec::Expectations.fail_with(
-  <<-EOF
-  Matcher does not support should_not.
-  See Spec::Matchers for more information
-  about matchers.
-  EOF
-  )
-            end
-            match = matcher.matches?(actual, &block)
-            ::Spec::Matchers.generated_description = "should not #{describe(matcher)}"
-            Spec::Expectations.fail_with(matcher.negative_failure_message) if match
-          end
-        end
-      end
-    end
-
-  end
-end
-

data/test/lib/spec/expectations/should.rb

@@ -1,5 +0,0 @@
-require 'spec/expectations/should/base'
-require 'spec/expectations/should/have'
-require 'spec/expectations/should/not'
-require 'spec/expectations/should/should'
-require 'spec/expectations/should/change'

data/test/lib/spec/expectations/should/base.rb

@@ -1,64 +0,0 @@
-module Spec
-  module Expectations
-    module Should
-      class Base
-        
-        #== and =~ will stay after the new syntax
-        def ==(expected)
-          __delegate_method_missing_to_target "==", "==", expected
-        end
-        
-        def =~(expected)
-          __delegate_method_missing_to_target "=~", "=~", expected
-        end
-        
-        #<, <=, >=, > are all implemented in Spec::Matchers::Be
-        # and will be removed with 0.9
-        deprecated do
-          def <(expected)
-            __delegate_method_missing_to_target "<", "<", expected
-          end
-        
-          def <=(expected)
-            __delegate_method_missing_to_target "<=", "<=", expected
-          end
-        
-          def >=(expected)
-            __delegate_method_missing_to_target ">=", ">=", expected
-          end
-        
-          def >(expected)
-            __delegate_method_missing_to_target ">", ">", expected
-          end
-        end
-
-        def default_message(expectation, expected=nil)
-          return "expected #{expected.inspect}, got #{@target.inspect} (using #{expectation})" if expectation == '=='
-          "expected #{expectation} #{expected.inspect}, got #{@target.inspect}" unless expectation == '=='
-        end
-
-        def fail_with_message(message, expected=nil, target=nil)
-          Spec::Expectations.fail_with(message, expected, target)
-        end
-    
-        def find_supported_sym(original_sym)
-          ["#{original_sym}?", "#{original_sym}s?"].each do |alternate_sym|
-            return alternate_sym.to_s if @target.respond_to?(alternate_sym.to_s)
-          end
-        end
-
-        deprecated do
-          def method_missing(original_sym, *args, &block)
-            if original_sym.to_s =~ /^not_/
-              return Not.new(@target).__send__(sym, *args, &block)
-            end
-            if original_sym.to_s =~ /^have_/
-              return have.__send__(original_sym.to_s[5..-1].to_sym, *args, &block)
-            end
-            __delegate_method_missing_to_target original_sym, find_supported_sym(original_sym), *args
-          end
-        end
-      end
-    end
-  end
-end

data/test/lib/spec/expectations/should/change.rb

@@ -1,69 +0,0 @@
-module Spec
-  module Expectations
-    module Should
-      class Change < Base
-
-        def initialize(target, receiver=nil, message=nil, &block)
-          @block = block
-          @target = target
-          @receiver = receiver
-          @message = message
-          execute_change
-          evaluate_change
-        end
-
-        def execute_change
-          @before_change = @block.nil? ? @receiver.send(@message) : @block.call
-          @target.call
-          @after_change = @block.nil? ? @receiver.send(@message) : @block.call
-        end
-        
-        def message
-          @message.nil? ? 'result' : @message
-        end
-
-        def evaluate_change
-          if @before_change == @after_change
-            fail_with_message "#{message} should have changed, but is still #{@after_change.inspect}"
-          end
-        end
-
-        def from(value)
-          if @before_change != value
-            fail_with_message "#{message} should have initially been #{value.inspect}, but was #{@before_change.inspect}"
-          end
-          self
-        end
-
-        def to(value)
-          if @after_change != value
-            fail_with_message "#{message} should have been changed to #{value.inspect}, but is now #{@after_change.inspect}"
-          end
-          self
-        end
-
-        def by(expected_delta)
-          if actual_delta != expected_delta
-            fail_with_message "#{message} should have been changed by #{expected_delta}, but was changed by #{actual_delta}"
-          end
-          self
-        end
-        
-        private
-          def actual_delta
-            @after_change - @before_change
-          end
-      end
-      
-      class NotChange < Change
-        def evaluate_change
-          if @before_change != @after_change
-            fail_with_message "#{@message} should not have changed, but did change from #{@before_change.inspect} to #{@after_change.inspect}"
-          end
-        end
-      end
-
-    end
-  end
-end
-