rspec_candy 0.1.0

data/.gitignore

@@ -0,0 +1,8 @@
+doc
+pkg
+*.gem
+.idea
+spec/**/app_root/log/*
+Gemfile.lock
+
+

data/README.md

@@ -0,0 +1,7 @@
+Changes from previous versions:
+
+- `new_and_store` has been renamed `create_without_callbacks`
+- `keep_invalid!` has been renamed to `prevent_storage`
+- `Object#should_not_receive_and_execute` has been removed (same as `Object#should_not_receive`)
+- `should_receive_all_with` (over-generic method name for a helper that is rarely useful)
+

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+require "bundler/gem_tasks"
+
+
+desc 'Default: Run all specs.'
+task :default => :all_specs
+
+desc "Run all specs"
+task :all_specs do
+  Dir['spec/**/Rakefile'].sort.each do |rakefile|
+    directory = File.dirname(rakefile)
+    puts '', "\033[44m#{directory}\033[0m", ''
+    env = "SPEC=../../#{ENV['SPEC']} " if ENV['SPEC']
+    system("cd #{directory} && #{env} bundle exec rake")
+  end
+end

data/lib/rspec_candy/helpers/disposable_copy.rb

@@ -0,0 +1,16 @@
+module RSpecCandy
+  module Helpers
+    module DisposableCopy
+
+      def disposable_copy(&body)
+        this = self
+        copy = Class.new(self, &body)
+        copy.singleton_class.send(:define_method, :name) { this.name }
+        copy
+      end
+
+      Class.send(:include, self)
+
+    end
+  end
+end

data/lib/rspec_candy/helpers/it_should_act_like.rb

@@ -0,0 +1,39 @@
+module RSpecCandy
+  module Helpers
+    module ItShouldActLike
+
+      def self.included(by)
+        by.class_eval do
+
+          # Improves it_should_behave_like in some ways:
+          # - It scopes the reused examples so #let und #subject does not bleed into the reusing example groups
+          # - It allows to parametrize the reused example group by appending a hash argument.
+          #   Every key/value pair in the hash will become a #let variable for the reused example group
+          # - You can call it with a block. It will be available to the reused example group as let(:block)
+          def it_should_act_like(shared_example_group, environment = {}, &block)
+            if Switcher.rspec_version == :rspec2
+              warn('"it_should_act_like" is deprecated. Consider using "it_should_behave_like".')
+            end
+
+            description = "as #{shared_example_group}"
+            description << " (#{environment.inspect})" if environment.present?
+            describe description do
+              environment.each do |name, value|
+                let(name) { value }
+              end
+              let(:block) { block } if block
+              it_should_behave_like(shared_example_group)
+            end
+          end
+        end
+      end
+
+      case Switcher.rspec_version
+      when :rspec1
+        Spec::Example::ExampleGroupMethods.send(:include, self)
+      when :rspec2
+        RSpec::Core::ExampleGroup.singleton_class.send(:include, self)
+      end
+    end
+  end
+end

data/lib/rspec_candy/helpers/new_with_stubs.rb

@@ -0,0 +1,16 @@
+module RSpecCandy
+  module Helpers
+    module NewWithStubs
+
+      def new_with_stubs(stubs)
+        obj = new
+        obj.stub_existing stubs
+        obj
+      end
+
+      Class.send(:include, self)
+
+    end
+  end
+end
+

data/lib/rspec_candy/helpers/rails/create_without_callbacks.rb

@@ -0,0 +1,25 @@
+module RSpecCandy
+  module Helpers
+    module Rails
+      module CreateWithoutCallbacks
+
+        def create_without_callbacks(*args)
+          table_name = self.table_name
+          plain_model = Class.new(ActiveRecord::Base) do
+            self.table_name = table_name
+          end
+          plain_record = plain_model.create!(*args)
+          find plain_record.id
+        end
+
+        def new_and_store(*args)
+          warn 'new_and_store is deprecated. Use create_without_callbacks instead.'
+          create_without_callbacks(*args)
+        end
+
+        ActiveRecord::Base.send(:extend, self)
+
+      end
+    end
+  end
+end

data/lib/rspec_candy/helpers/rails/it_should_run_callbacks.rb

@@ -0,0 +1,111 @@
+module RSpecCandy
+  module Helpers
+    module Rails
+      module ItShouldRunCallbacks
+
+        module ExampleGroupMethods
+          def self.included(by)
+            by.class_eval do
+
+              def it_should_run_callbacks_in_order(*callbacks)
+                callbacks.push(:ordered => true)
+                it_should_run_callbacks(*callbacks)
+              end
+
+              def it_should_run_callbacks(*callbacks)
+                options = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
+                reason = callbacks.pop if callbacks.last.is_a?(String)
+                should = ['should run callbacks', callbacks.inspect, ('in order' if options[:ordered]), reason].compact.join ' '
+
+                prose = case Switcher.rspec_version
+                when :rspec1
+                  description_parts.last
+                when :rspec2
+                  description.split(/(?=#)/).last
+                end
+
+                send(:it, should) do
+                  extend ExampleMethods
+                  if subject.class.respond_to?(:state_machine) and defined?(StateMachine)
+                    extend StateMachineExampleMethods
+                  end
+                  callbacks.each do |callback|
+                    expectation = subject.should_receive(callback).once
+                    expectation.ordered if options[:ordered]
+                  end
+                  run_all_callbacks(prose)
+                end
+              end
+            end
+          end
+        end
+
+        module ExampleMethods
+          private
+
+          def run_all_callbacks(prose)
+            run_active_record_callbacks_from_prose(prose)
+          end
+
+          case Switcher.rspec_version
+          when :rspec1
+
+            def run_active_record_callbacks_from_prose(prose)
+              subject.run_callbacks(prose.sub(/^#/, ''))
+            end
+
+          when :rspec2
+
+            def run_active_record_callbacks_from_prose(prose)
+              hook = prose.split.last.sub(/^#/, '')
+              if hook.sub!(/_on_(create|update)$/, '')
+                condition = "validation_context == :#{$1}"
+              else
+                condition = nil
+              end
+              if hook == 'validate'
+                kind = 'before'
+                action = 'validate'
+              else
+                hook =~ /^(before|after|around)_(.*)$/
+                kind = $1
+                action = $2
+              end
+              # Run all matching callbacks
+              subject.send("_#{action}_callbacks").send(kind == 'after' ? :reverse_each : :each) do |callback|
+                if callback.kind.to_s == kind && (condition.nil? || callback.options[:if].include?(condition))
+                  subject.send(callback.filter.to_s.gsub(/[\(,\)]/, '').to_sym) {}
+                end
+              end
+            end
+
+          end
+        end
+
+        module StateMachineExampleMethods
+          def run_all_callbacks(prose)
+            run_state_machine_callbacks_from_prose(prose) or super
+          end
+
+          def run_state_machine_callbacks_from_prose(prose)
+            if parts = prose.match(/^(#\w+) from ([\:\w]+) to ([\:\w]+)$/)
+              name = parts[1].sub(/^#/, '').to_sym
+              from = parts[2].sub(/^:/, '').to_sym
+              to = parts[3].sub(/^:/, '').to_sym
+              transition = StateMachine::Transition.new(subject, subject.class.state_machine, name, from, to)
+              transition.run_callbacks
+            end
+          end
+        end
+
+        case Switcher.rspec_version
+        when :rspec1
+          Spec::Example::ExampleGroupMethods.send(:include, self::ExampleGroupMethods)
+        when :rspec2
+          RSpec::Core::ExampleGroup.singleton_class.send(:include, self::ExampleGroupMethods)
+        end
+
+      end
+    end
+  end
+end

data/lib/rspec_candy/helpers/rails/prevent_storage.rb

@@ -0,0 +1,20 @@
+module RSpecCandy
+  module Helpers
+    module Rails
+      module PreventStorage
+
+        def prevent_storage
+          errors.stub :empty? => false
+        end
+
+        def keep_invalid!
+          warn 'keep_invalid! is deprecated. Use prevent_storage instead.'
+          prevent_storage
+        end
+
+        ActiveRecord::Base.send(:include, self)
+
+      end
+    end
+  end
+end

data/lib/rspec_candy/helpers/should_receive_and_execute.rb

@@ -0,0 +1,38 @@
+module RSpecCandy
+  module Helpers
+    module ShouldReceiveAndExecute
+
+      def should_receive_and_execute(method)
+        method_base = method.to_s.gsub(/([\?\!\=\[\]]+)$/, '')
+        method_suffix = $1
+
+        method_called = "_#{method_base}_called#{method_suffix}"
+        method_with_spy = "#{method_base}_with_spy#{method_suffix}"
+        method_without_spy = "#{method_base}_without_spy#{method_suffix}"
+
+        prototype = respond_to?(:singleton_class) ? singleton_class : metaclass
+        prototype.class_eval do
+
+          unless method_defined?(method_with_spy)
+
+            define_method method_called do
+            end
+
+            define_method method_with_spy do |*args, &block|
+              send(method_called, *args)
+              send(method_without_spy, *args, &block)
+            end
+            alias_method_chain method, :spy
+          end
+
+        end
+
+        should_receive(method_called)
+      end
+
+      Object.send(:include, self)
+
+    end
+  end
+end
+

data/lib/rspec_candy/helpers/should_receive_and_return.rb

@@ -0,0 +1,17 @@
+module RSpecCandy
+  module Helpers
+    module ShouldReceiveAndReturn
+
+      def should_receive_and_return(methods_and_values)
+        methods_and_values.each do |method, value|
+          should_receive(method).and_return(value)
+        end
+        self
+      end
+
+      Object.send(:include, self)
+
+    end
+  end
+end
+

data/lib/rspec_candy/helpers/should_receive_chain.rb

@@ -0,0 +1,43 @@
+module RSpecCandy
+  module Helpers
+    module ShouldReceiveChain
+
+      def should_receive_chain(*parts)
+        setup_expectation_chain(parts)
+      end
+
+      def should_not_receive_chain(*parts)
+        setup_expectation_chain(parts, :negate => true)
+      end
+
+      private
+
+      def setup_expectation_chain(parts, options = {})
+        obj = self
+        for part in parts
+          if part == parts.last
+            expectation = options[:negate] ? :should_not_receive : :should_receive
+            obj = add_expectation_chain_link(obj, expectation, part)
+          else
+            next_obj = Switcher.new_mock('chain link')
+            add_expectation_chain_link(obj, :stub, part).and_return(next_obj)
+            obj = next_obj
+          end
+        end
+        obj
+      end
+
+      def add_expectation_chain_link(obj, expectation, part)
+        if part.is_a?(Array)
+          obj.send(expectation, part.first).with(*part[1..-1])
+        else
+          obj.send(expectation, part)
+        end
+      end
+
+      Object.send(:include, self)
+
+    end
+  end
+end
+

data/lib/rspec_candy/helpers/stub_any_instance.rb

@@ -0,0 +1,25 @@
+module RSpecCandy
+  module Helpers
+    module StubAnyInstance
+
+      def stub_any_instance(stubs)
+        case Switcher.rspec_version
+        when :rspec1
+          unstubbed_new = method(:new)
+          stub(:new).and_return do |*args|
+            unstubbed_new.call(*args).tap do |obj|
+              obj.stub stubs
+            end
+          end
+          stubs
+        when :rspec2
+          any_instance.stub(stubs)
+        end
+      end
+
+      Class.send(:include, self)
+
+    end
+  end
+end
+

data/lib/rspec_candy/helpers/stub_existing.rb

@@ -0,0 +1,20 @@
+module RSpecCandy
+  module Helpers
+    module StubExisting
+
+      def stub_existing(attrs)
+        attrs.each do |method, value|
+          if respond_to?(method, true)
+            stub(method => value)
+          else
+            raise "Attempted to stub non-existing method ##{method} on #{inspect}"
+          end
+        end
+      end
+
+      Object.send(:include, self)
+      
+    end
+  end
+end
+

data/lib/rspec_candy/switcher.rb

@@ -0,0 +1,44 @@
+module RSpecCandy
+  module Switcher
+    extend self
+
+    def rspec_version
+      if defined?(RSpec)
+        :rspec2
+      elsif defined?(Spec)
+        :rspec1
+      else
+        raise 'Cannot determine RSpec version'
+      end
+    end
+
+    def rails_version
+      if Rails.version.to_i < 3
+        :rails2
+      else
+        :rails3
+      end
+    end
+
+    def rails_loaded?
+      defined?(Rails)
+    end
+
+    def new_mock(*args)
+      rspec_root.const_get(:Mocks).const_get(:Mock).new(*args)
+    end
+
+    def rspec_root
+      (defined?(RSpec) ? RSpec : Spec)
+    end
+
+    def rspec_matcher_registry
+      rspec_root.const_get(:Matchers)
+    end
+
+    def define_matcher(*args, &block)
+      rspec_matcher_registry.define(*args, &block)
+    end
+
+  end
+end