deckshuffler 0.0.2

data/vendor/plugins/rspec/lib/spec/dsl/behaviour_description.rb

@@ -0,0 +1,85 @@
+module Spec
+  module DSL
+    class BehaviourDescription
+      module ClassMethods
+        def generate_description(*args)
+          description = args.shift.to_s
+          until args.empty?
+            suffix = args.shift.to_s
+            description << " " unless suffix =~ /^\s|\.|#/
+            description << suffix
+          end
+          description
+        end
+      end
+      extend ClassMethods
+
+      attr_reader :description, :described_type
+      
+      def initialize(*args)
+        args, @options = args_and_options(*args)
+        init_behaviour_type(@options)
+        init_spec_path(@options)
+        init_described_type(args)
+        init_description(*args)
+      end
+  
+      def [](key)
+        @options[key]
+      end
+      
+      def []=(key, value)
+        @options[key] = value
+      end
+      
+      def to_s; @description; end
+      
+      def ==(value)
+        case value
+        when BehaviourDescription
+          @description == value.description
+        else
+          @description == value
+        end
+      end
+      
+    private
+      def init_behaviour_type(options)
+        # NOTE - BE CAREFUL IF CHANGING THIS NEXT LINE:
+        #   this line is as it is to satisfy JRuby - the original version
+        #   read, simply: "if options[:behaviour_class]", which passed against ruby, but failed against jruby
+        if options[:behaviour_class] && options[:behaviour_class].ancestors.include?(ExampleModule)
+          options[:behaviour_type] ||= parse_behaviour_type(@options[:behaviour_class])
+        end
+      end
+      
+      def init_spec_path(options)
+        if options.has_key?(:spec_path)
+          options[:spec_path] = File.expand_path(@options[:spec_path])
+        end
+      end
+      
+      def init_description(*args)
+        @description = self.class.generate_description(*args)
+      end
+      
+      def init_described_type(args)
+        @described_type = args.find{|arg| Module === arg}
+      end
+    
+      def parse_behaviour_type(behaviour_class)
+        class_name = get_class_name(behaviour_class)
+        parsed_class_name = class_name.split("::").reverse[0].gsub('Example', '')
+        return nil if parsed_class_name.empty?
+        parsed_class_name.downcase.to_sym
+      end
+
+      def get_class_name(behaviour_class)
+        unless behaviour_class.name.empty?
+          return behaviour_class.name
+        end
+        get_class_name(behaviour_class.superclass)
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/behaviour_factory.rb

@@ -0,0 +1,59 @@
+module Spec
+  module DSL
+    class BehaviourFactory
+      BEHAVIOURS = {
+        :default => Spec::DSL::Example,
+        :shared => Spec::DSL::SharedBehaviour
+      }      
+      class << self
+        # Registers a behaviour class +klass+ with the symbol
+        # +type+. For example:
+        #
+        #   Spec::DSL::BehaviourFactory.add_example_class(:farm, Spec::Farm::DSL::FarmBehaviour)
+        #
+        # This will cause Main#describe from a file living in 
+        # <tt>spec/farm</tt> to create behaviour instances of type
+        # Spec::Farm::DSL::FarmBehaviour.
+        def add_example_class(type, klass)
+          BEHAVIOURS[type] = klass
+        end
+        def add_behaviour_class(type, klass)
+          warn "add_behaviour_class is deprecated. Use add_example_class instead."
+          add_example_class(type, klass)
+        end
+        
+        def remove_example_class(type)
+          BEHAVIOURS.delete(type)
+        end
+
+        def create(*args, &block)
+          opts = Hash === args.last ? args.last : {}
+          if opts[:shared]
+            type = :shared
+            return create_shared_module(*args, &block)
+            
+          # new: replaces behaviour_type  
+          elsif opts[:type]
+            type = opts[:type]
+            
+          #backwards compatibility
+          elsif opts[:behaviour_type]
+            type = opts[:behaviour_type]
+            
+          elsif opts[:spec_path] =~ /spec(\\|\/)(#{BEHAVIOURS.keys.join('|')})/
+            type = $2.to_sym
+          else
+            type = :default
+          end
+          example_class = Class.new(BEHAVIOURS[type])
+          example_class.describe(*args, &block)
+        end
+
+        protected
+        def create_shared_module(*args, &block)
+          BEHAVIOURS[:shared].new(*args, &block)
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/configuration.rb

@@ -0,0 +1,137 @@
+module Spec
+  module DSL
+    class Configuration
+      
+      # Chooses what mock framework to use. Example:
+      #
+      #   Spec::Runner.configure do |config|
+      #     config.mock_with :rspec, :mocha, :flexmock, or :rr
+      #   end
+      #
+      # To use any other mock framework, you'll have to provide
+      # your own adapter. This is simply a module that responds to
+      # setup_mocks_for_rspec, verify_mocks_for_rspec and teardown_mocks_for_rspec.
+      # These are your hooks into the lifecycle of a given example. RSpec will
+      # call setup_mocks_for_rspec before running anything else in each Example.
+      # After executing the #after methods, RSpec will then call verify_mocks_for_rspec
+      # and teardown_mocks_for_rspec (this is guaranteed to run even if there are
+      # failures in verify_mocks_for_rspec).
+      #
+      # Once you've defined this module, you can pass that to mock_with:
+      #
+      #   Spec::Runner.configure do |config|
+      #     config.mock_with MyMockFrameworkAdapter
+      #   end
+      #
+      def mock_with(mock_framework)
+        @mock_framework = case mock_framework
+        when Symbol
+          mock_framework_path(mock_framework.to_s)
+        else
+          mock_framework
+        end
+      end
+      
+      def mock_framework # :nodoc:
+        @mock_framework ||= mock_framework_path("rspec")
+      end
+      
+      # Declares modules to be included in all behaviours (<tt>describe</tt> blocks).
+      #
+      #   config.include(My::Bottle, My::Cup)
+      #
+      # If you want to restrict the inclusion to a subset of all the behaviours then
+      # specify this in a Hash as the last argument:
+      #
+      #   config.include(My::Pony, My::Horse, :behaviour_type => :farm)
+      #
+      # Only behaviours that have that type will get the modules included:
+      #
+      #   describe "Downtown", :behaviour_type => :city do
+      #     # Will *not* get My::Pony and My::Horse included
+      #   end
+      #
+      #   describe "Old Mac Donald", :behaviour_type => :farm do
+      #     # *Will* get My::Pony and My::Horse included
+      #   end
+      #
+      def include(*args)
+        args << {} unless Hash === args.last
+        modules, options = args_and_options(*args)
+        required_behaviour_type = options[:behaviour_type]
+        required_behaviour_type = required_behaviour_type.to_sym if required_behaviour_type
+        @modules ||= {}
+        @modules[required_behaviour_type] ||= []
+        @modules[required_behaviour_type] += modules
+      end
+
+      def modules_for(required_behaviour_type) #:nodoc:
+        @modules ||= {}
+        modules = @modules[nil] || [] # general ones
+        if required_behaviour_type
+          modules.push(*@modules[required_behaviour_type.to_sym])
+        end
+        modules.uniq.compact
+      end
+      
+      # This is just for cleanup in RSpec's own examples
+      def exclude(*modules) #:nodoc:
+        @modules.each do |behaviour_type, mods|
+          modules.each{|m| mods.delete(m)}
+        end
+      end
+      
+      # Defines global predicate matchers. Example:
+      #
+      #   config.predicate_matchers[:swim] = :can_swim?
+      #
+      # This makes it possible to say:
+      #
+      #   person.should swim # passes if person.should_swim? returns true
+      #
+      def predicate_matchers
+        @predicate_matchers ||= {}
+      end
+      
+      # Prepends a global <tt>before</tt> block to all behaviours.
+      # See #append_before for filtering semantics.
+      def prepend_before(*args, &proc)
+        Example.prepend_before(*args, &proc)
+      end
+      # Appends a global <tt>before</tt> block to all behaviours.
+      #
+      # If you want to restrict the block to a subset of all the behaviours then
+      # specify this in a Hash as the last argument:
+      #
+      #   config.prepend_before(:all, :behaviour_type => :farm)
+      #
+      # or
+      #
+      #   config.prepend_before(:behaviour_type => :farm)
+      #
+      def append_before(*args, &proc)
+        Example.append_before(*args, &proc)
+      end
+      alias_method :before, :append_before
+
+      # Prepends a global <tt>after</tt> block to all behaviours.
+      # See #append_before for filtering semantics.
+      def prepend_after(*args, &proc)
+        Example.prepend_after(*args, &proc)
+      end
+      alias_method :after, :prepend_after
+      # Appends a global <tt>after</tt> block to all behaviours.
+      # See #append_before for filtering semantics.
+      def append_after(*args, &proc)
+        Example.append_after(*args, &proc)
+      end
+
+    private
+    
+      def mock_framework_path(framework_name)
+        File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "plugins", "mock_frameworks", framework_name))
+      end
+      
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/errors.rb

@@ -0,0 +1,9 @@
+module Spec
+  module DSL
+    class ExamplePendingError < StandardError
+    end
+
+    class PendingFixedError < StandardError
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/example.rb

@@ -0,0 +1,7 @@
+module Spec
+  module DSL
+    class Example
+      include ExampleModule
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/example_definition.rb

@@ -0,0 +1,32 @@
+module Spec
+  module DSL
+    class ExampleDefinition
+      # The global sequence number of this example
+      attr_accessor :number, :description
+      attr_reader :from, :example_block, :options
+
+      def initialize(description, options={}, &example_block)
+        @from = caller(0)[3]
+        @options = options
+        @example_block = example_block
+        @description = description
+      end
+
+      def to_s
+        description
+      end
+
+      def pending?
+        @example_block.nil?
+      end
+
+      def should_raise
+        @options[:should_raise]
+      end
+
+      def use_generated_description?
+        @description == :__generate_description
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/example_matcher.rb

@@ -0,0 +1,38 @@
+module Spec
+  module DSL
+    class ExampleMatcher
+      def initialize(behaviour_description, example_description)
+        @behaviour_description = behaviour_description
+        @example_description = example_description
+      end
+      
+      def matches?(specified_examples)
+        specified_examples.each do |specified_example|
+          return true if matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
+        end
+        false
+      end
+      
+      protected
+      def matches_literal_example?(specified_example)
+        specified_example =~ /(^#{behaviour_regexp} #{example_regexp}$|^#{behaviour_regexp}$|^#{example_regexp}$)/
+      end
+
+      def matches_example_not_considering_modules?(specified_example)
+        specified_example =~ /(^#{behaviour_regexp_not_considering_modules} #{example_regexp}$|^#{behaviour_regexp_not_considering_modules}$|^#{example_regexp}$)/
+      end
+
+      def behaviour_regexp
+        Regexp.escape(@behaviour_description)
+      end
+
+      def behaviour_regexp_not_considering_modules
+        Regexp.escape(@behaviour_description.split('::').last)
+      end
+
+      def example_regexp
+        Regexp.escape(@example_description)
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/example_module.rb

@@ -0,0 +1,198 @@
+module Spec
+  module DSL
+    # TODO: BT - Change this name to Example.
+    # It is intentionally bad because it is temporary.
+    module ExampleModule
+      def self.included(mod)
+        mod.extend ClassMethods
+      end
+      module ClassMethods
+        include Behaviour
+        def inherited(klass)
+          super
+          unless klass.name.to_s == ""
+            klass.describe(klass.name)
+            klass.register
+          end
+        end
+
+        def suite
+          description = description ? description.description : "Rspec Description Suite"
+          suite = ExampleSuite.new(description, self)
+          ordered_example_definitions.each do |example_definition|
+            suite << new(example_definition)
+          end
+          instance_methods.each do |method_name|
+            if method_name =~ /^test./ && (
+              instance_method(method_name).arity == 0 ||
+              instance_method(method_name).arity == -1
+            )
+              example_definition = ExampleDefinition.new(method_name) do
+                __send__ method_name
+              end
+              suite << new(example_definition)
+            end
+          end
+          suite
+        end
+
+        # Sets the #number on each ExampleDefinition and returns the next number
+        def set_sequence_numbers(number) #:nodoc:
+          ordered_example_definitions.each do |example_definition|
+            example_definition.number = number
+            number += 1
+          end
+          number
+        end
+
+        def register
+          rspec_options.add_behaviour self
+        end
+
+        protected
+
+        def ordered_example_definitions
+          rspec_options.reverse ? example_definitions.reverse : example_definitions
+        end
+
+        def plugin_mock_framework
+          case mock_framework = Spec::Runner.configuration.mock_framework
+          when Module
+            include mock_framework
+          else
+            require Spec::Runner.configuration.mock_framework
+            include Spec::Plugins::MockFramework
+          end
+        end
+
+        def include_example_modules(behaviour_type)
+          Spec::Runner.configuration.modules_for(behaviour_type).each do |mod|
+            include mod
+          end
+        end
+
+        def define_predicate_matchers(definitions) # :nodoc:
+          definitions.each_pair do |matcher_method, method_on_object|
+            define_method matcher_method do |*args|
+              eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
+            end
+          end
+        end
+      end
+
+      class TestResultShim
+        def add_assertion
+        end
+        def add_failure(failure)
+        end
+        def add_error(error)
+        end
+      end
+
+      include ::Spec::Matchers
+      include ::Spec::DSL::Pending
+
+      attr_reader :rspec_behaviour, :rspec_definition
+      alias_method :behaviour, :rspec_behaviour
+      alias_method :definition, :rspec_definition
+
+      def initialize(definition) #:nodoc:
+        @rspec_behaviour = self.class
+        @rspec_definition = definition
+        @_result = TestResultShim.new
+
+        behaviour_type = behaviour_type
+        predicate_matchers = @rspec_behaviour.predicate_matchers
+        (class << self; self; end).class_eval do
+          plugin_mock_framework
+          include_example_modules behaviour_type
+          define_predicate_matchers predicate_matchers
+          define_predicate_matchers(Spec::Runner.configuration.predicate_matchers)
+        end
+      end
+
+      def violated(message="")
+        raise Spec::Expectations::ExpectationNotMetError.new(message)
+      end
+
+      def copy_instance_variables_from(obj)
+        super(obj, [:@rspec_definition, :@rspec_behaviour, :@_result])
+      end
+
+      def before_each
+        run_before_parts Example.before_each_parts(nil)
+        if behaviour_type
+          run_before_parts Example.before_each_parts(behaviour_type)
+        end
+        run_before_parts rspec_behaviour.before_each_parts(nil)
+        if behaviour_type
+          run_before_parts rspec_behaviour.before_each_parts(behaviour_type)
+        end
+      end
+
+      def before_all
+        run_before_parts Example.before_all_parts(nil)
+        if behaviour_type
+          run_before_parts Example.before_all_parts(behaviour_type)
+        end
+        run_before_parts rspec_behaviour.before_all_parts(nil)
+        if behaviour_type
+          run_before_parts rspec_behaviour.before_all_parts(behaviour_type)
+        end
+      end
+
+      def after_all
+        exception = nil
+        if behaviour_type
+          exception = run_after_parts(exception, rspec_behaviour.after_all_parts(behaviour_type))
+        end
+        exception = run_after_parts(exception, rspec_behaviour.after_all_parts(nil))
+        if behaviour_type
+          exception = run_after_parts(exception, Example.after_all_parts(behaviour_type))
+        end
+        exception = run_after_parts(exception, Example.after_all_parts(nil))
+        raise exception if exception
+      end
+
+      def after_each
+        exception = nil
+        if behaviour_type
+          exception = run_after_parts(exception, rspec_behaviour.after_each_parts(behaviour_type))
+        end
+        exception = run_after_parts(exception, rspec_behaviour.after_each_parts(nil))
+        if behaviour_type
+          exception = run_after_parts(exception, Example.after_each_parts(behaviour_type))
+        end
+        exception = run_after_parts(exception, Example.after_each_parts(nil))
+        raise exception if exception
+      end
+
+      def run_example
+        self.instance_eval(&rspec_definition.example_block)
+      end
+
+      protected
+      def run_before_parts(parts)
+        parts.each do |part|
+          self.instance_eval(&part)
+        end
+      end
+
+      def run_after_parts(original_exception, parts)
+        new_exception = nil
+        parts.each do |part|
+          begin
+            self.instance_eval(&part)
+          rescue Exception => e
+            new_exception ||= e
+          end
+        end
+        return original_exception || new_exception
+      end
+
+      def behaviour_type
+        @rspec_behaviour.behaviour_type
+      end      
+    end
+  end
+end