should_pricot 1.0.0

data/test/test-app/vendor/plugins/funktional/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the should_b plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the should_b plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ShouldB'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/test/test-app/vendor/plugins/funktional/init.rb

@@ -0,0 +1,8 @@
+if RAILS_ENV.eql? 'test'
+  require File.join(File.dirname(__FILE__), "lib", "funktional")
+end
+
+if RAILS_ENV.eql? 'test' or $0 == 'irb'
+  require 'funktional/random_characters'
+  Integer.send :include, Funktional::RandomCharacters
+end

data/test/test-app/vendor/plugins/funktional/install.rb

@@ -0,0 +1 @@
+# Install hook code here

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

@@ -0,0 +1,41 @@
+Rails.backtrace_cleaner.add_silencer { |line| line =~ /funktional/ }
+
+require 'test_help'
+
+require 'funktional/test_instance_methods'
+require 'funktional/test_class_methods'
+
+require 'funktional/assertion'
+require 'funktional/assigned_assertion'
+require 'funktional/email_assertion'
+require 'funktional/flashed_assertion'
+require 'funktional/model_assertions'
+require 'funktional/route_checker'
+require 'funktional/attribute_test_helper'
+
+require 'funktional/context'
+require 'funktional/context/stack_recorder'
+require 'funktional/context/should_block'
+require 'funktional/context/should_not_block'
+require 'funktional/context/delegating_should_block'
+require 'funktional/context/should_create_block'
+require 'funktional/context/should_not_create_block'
+require 'funktional/context/should_not_delete_block'
+require 'funktional/context/should_not_send_email_block'
+require 'funktional/context/should_delete_block'
+require 'funktional/context/element_should_block'
+require 'funktional/context/count_should_block'
+require 'funktional/context/flashed_should_block'
+require 'funktional/context/assigned_should_block'
+require 'funktional/context/collector'
+
+require 'funktional/setup'
+
+ActiveRecord::Base.send(:include, Funktional::ModelAssertions)
+
+ActiveSupport::TestCase.send(:include, Funktional::TestInstanceMethods)
+ActiveSupport::TestCase.send :extend, Funktional::TestClassMethods
+ActiveSupport::TestCase.send(:include, Funktional::AttributeTestHelper)
+
+ActiveSupport::TestCase.send(:include, Funktional::Setup)
+

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

@@ -0,0 +1,9 @@
+module Funktional
+  class Assertion
+    protected
+    
+    def method_missing(method, *args)
+      Funktional.test_instance.send method, *args
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,27 @@
+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.rb

@@ -0,0 +1,126 @@
+# 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/context/assigned_should_block.rb

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,17 @@
+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