should_pricot 1.0.0 → 2.0.0

data/test/test-app/vendor/plugins/funktional/lib/funktional/assigned_assertion.rb

@@ -1,39 +0,0 @@
-module Funktional
-  class AssignedAssertion
-    def initialize(klass_or_symbol)
-      if klass_or_symbol.is_a? Symbol
-        @symbol = klass_or_symbol
-      else
-        @klass = klass_or_symbol
-        @symbol = get_symbol_from_klass
-      end
-      
-      @test = Funktional.test_instance
-      @assigned = @test.assigns(@symbol)
-      
-      @test.assert_not_nil @assigned, "No [#{@symbol}] assigned"
-      
-      if @klass
-        @test.assert @assigned.is_a?(@klass), type_safety_failed_msg
-      end
-    end
-    
-    def should_be(expected_value)
-      @test.assert_equal expected_value, @assigned
-    end
-    
-    protected
-    
-    def method_missing(method, *args)
-      RecursiveAssertion.new(@assigned, method)
-    end
-    
-    def get_symbol_from_klass
-      @klass.to_s.tableize.singularize.to_sym
-    end
-    
-    def type_safety_failed_msg
-      "assigned [#{@symbol}] is not a [#{@klass}]"
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/attribute_test_helper.rb

@@ -1,27 +0,0 @@
-module Funktional
-  module AttributeTestHelper
-    
-    def missing_attrib(to_remove)
-      copy_of_attrib = attrib.clone
-      found = copy_of_attrib.delete to_remove
-      raise Exception, 'attribute marked for removal is missing' unless found
-      
-      return copy_of_attrib
-    end
-    
-    def blank_attrib(to_blank)
-      attrib.merge(to_blank => '')
-    end
-    
-    def replace_attrib(to_replace)
-      key = to_replace.keys.first
-      value = to_replace.values.first
-      
-      attrib.merge(key => value)
-    end
-    
-    def add_attrib(addition)
-      attrib.merge(addition)
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/assigned_should_block.rb

@@ -1,32 +0,0 @@
-module Funktional
-  class AssignedShouldBlock < ShouldBlock
-    
-    def initialize(recorder, context)
-      @recorder, @context = recorder, context
-      @should_name = "the assigned(#{@recorder.__target})"
-      
-      @blk = lambda do
-        result = nil
-        
-        recorder.__each_called do |meth, args|
-          if result.nil?
-            result = assigned(recorder.__target).send(meth, *args)
-          else
-            result.send(meth, *args)
-          end
-        end
-      end
-    end
-    
-    def test_name_parts
-      call_chain = ''
-      
-      @recorder.__each_called do |meth, args|
-        call_chain << ".#{meth}" unless meth.eql? :should_be
-      end
-      @should_name << "#{call_chain} should be [#{@recorder.__last_value}]"
-      
-      return ["test:", "#{@context.full_name},", "#{@should_name}"]
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/collector.rb

@@ -1,21 +0,0 @@
-module Funktional
-  class << self
-    attr_accessor :contexts
-    
-    def contexts
-      @contexts ||= []
-    end
-    
-    def current_context
-      self.contexts.last
-    end
-    
-    def add_context(context)
-      self.contexts.push(context)
-    end
-    
-    def remove_context
-      self.contexts.pop
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/count_should_block.rb

@@ -1,21 +0,0 @@
-module Funktional
-  class CountShouldBlock < ShouldBlock
-    
-    def initialize(recorder, context)
-      @recorder, @context = recorder, context
-      @should_name = "count(#{@recorder.__target})"
-      
-      @blk = lambda do
-        count(recorder.__target).send(recorder.__meth(0)[:name], *recorder.__meth(0)[:args])
-      end
-    end
-    
-    def test_name_parts
-      parts = ["test:", "#{@context.full_name},", "#{@should_name}"]
-      parts << @recorder.__meth(0)[:name].to_s.gsub('_', ' ')
-      parts << "[#{@recorder.__meth(0)[:args]}]"
-      
-      return parts
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/delegating_should_block.rb

@@ -1,30 +0,0 @@
-module Funktional
-  class DelegatingShouldBlock < ShouldBlock
-    
-    def initialize(options, context, &blk)
-      @should_name = build_should_name(options, &blk)
-      @blk = proc { should(options, &blk) }
-      @context = context
-    end
-    
-    def build_should_name(options, &blk)
-      case options.keys.first
-        when :render
-          "render the [#{options[:render]}] template"
-        when :render_404
-          "render the [#{options[:render_404]}] template with a [404] status code"
-        when :redirect_to
-          "redirect to the [#{options[:redirect_to]}] url"
-        when :assign_new
-          "assign a new [#{options[:assign_new]}]"
-        when :route, :method
-          args = (options.length > 1) ? options : options.values.first
-          RouteChecker.build(args, &blk).__test_name
-        when :send_email
-          "send an email #{options[:send_email].inspect}"
-        else
-          raise NoMethodError, "#{options.inspect} is not recognised"
-      end
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/element_should_block.rb

@@ -1,29 +0,0 @@
-module Funktional
-  class ElementShouldBlock < ShouldBlock
-    
-    def initialize(recorder, context)
-      @recorder, @context = recorder, context
-      @should_name = "element(#{@recorder.__target})"
-      
-      @blk = lambda do
-        element(recorder.__target).send(recorder.__meth(0)[:name], *recorder.__meth(0)[:args])
-      end
-    end
-    
-    def test_name_parts
-      parts = ["test:", "#{@context.full_name},", "#{@should_name}"]
-      parts << @recorder.__meth(0)[:name].to_s.gsub('_', ' ')
-      
-      if called?(:should_be) or called?(:should_contain)
-        parts << "[#{@recorder.__meth(0)[:args]}]"
-      end
-      return parts
-    end
-    
-    private
-    
-    def called?(name)
-      @recorder.__meth(0)[:name].eql? name
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/flashed_should_block.rb

@@ -1,17 +0,0 @@
-module Funktional
-  class FlashedShouldBlock < ShouldBlock
-    
-    def initialize(recorder, context)
-      @recorder, @context = recorder, context
-      @should_name = "flash[:#{@recorder.__target}]"
-      
-      @blk = lambda do
-        flashed(recorder.__target).send(recorder.__meth(0)[:name], *recorder.__meth(0)[:args])
-      end
-    end
-    
-    def test_name_parts
-      ["test:", "#{@context.full_name},", @should_name, "should be", "[#{@recorder.__meth(0)[:args]}]"]
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/should_block.rb

@@ -1,60 +0,0 @@
-module Funktional
-  class ShouldBlock
-    
-    def self.build(options, context, &blk)
-      return self.new(name = options, context, &blk) if options.is_a? String
-      
-      options = {:render_404 => 'public/404'} if options == :render_404
-      
-      case options.keys.first
-        when :create
-          ShouldCreateBlock.new(options[:create], context)
-        when :delete
-          ShouldDeleteBlock.new(options[:delete], context)
-        else
-          DelegatingShouldBlock.new(options, context, &blk)
-      end
-    end
-    
-    def initialize(should_name, context, &blk)
-      raise 'block required' unless block_given?
-      @should_name, @blk, @context = should_name, blk, context
-    end
-    
-    def to_test
-      context, blk, before = @context, @blk, @before
-      
-      @context.test_unit_class.send(:define_method, build_test_name) do
-        begin
-          context.run_parent_setup_blocks(self)
-          before.bind(self).call if before
-          
-          context.run_current_setup_blocks(self)
-          blk.bind(self).call
-        ensure
-          context.run_all_teardown_blocks(self)
-        end
-      end
-    end
-    
-    protected
-    
-    def test_and_line_no
-      stack_frame = caller.grep(/bind/).last
-      stack_frame.split(':in ').first
-    end
-    
-    def build_test_name
-      test_name = test_name_parts.flatten.join(' ')
-      
-      if @context.test_unit_class.instance_methods.include?(test_name)
-        warn "  * WARNING: '#{test_name}' is already defined"
-      end
-      return test_name.to_sym
-    end
-    
-    def test_name_parts
-      ["test:", @context.full_name, "should", "#{@should_name}."]
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/should_create_block.rb

@@ -1,17 +0,0 @@
-module Funktional
-  class ShouldCreateBlock < ShouldBlock
-    
-    def initialize(klass, context)
-      @context = context
-      @should_name = "create a #{klass}"
-      
-      @before = lambda { @before_setup_count = klass.count }
-      where = test_and_line_no
-      
-      @blk = lambda do
-        expected_count = @before_setup_count + 1
-        assert_equal expected_count, klass.count, "New [#{klass}] was not created. #{where}"
-      end
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/should_delete_block.rb

@@ -1,17 +0,0 @@
-module Funktional
-  class ShouldDeleteBlock < ShouldBlock
-    
-    def initialize(klass, context)
-      @context = context
-      @should_name = "delete a #{klass}"
-      
-      @before = lambda { @before_setup_count = klass.count }
-      where = test_and_line_no
-      
-      @blk = lambda do
-        expected_count = @before_setup_count - 1 
-        assert_equal expected_count, klass.count, "New [#{klass}] was not deleted. #{where}"
-      end
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/should_not_block.rb

@@ -1,20 +0,0 @@
-module Funktional
-  class ShouldNotBlock
-    
-    def self.build(options, context, &blk)
-      
-      if options.is_a? Symbol and options.eql? :send_email
-        return ShouldNotSendEmailBlock.new(context)
-      end
-      
-      case options.keys.first
-        when :create
-          ShouldNotCreateBlock.new(options[:create], context)
-        when :delete
-          ShouldNotDeleteBlock.new(options[:delete], context)
-        else
-          raise "Unknown assertion [should_not #{options.inspect}]"
-      end
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/should_not_create_block.rb

@@ -1,17 +0,0 @@
-module Funktional
-  class ShouldNotCreateBlock < ShouldBlock
-    
-    def initialize(klass, context)
-      @context = context
-      @should_name = "not create a #{klass}"
-      
-      @before = lambda { @before_setup_count = klass.count }
-      where = test_and_line_no
-      
-      @blk = lambda do
-        expected_count = @before_setup_count
-        assert_equal expected_count, klass.count, "New [#{klass}] was created. #{where}"
-      end
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/should_not_delete_block.rb

@@ -1,17 +0,0 @@
-module Funktional
-  class ShouldNotDeleteBlock < ShouldBlock
-    
-    def initialize(klass, context)
-      @context = context
-      @should_name = "not delete a #{klass}"
-      
-      @before = lambda { @before_setup_count = klass.count }
-      where = test_and_line_no
-      
-      @blk = lambda do
-        expected_count = @before_setup_count
-        assert_equal expected_count, klass.count, "New [#{klass}] was deleted. #{where}"
-      end
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/should_not_send_email_block.rb

@@ -1,18 +0,0 @@
-module Funktional
-  class ShouldNotSendEmailBlock < ShouldBlock
-    
-    def initialize(context)
-      @context = context
-      @should_name = "not send an email"
-      
-      @before = lambda { @before_setup_count = ActionMailer::Base.deliveries.size }
-      where = test_and_line_no
-      
-      @blk = lambda do
-        expected_count = @before_setup_count
-        current = ActionMailer::Base.deliveries.size
-        assert_equal expected_count, current, "New [Email] was sent."
-      end
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context/stack_recorder.rb

@@ -1,34 +0,0 @@
-module Funktional
-  class BlankSlate
-    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
-  end
-  
-  class StackRecorder < BlankSlate
-    attr_reader :__target
-    
-    def initialize(target)
-      @__target = target
-      @__methods = []
-    end
-    
-    def __meth(index)
-      @__methods[index]
-    end
-    
-    def __each_called
-      @__methods.each { |meth| yield [meth[:name], meth[:args]] }
-    end
-    
-    def __last_value
-      @__methods.last[:args].first
-    end
-    
-    def method_missing(method_name, *args)
-      @__methods << {
-        :name => method_name,
-        :args => args
-      }
-      return self
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/context.rb

@@ -1,126 +0,0 @@
-# borrowing heavily from shoulda contexts.
-
-module Funktional
-  class Context
-    
-    attr_accessor :name
-    attr_accessor :parent
-    attr_accessor :sub_contexts
-    attr_accessor :setup_blocks
-    attr_accessor :teardown_blocks
-    attr_accessor :should_blocks
-    
-    def initialize(name, parent, &blk)
-      Funktional.add_context(self)
-      self.name = name
-      self.parent = parent
-      self.setup_blocks = []
-      self.teardown_blocks = []
-      self.should_blocks = []
-      self.sub_contexts = []
-      
-      merge_block(&blk)
-      Funktional.remove_context
-    end
-    
-    def merge_block(&blk)
-      blk.bind(self).call
-    end
-    
-    def context(name, &blk)
-      self.sub_contexts << Context.new(name, self, &blk)
-    end
-    
-    def setup(&blk)
-      self.setup_blocks << blk
-    end
-    
-    alias :before :setup
-    
-    def teardown(&blk)
-      self.teardown_blocks << blk
-    end
-    
-    alias :after :teardown
-    
-    def should(options, &blk)
-      self.should_blocks << ShouldBlock.build(options, self, &blk)
-    end
-    
-    def should_not(options, &blk)
-      self.should_blocks << ShouldNotBlock.build(options, self, &blk)
-    end
-    
-    def element(selector)
-      recorder = StackRecorder.new(selector)
-      self.should_blocks << ElementShouldBlock.new(recorder, self)
-      
-      return recorder
-    end
-    
-    def count(selector)
-      recorder = StackRecorder.new(selector)
-      self.should_blocks << CountShouldBlock.new(recorder, self)
-      
-      return recorder
-    end
-    
-    def assigned(target)
-      recorder = StackRecorder.new(target)
-      self.should_blocks << AssignedShouldBlock.new(recorder, self)
-      
-      return recorder
-    end
-    
-    def flashed(kind)
-      recorder = StackRecorder.new(kind)
-      self.should_blocks << FlashedShouldBlock.new(recorder, self)
-      
-      return recorder
-    end
-    
-    def full_name
-      parent_name = parent.full_name if sub_context?
-      return [parent_name, name].join(" ").strip
-    end
-    
-    def sub_context?
-      parent.is_a?(self.class)
-    end
-    
-    def test_unit_class
-      sub_context? ? parent.test_unit_class : parent
-    end
-    
-    def run_all_setup_blocks(binding)
-      run_parent_setup_blocks(binding)
-      run_current_setup_blocks(binding)
-    end
-    
-    def run_parent_setup_blocks(binding)
-      self.parent.run_all_setup_blocks(binding) if sub_context?
-    end
-    
-    def run_current_setup_blocks(binding)
-      setup_blocks.each do |setup_block|
-        setup_block.bind(binding).call
-      end
-    end
-    
-    def run_all_teardown_blocks(binding)
-      teardown_blocks.reverse.each do |teardown_block|
-        teardown_block.bind(binding).call
-      end
-      self.parent.run_all_teardown_blocks(binding) if sub_context?
-    end
-    
-    def build
-      self.should_blocks.map(&:to_test)
-      sub_contexts.each { |context| context.build }
-    end
-    
-    def method_missing(method, *args, &blk)
-      test_unit_class.send(method, *args, &blk)
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/email_assertion.rb

@@ -1,50 +0,0 @@
-module Funktional
-  class EmailAssertion < Funktional::Assertion
-    def initialize(expectations)
-      if ActionMailer::Base.deliveries.size < 1
-        flunk 'No emails have been sent'
-      end
-      
-      email = ActionMailer::Base.deliveries.last
-      
-      expectations.each_key do |key|
-        case key
-          when :from
-            then check_from(expectations[:from], email.from)
-          when :to
-            then check_to(expectations[:to], email.to)
-          when :subject
-            then assert_equal expectations[:subject], email.subject
-          when :containing
-            then check_containing(expectations[:containing], email.body)
-          else
-            flunk "Assertion key: [#{key}] not recognised"
-        end
-      end
-    end
-    
-    def check_from(expected_from, email_from)
-      if email_from.nil?
-        flunk 'email is missing a [from]'
-      end
-      assert_equal expected_from, email_from[0]
-    end
-    
-    def check_to(expected_to, email_to)
-      if email_to.nil?
-        flunk 'email is missing a [to]'
-      end
-      assert_equal expected_to, email_to[0]
-    end
-    
-    def check_containing(should_contain, body)
-      if should_contain.is_a? Array
-        should_contain.each do |should_i|
-          assert_match /#{Regexp.escape(should_i)}/, body
-        end
-      else
-        assert_match /#{Regexp.escape(should_contain)}/, body
-      end
-    end
-  end
-end

data/test/test-app/vendor/plugins/funktional/lib/funktional/flashed_assertion.rb

@@ -1,12 +0,0 @@
-module Funktional
-  class FlashedAssertion < Funktional::Assertion
-    def initialize(symbol)
-      @symbol = symbol
-    end
-    
-    def should_be(expected_value)
-      assert_not_nil flash[@symbol], "Flash is empty [#{expected_value}] expected."
-      assert_equal expected_value, flash[@symbol]
-    end
-  end
-end