mack 0.8.2 → 0.8.3

data/lib/gems/rspec-1.1.11/spec/rspec_suite.rb

@@ -1,6 +0,0 @@
-if __FILE__ == $0
-  dir = File.dirname(__FILE__)
-  Dir["#{dir}/**/*_spec.rb"].reverse.each do |file|
-    require file
-  end
-end

data/lib/gems/rspec-1.1.11/spec/ruby_forker.rb

@@ -1,13 +0,0 @@
-require 'rbconfig'
-
-module RubyForker
-  # Forks a ruby interpreter with same type as ourself.
-  # juby will fork jruby, ruby will fork ruby etc.
-  def ruby(args, stderr=nil)
-    config       = ::Config::CONFIG
-    interpreter  = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
-    cmd = "#{interpreter} #{args}"
-    cmd << " 2> #{stderr}" unless stderr.nil?
-    `#{cmd}`
-  end
-end

data/lib/gems/rspec-1.1.11/spec/spec.opts

@@ -1,6 +0,0 @@
---colour
---format
-profile
---timeout
-20
---diff

data/lib/gems/rspec-1.1.11/spec/spec/adapters/ruby_engine_spec.rb

@@ -1,16 +0,0 @@
-describe Spec::Adapters::RubyEngine do
-  it "should default to MRI" do
-    Spec::Adapters::RubyEngine.adapter.should be_an_instance_of(Spec::Adapters::RubyEngine::MRI)
-  end
-  
-  it "should provide Rubinius for rbx" do
-    Spec::Adapters::RubyEngine.stub!(:engine).and_return('rbx')
-    Spec::Adapters::RubyEngine.adapter.should be_an_instance_of(Spec::Adapters::RubyEngine::Rubinius)
-  end
-  
-  it "should try to find whatever is defined by the RUBY_ENGINE const" do
-    Object.stub!(:const_defined?).with('RUBY_ENGINE').and_return(true)
-    Object.stub!(:const_get).with('RUBY_ENGINE').and_return("xyz")
-    Spec::Adapters::RubyEngine.engine.should == "xyz"
-  end
-end

data/lib/gems/rspec-1.1.11/spec/spec/example/configuration_spec.rb

@@ -1,296 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Example
-    describe Configuration do
-
-      describe "#mock_with" do
-
-        before(:each) do
-          @config = Configuration.new
-          @example_group = mock("example_group")
-        end
-
-        it "should default mock framework to rspec" do
-          @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
-        end
-
-        it "should set rspec mocking explicitly" do
-          @config.mock_with(:rspec)
-          @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
-        end
-
-        it "should set mocha" do
-          @config.mock_with(:mocha)
-          @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/mocha$/
-        end
-
-        it "should set flexmock" do
-          @config.mock_with(:flexmock)
-          @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/flexmock$/
-        end
-
-        it "should set rr" do
-          @config.mock_with(:rr)
-          @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rr$/
-        end
-
-        it "should set an arbitrary adapter module" do
-          adapter = Module.new
-          @config.mock_with(adapter)
-          @config.mock_framework.should == adapter
-        end
-      end
-
-      with_sandboxed_config do
-
-        describe "#include" do
-          
-          before(:each) do
-            @example_group_class = Class.new(ExampleGroup) {}
-            ExampleGroupFactory.register(:foobar, @example_group_class)
-          end
-
-          it "should include the submitted module in ExampleGroup subclasses" do
-            mod = Module.new
-            config.include mod
-            Class.new(@example_group_class).included_modules.should include(mod)
-          end
-
-          it "should scope modules to be included for a specific type" do
-            mod = Module.new
-            config.include mod, :type => :foobar
-            Class.new(@example_group_class).included_modules.should include(mod)
-          end
-
-          it "should not include modules in a type they are not intended for" do
-            mod = Module.new
-            @other_example_group_class = Class.new(ExampleGroup)
-            ExampleGroupFactory.register(:baz, @other_example_group_class)
-
-            config.include mod, :type => :foobar
-
-            Class.new(@other_example_group_class).included_modules.should_not include(mod)
-          end
-
-        end
-      
-        describe "#extend" do
-        
-          before(:each) do
-            @example_group_class = Class.new(ExampleGroup) {}
-            ExampleGroupFactory.register(:foobar, @example_group_class)
-          end
-
-          it "should extend all groups" do
-            mod = Module.new
-            ExampleGroup.should_receive(:extend).with(mod)
-            Spec::Runner.configuration.extend mod
-          end
-      
-          it "should extend specified groups" do
-            mod = Module.new
-            @example_group_class.should_receive(:extend).with(mod)
-            Spec::Runner.configuration.extend mod, :type => :foobar
-          end
-      
-          it "should not extend non-specified groups" do
-            @other_example_group_class = Class.new(ExampleGroup)
-            ExampleGroupFactory.register(:baz, @other_example_group_class)
-
-            mod = Module.new
-            @other_example_group_class.should_not_receive(:extend)          
-
-            Spec::Runner.configuration.extend mod, :type => :foobar
-          end
-        
-        end
-      end
-
-      describe Configuration do
-            
-        before(:each) do
-          @special_example_group = Class.new(ExampleGroup).describe("special_example_group")
-          @special_child_example_group = Class.new(@special_example_group).describe("special_child_example_group")
-          @nonspecial_example_group = Class.new(ExampleGroup).describe("nonspecial_example_group")
-          ExampleGroupFactory.register(:special, @special_example_group)
-          ExampleGroupFactory.register(:special_child, @special_child_example_group)
-          ExampleGroupFactory.register(:non_special, @nonspecial_example_group)
-          @example_group = @special_child_example_group.describe "Special Example Group"
-          @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group"
-        end
-
-        describe "#prepend_before" do
-          it "prepends the before block on all instances of the passed in type" do
-            order = []
-            config.prepend_before(:all) do
-              order << :prepend__before_all
-            end
-            config.prepend_before(:all, :type => :special) do
-              order << :special_prepend__before_all
-            end
-            config.prepend_before(:all, :type => :special_child) do
-              order << :special_child_prepend__before_all
-            end
-            config.prepend_before(:each) do
-              order << :prepend__before_each
-            end
-            config.prepend_before(:each, :type => :special) do
-              order << :special_prepend__before_each
-            end
-            config.prepend_before(:each, :type => :special_child) do
-              order << :special_child_prepend__before_each
-            end
-            config.prepend_before(:all, :type => :non_special) do
-              order << :special_prepend__before_all
-            end
-            config.prepend_before(:each, :type => :non_special) do
-              order << :special_prepend__before_each
-            end
-            @example_group.it "calls prepend_before" do
-            end
-        
-            @example_group.run
-            order.should == [
-              :prepend__before_all,
-              :special_prepend__before_all,
-              :special_child_prepend__before_all,
-              :prepend__before_each,
-              :special_prepend__before_each,
-              :special_child_prepend__before_each
-            ]
-          end
-        end
-
-        describe "#append_before" do
-
-          it "calls append_before on the type" do
-            order = []
-            config.append_before(:all) do
-              order << :append_before_all
-            end
-            config.append_before(:all, :type => :special) do
-              order << :special_append_before_all
-            end
-            config.append_before(:all, :type => :special_child) do
-              order << :special_child_append_before_all
-            end
-            config.append_before(:each) do
-              order << :append_before_each
-            end
-            config.append_before(:each, :type => :special) do
-              order << :special_append_before_each
-            end
-            config.append_before(:each, :type => :special_child) do
-              order << :special_child_append_before_each
-            end
-            config.append_before(:all, :type => :non_special) do
-              order << :special_append_before_all
-            end
-            config.append_before(:each, :type => :non_special) do
-              order << :special_append_before_each
-            end
-            @example_group.it "calls append_before" do
-            end
-
-            @example_group.run
-            order.should == [
-              :append_before_all,
-              :special_append_before_all,
-              :special_child_append_before_all,
-              :append_before_each,
-              :special_append_before_each,
-              :special_child_append_before_each
-            ]
-          end
-        end
-
-        describe "#prepend_after" do
-
-          it "prepends the after block on all instances of the passed in type" do
-            order = []
-            config.prepend_after(:all) do
-              order << :prepend__after_all
-            end
-            config.prepend_after(:all, :type => :special) do
-              order << :special_prepend__after_all
-            end
-            config.prepend_after(:all, :type => :special) do
-              order << :special_child_prepend__after_all
-            end
-            config.prepend_after(:each) do
-              order << :prepend__after_each
-            end
-            config.prepend_after(:each, :type => :special) do
-              order << :special_prepend__after_each
-            end
-            config.prepend_after(:each, :type => :special) do
-              order << :special_child_prepend__after_each
-            end
-            config.prepend_after(:all, :type => :non_special) do
-              order << :special_prepend__after_all
-            end
-            config.prepend_after(:each, :type => :non_special) do
-              order << :special_prepend__after_each
-            end
-            @example_group.it "calls prepend_after" do
-            end
-
-            @example_group.run
-            order.should == [
-              :special_child_prepend__after_each,
-              :special_prepend__after_each,
-              :prepend__after_each,
-              :special_child_prepend__after_all,
-              :special_prepend__after_all,
-              :prepend__after_all
-            ]
-          end
-        end
-
-        describe "#append_after" do
-
-          it "calls append_after on the type" do
-            order = []
-            config.append_after(:all) do
-              order << :append__after_all
-            end
-            config.append_after(:all, :type => :special) do
-              order << :special_append__after_all
-            end
-            config.append_after(:all, :type => :special_child) do
-              order << :special_child_append__after_all
-            end
-            config.append_after(:each) do
-              order << :append__after_each
-            end
-            config.append_after(:each, :type => :special) do
-              order << :special_append__after_each
-            end
-            config.append_after(:each, :type => :special_child) do
-              order << :special_child_append__after_each
-            end
-            config.append_after(:all, :type => :non_special) do
-              order << :non_special_append_after_all
-            end
-            config.append_after(:each, :type => :non_special) do
-              order << :non_special_append_after_each
-            end
-            @example_group.it "calls append_after" do
-            end
-
-            @example_group.run
-            order.should == [
-              :special_child_append__after_each,
-              :special_append__after_each,
-              :append__after_each,
-              :special_child_append__after_all,
-              :special_append__after_all,
-              :append__after_all
-            ]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gems/rspec-1.1.11/spec/spec/example/example_group_class_definition_spec.rb

@@ -1,48 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module Example
-    class ExampleGroupSubclass < ExampleGroup
-      class << self
-        attr_accessor :examples_ran
-      end
-
-      @@class_variable = :class_variable
-      CONSTANT = :constant
-
-      before do
-        @instance_variable = :instance_variable
-      end
-      
-      after(:all) do
-        self.class.examples_ran = true
-      end
-
-      it "should have access to instance variables" do
-        @instance_variable.should == :instance_variable
-      end
-
-      it "should have access to class variables" do
-        @@class_variable.should == :class_variable
-      end
-
-      it "should have access to constants" do
-        CONSTANT.should == :constant
-      end
-
-      it "should have access to methods defined in the Example Group" do
-        a_method.should == 22
-      end
-      
-      def a_method
-        22
-      end
-    end
-
-    describe ExampleGroupSubclass do
-      it "should run" do
-        ExampleGroupSubclass.examples_ran.should be_true
-      end
-    end
-  end
-end

data/lib/gems/rspec-1.1.11/spec/spec/example/example_group_factory_spec.rb

@@ -1,165 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-module Spec
-  module Example
-    describe ExampleGroupFactory do
-      describe "#get" do
-        attr_reader :example_group
-        before do
-          @example_group_class = Class.new(ExampleGroup)
-          ExampleGroupFactory.register(:registered_type, @example_group_class)
-        end
-
-        after do
-          ExampleGroupFactory.reset
-        end
-
-        it "should return the default ExampleGroup type for nil" do
-          ExampleGroupFactory.get(nil).should == ExampleGroup
-        end
-
-        it "should return the default ExampleGroup for an unregistered non-nil value" do
-          ExampleGroupFactory.get(:does_not_exist).should == ExampleGroup
-        end
-
-        it "should return custom type if registered" do
-          ExampleGroupFactory.get(:registered_type).should == @example_group_class
-        end
-
-        it "should return the actual type when that is what is submitted" do
-          ExampleGroupFactory.get(@example_group_class).should == @example_group_class
-        end
-
-        it "should get the custom type after setting the default" do
-          @alternate_example_group_class = Class.new(ExampleGroup)
-          ExampleGroupFactory.default(@alternate_example_group_class)
-          ExampleGroupFactory.get(:registered_type).should == @example_group_class
-        end
-      end
-
-      describe "#create_example_group" do
-        attr_reader :parent_example_group
-        before do
-          @parent_example_group = Class.new(ExampleGroup) do
-            def initialize(*args, &block)
-              ;
-            end
-          end
-        end
-
-        it "should create a uniquely named class" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {}
-          example_group.name.should =~ /Spec::Example::ExampleGroup::Subclass_\d+/
-        end
-
-        it "should create a Spec::Example::Example subclass by default" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {}
-          example_group.superclass.should == Spec::Example::ExampleGroup
-        end
-
-        describe "with :type => :default" do
-          it "should create a Spec::Example::ExampleGroup" do
-            example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "example_group", :type => :default
-            ) {}
-            example_group.superclass.should == Spec::Example::ExampleGroup
-          end
-        end
-
-        describe "with :type => :something_other_than_default" do
-          it "should create the specified type" do
-            Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group)
-            non_default_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-              "example_group", :type => :something_other_than_default
-            ) {}
-            non_default_example_group.superclass.should == parent_example_group
-          end
-        end
-
-        it "should create a type indicated by :spec_path" do
-          Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group)
-          custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "example_group", :spec_path => "./spec/something_other_than_default/some_spec.rb"
-          ) {}
-          custom_example_group.superclass.should == parent_example_group
-        end
-
-        it "should create a type indicated by :spec_path (with spec_path generated by caller on windows)" do
-          Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group)
-          custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "example_group",
-            :spec_path => "./spec\\something_other_than_default\\some_spec.rb"
-          ) {}
-          custom_example_group.superclass.should == parent_example_group
-        end
-
-        describe "with :shared => true" do
-          def shared_example_group
-            @shared_example_group ||= Spec::Example::ExampleGroupFactory.create_example_group(
-              "name", :spec_path => '/blah/spec/models/blah.rb', :type => :controller, :shared => true
-            ) {}
-          end
-
-          it "should create and register a Spec::Example::SharedExampleGroup" do
-            shared_example_group.should be_an_instance_of(Spec::Example::SharedExampleGroup)
-            SharedExampleGroup.shared_example_groups.should include(shared_example_group)
-          end
-        end
-
-        it "should favor the :type over the :spec_path" do
-          Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group)
-          custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "name", :spec_path => '/blah/spec/models/blah.rb', :type => :something_other_than_default
-          ) {}
-          custom_example_group.superclass.should == parent_example_group
-        end
-
-        it "should register ExampleGroup by default" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do
-          end
-          Spec::Runner.options.example_groups.should include(example_group)
-        end
-
-        it "should enable unregistering of ExampleGroups" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do
-            unregister
-          end
-          Spec::Runner.options.example_groups.should_not include(example_group)
-        end
-
-        after(:each) do
-          Spec::Example::ExampleGroupFactory.reset
-        end
-      end
-
-      describe "#all_registered?" do
-        before(:each) do
-          @unregistered_parent = Class.new(ExampleGroup)
-          @registered_child = Class.new(@unregistered_parent)
-          @unregistered_grandchild = Class.new(@registered_child)
-          Spec::Example::ExampleGroupFactory.register :registered_child, @registered_child
-        end
-        
-        it "should return true for empty list" do
-          Spec::Example::ExampleGroupFactory.all_registered?([]).should be_true
-        end
-        
-        it "should return true for a registered example group class" do
-          Spec::Example::ExampleGroupFactory.all_registered?([@registered_child]).should be_true
-        end
-
-        it "should return true for an ancestor of a registered example_group_classes" do
-          Spec::Example::ExampleGroupFactory.all_registered?([@unregistered_parent]).should be_true
-        end
-
-        it "should return false for a subclass of a registered example_group_class" do
-          Spec::Example::ExampleGroupFactory.all_registered?([@unregistered_grandchild]).should be_false
-        end
-
-        after(:each) do
-          Spec::Example::ExampleGroupFactory.reset
-        end
-      end
-    end
-  end
-end