mcmire-context 0.5.6

data/lib/context.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'context/core'
+
+Context.setup Test::Unit::TestCase

data/lib/context/core.rb

@@ -0,0 +1,102 @@
+require 'test/unit'
+
+module Context
+  class << self
+    attr_accessor :core_class
+  end
+
+  def self.setup(test_case)
+    if core_class
+      if core_class == test_case
+        return
+      else
+        raise ArgumentError, "Currently, you're not allowed to run Context.setup again and clobber '#{core_class.name}'.  Require 'context/core' and pick ONE class."
+      end
+    end
+
+    self.core_class = test_case
+    test_case.class_eval do
+      include TestCase
+      extend  TestCase::ClassMethods
+
+      # for some reason, Test::Unit::TestCase won't let me cleanly override
+      # #suite with an extended module :(
+      def self.suite
+        context_suite
+      end
+    end
+  end
+
+  module TestCase
+    module ClassMethods
+      # Test::Unit uses ObjectSpace to figure out what Test::Unit:TestCase instances are running
+      # Contexts are not named and therefore sometimes get garbage collected.
+      # Think of #context_list as the shelter for nameless contexts
+      attr_accessor :context_list
+
+      def context_name #:nodoc:
+        @context_name ||= ""
+        if superclass.respond_to?(:context_name)
+          return "#{superclass.context_name} #{@context_name}".gsub(/^\s+/, "")
+        end
+      end
+
+      def context_name=(val) #:nodoc:
+        @context_name = val
+      end
+
+      # Add a context to a set of tests.
+      # 
+      #   context "A new account" do
+      #     it "should not have users"
+      #       assert Account.new.users.empty?
+      #     end
+      #   end
+      # 
+      # The context name is prepended to the test name, so failures look like this:
+      # 
+      #   1) Failure:
+      #   test_a_new_account_should_not_have_users() [./test/test_accounts.rb:4]:
+      #   <false> is not true.
+      # 
+      # Contexts can also be nested like so:
+      # 
+      #   context "A new account" do
+      #     context "created by the web application" do
+      #       it "should have web as its vendor" do
+      #         assert_equal "web", users(:web_user).vendor
+      #       end
+      #     end
+      #   end
+      # 
+      # Since contexts create a singleton instance of a class, each one must have its own before/after blocks.  This
+      # will be tweaked in future releases to allow you to chain these blocks from its parent contexts.
+      #
+      def context(name, &block)
+        cls = Class.new(self)
+        cls.context_name = name
+      
+        # Care about Rails tests in nested contexts
+        cls.tests($1.constantize) if defined?(Rails) && 
+          self.name =~ /^(.*(Controller|Helper|Mailer))Test/ && 
+            self < ActiveSupport::TestCase
+
+        cls.class_eval(&block)
+        (self.context_list ||= []) << cls
+        const_set("Test#{name.to_class_name}#{cls.object_id.abs}", cls)
+        cls
+      end
+
+      %w(contexts describe describes group specify specifies).each {|m| alias_method m, :context}
+    end
+  end
+end
+
+require 'context/core_ext/string'
+require 'context/core_ext/rails_hacks'
+
+require 'context/version'
+require 'context/suite'
+require 'context/test'
+require 'context/lifecycle'
+require 'context/shared_behavior'

data/lib/context/core_ext/rails_hacks.rb

@@ -0,0 +1,8 @@
+module Context::TestCase::ClassMethods
+  def setup_for_shoulda
+    self.instance_eval do
+      alias :setup :before
+      alias :teardown :after
+    end
+  end
+end

data/lib/context/core_ext/string.rb

@@ -0,0 +1,29 @@
+module Context::String
+  # Replaces spaces and tabs with _ so we can use the string as a method name
+  # Also replace dangerous punctuation
+  def to_method_name
+    downcased = self.downcase
+    downcased.gsub!(/[\s:',\.~;!#=\-\(\)\?]+/,'_')
+    downcased
+  end
+  
+  # Borrowed from +camelize+ in ActiveSupport
+  def to_module_name
+    meth_name = self.to_method_name
+    meth_name.gsub!(/\/(.?)/) { "::#{$1.upcase}" }
+    meth_name.gsub!(/(?:^|_)(.)/) { $1.upcase }
+    meth_name
+  end
+  
+  # Borrowed from +camelize+ in ActiveSupport
+  def to_class_name
+    meth_name = self.to_method_name
+    meth_name.gsub!(/\/(.?)/) { "#{$1.upcase}" }
+    meth_name.gsub!(/(?:^|_)(.)/) { $1.upcase }
+    meth_name
+  end
+end
+
+class String
+  include Context::String
+end

data/lib/context/lifecycle.rb

@@ -0,0 +1,115 @@
+module Context
+  module TestCase::ClassMethods
+    attr_accessor :before_each_callbacks, :before_all_callbacks, :after_each_callbacks, :after_all_callbacks, :before_should_callbacks
+
+    def self.extended(test_case)
+      test_case.before_all_callbacks    = []
+      test_case.before_each_callbacks   = []
+      test_case.after_each_callbacks    = []
+      test_case.after_all_callbacks     = []
+      test_case.before_should_callbacks = {}
+    end
+
+    # Add logic to run before the tests (i.e., a +setup+ method)
+    #
+    #     before do
+    #       @user = User.first
+    #     end
+    # 
+    def before(period = :each, &block)
+      unless block_given?
+        block  = period
+        period = :each
+      end
+
+      send("before_#{period}_callbacks") << block
+    end
+    
+    alias :setup :before
+    
+    # Add logic to run after the tests (i.e., a +teardown+ method)
+    #
+    #     after do
+    #       User.delete_all
+    #     end
+    #
+    def after(period = :each, &block)
+      unless block_given?
+        block  = period
+        period = :each
+      end
+
+      send("after_#{period}_callbacks") << block
+    end
+    
+    alias :teardown :after
+
+    def gather_callbacks(callback_type, period) # :nodoc:
+      callbacks = superclass.respond_to?(:gather_callbacks) ? superclass.gather_callbacks(callback_type, period) : []
+      callbacks.push(*send("#{callback_type}_#{period}_callbacks"))
+    end
+
+    def inherited(child) # :nodoc:
+      super
+      child.before_all_callbacks    = []
+      child.before_each_callbacks   = []
+      child.after_each_callbacks    = []
+      child.after_all_callbacks     = []
+      child.before_should_callbacks = {}
+
+      child.class_eval do
+        def setup(&block)
+          super
+          run_context_before_callbacks
+        end
+    
+        def teardown
+          super
+          run_context_after_callbacks
+        end
+      end if self == ::Context.core_class
+    end
+  end
+
+  module TestCase
+    def run_each_callbacks(callback_type) # :nodoc:
+      self.class.gather_callbacks(callback_type, :each).each do |c|
+        next if !c
+        c.is_a?(Proc) ? instance_eval(&c) : send(c)
+      end
+    end
+    
+    def run_all_callbacks(callback_type) # :nodoc:
+      previous_ivars = instance_variables
+      self.class.gather_callbacks(callback_type, :all).each { |c| instance_eval(&c) if c }
+      (instance_variables - previous_ivars).inject({}) do |hash, ivar|
+        hash.update ivar => instance_variable_get(ivar)
+      end
+    rescue Object => exception
+      raise <<-BANG
+    Error running the #{callback_type}(:all) callback for #{name}
+    #{exception.class.name}: #{exception.message}
+    #{exception.backtrace.join("\n")}
+      BANG
+    end
+
+    def set_values_from_callbacks(values) # :nodoc:
+      values.each do |name, value|
+        instance_variable_set name, value
+      end
+    end
+
+    private
+    def run_context_before_callbacks
+      unless self.class.before_should_callbacks[method_name].nil?
+        instance_eval(&self.class.before_should_callbacks[method_name])
+      end
+
+      run_each_callbacks :before
+    end
+
+    def run_context_after_callbacks
+      run_each_callbacks :after
+    end
+  end
+end

data/lib/context/shared_behavior.rb

@@ -0,0 +1,96 @@
+module Context
+  class SharedBehavior < Module
+    def self.create_from_behavior(beh) # :nodoc:
+      mod = self.new
+      mod._behavior = beh
+      
+      mod
+    end
+  
+    def _behavior=(beh) # :nodoc:
+      @_behavior = beh
+    end
+  
+    def included(arg) # :nodoc:
+      arg.instance_eval(&@_behavior)
+    end
+  end
+end
+
+module Context::TestCase::ClassMethods
+  # Share behavior among different contexts.  This creates a module (actually, a Module subclass)
+  # that is included using the +use+ method (or one of its aliases) provided by context or +include+ 
+  # if you know the module's constant name.
+  #
+  # ==== Examples
+  #   
+  #   shared "other things" do
+  #     it "should do things but not some things" do
+  #       # behavior is fun
+  #     end
+  #   end
+  #
+  #   use "other things"
+  #   # or...
+  #   it_should_behave_like "other things"
+  #
+  #   shared :client do
+  #     it "should be a client to our server" do
+  #       # TODO: client behavior here
+  #     end
+  #   end
+  #
+  #   use :client
+  #   # or...
+  #   uses "client"
+  #   behaves_like "client"
+  #
+  def shared(name, &block)
+    case name.class.name
+    when "String"
+      name = name.to_module_name
+    when "Symbol"
+      name = name.to_s.to_module_name
+    else
+      raise ArgumentError, "Provide a String or Symbol as the name of the shared behavior group"
+    end
+    
+    Object.const_set(name, Context::SharedBehavior.create_from_behavior(block))
+  end
+  
+  %w(shared_behavior share_as share_behavior_as shared_examples_for).each {|m| alias_method m, :shared}
+  
+  # Pull in behavior shared by +shared+ or a module.  
+  #
+  # ==== Examples
+  #   
+  #   shared "other things" do
+  #     it "should do things but not some things" do
+  #       # behavior is fun
+  #     end
+  #   end
+  #
+  #   use "other things"
+  #   # or...
+  #   it_should_behave_like "other things"
+  #
+  #   module Things
+  #   end
+  #
+  #   uses Things
+  #
+  def use(shared_name)
+    case shared_name.class.name
+    when "Context::SharedBehavior", "Module"
+      include shared_name
+    when "String"
+      include Object.const_get(shared_name.to_module_name)
+    when "Symbol"
+      include Object.const_get(shared_name.to_s.to_module_name)
+    else
+      raise ArgumentError, "Provide a String or Symbol as the name of the shared behavior group or the module name"
+    end
+  end
+  
+  %w(uses it_should_behave_like behaves_like uses_examples_from).each {|m| alias_method m, :use}
+end

data/lib/context/suite.rb

@@ -0,0 +1,35 @@
+module Context
+  module TestCase::ClassMethods
+    # Tweaks to standard method so we don't get superclass methods and we don't
+    # get weird default tests
+    def context_suite # :nodoc:
+      method_names = public_instance_methods - superclass.public_instance_methods
+  
+      tests = method_names.delete_if {|method_name| method_name !~ /^test./}
+      suite = TestSuite.new(name)
+      
+      tests.sort.each do |test|
+        catch(:invalid_test) do
+          suite << new(test)
+        end
+      end
+      
+      suite
+    end
+  end
+
+  class TestSuite < Test::Unit::TestSuite
+    # Runs the tests and/or suites contained in this
+    # TestSuite.
+    def run(result, &progress_block) # :nodoc:
+      yield(STARTED, name)
+      ivars_from_callback = @tests.first.run_all_callbacks(:before) if @tests.first.is_a?(Context.core_class)
+      @tests.each do |test|
+        test.set_values_from_callbacks(ivars_from_callback) if ivars_from_callback
+        test.run(result, &progress_block)
+      end
+      ivars_from_callback = @tests.first.run_all_callbacks(:after) if ivars_from_callback
+      yield(FINISHED, name)
+    end
+  end
+end

data/lib/context/test.rb

@@ -0,0 +1,34 @@
+module Context::TestCase::ClassMethods
+  # Create a test method.  +name+ is a native-language string to describe the test
+  # (e.g., no more +test_this_crazy_thing_with_underscores+).
+  #
+  #     test "A user should not be able to delete another user" do
+  #       assert_false @user.can?(:delete, @other_user)
+  #     end
+  #
+  def test(name, opts={}, &block)
+    test_name = ["test:", context_name, name].reject { |n| n == "" }.join(' ')
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+
+    unless opts[:before].nil?
+      before_should_callbacks[test_name] = opts[:before]
+    end
+    
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation provided for #{name}"
+      end
+    end
+  end
+  
+  %w(it should tests).each {|m| alias_method m, :test} 
+
+  def before_test(name, &block)
+    test(name, :before => block) {}
+  end
+
+  %w(before_it before_should before_tests).each {|m| alias_method m, :before_test}
+end

data/lib/context/version.rb

@@ -0,0 +1,9 @@
+module Context
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 5
+    TINY  = 6
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/tasks/deployment.rake

@@ -0,0 +1,34 @@
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+namespace :manifest do
+  desc 'Recreate Manifest.txt to include ALL files'
+  task :refresh do
+    `rake check_manifest | patch -p0 > Manifest.txt`
+  end
+end