tu-context 0.5.7

data/countloc.rb

@@ -0,0 +1,65 @@
+
+def extract_path(argv)
+  if argv[1].nil?
+    if argv[0] =~ /-a/
+      return "/**/*.rb"
+    elsif argv[0]
+      if argv[0] =~ /\.rb$/
+        return argv[0]
+      end
+      return argv[0] + "/**/*.rb"
+    else
+      return "/**/*.rb"
+    end
+  elsif argv[1] =~ /\.rb$/
+    return argv[1]
+  else
+    return argv[1] + "/**/*.rb"
+  end
+end
+
+def all?
+  ARGV.join =~ /-a/
+end
+
+def comment?(line)
+  line =~ /^\s*#/
+end
+
+def blank?(line)
+  line =~ /^\s*$/
+end
+
+def puke(header, locs, comments, blanks)
+  puts header + ":"
+  puts "#{locs} loc"
+  puts "#{comments} lines of comments"
+  puts "#{blanks} blank lines"
+end
+
+dir = File.dirname(__FILE__)
+full_path = File.join(dir,extract_path(ARGV))
+gloc = gcmts = gblanks = 0
+Dir[File.expand_path("#{full_path}")].uniq.each do |file|
+  if file =~ /.*\.rb$/ 
+    
+    loc = cmts = blanks = 0
+
+    File.open(file, "r") do |f|
+      while f.gets
+        if comment?($_)
+          cmts += 1
+        elsif blank?($_)
+          blanks += 1
+        else
+          loc += 1
+        end
+      end
+    end
+    gcmts   += cmts
+    gloc    += loc
+    gblanks += blanks 
+    puke(file, loc, cmts, blanks) if all?
+  end
+end
+puke("Total", gloc, gcmts, gblanks)

data/lib/context.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'test/unit'
+
+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/context'
+require 'context/shared_behavior'
+
+class Test::Unit::TestCase
+  extend Context::Context
+end

data/lib/context/context.rb

@@ -0,0 +1,64 @@
+module Context
+  module Context
+    # 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
+      # puts "Creating context #{cls.context_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

data/lib/context/core_ext/rails_hacks.rb

@@ -0,0 +1,10 @@
+class Test::Unit::TestCase
+  class << self
+    def setup_for_shoulda
+      self.instance_eval do
+        alias :setup :before
+        alias :teardown :after
+      end
+    end
+  end
+end

data/lib/context/core_ext/string.rb

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

data/lib/context/lifecycle.rb

@@ -0,0 +1,103 @@
+class Test::Unit::TestCase
+  class << self
+    attr_accessor :before_each_callbacks, :before_all_callbacks, :after_each_callbacks, :after_all_callbacks, :before_should_callbacks
+
+    # 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
+  end
+
+  self.before_all_callbacks    = []
+  self.before_each_callbacks   = []
+  self.after_each_callbacks    = []
+  self.after_all_callbacks     = []
+  self.before_should_callbacks = {}
+
+  def self.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
+        
+        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 teardown
+        super
+
+        run_each_callbacks :after
+      end
+    end if self == Test::Unit::TestCase
+  end
+
+  def run_each_callbacks(callback_type) # :nodoc:
+    self.class.gather_callbacks(callback_type, :each).each do |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
+end

data/lib/context/shared_behavior.rb

@@ -0,0 +1,97 @@
+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(including_module) # :nodoc:
+      including_module.class_eval(&@_behavior)
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  class << self
+    # 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
+end

data/lib/context/suite.rb

@@ -0,0 +1,39 @@
+module Test
+  module Unit
+    class TestCase
+      class << self
+        # Tweaks to standard method so we don't get superclass methods and we don't
+        # get weird default tests
+        def suite # :nodoc:
+          method_names = public_instance_methods - superclass.public_instance_methods
+    
+          tests = method_names.delete_if {|method_name| method_name !~ /^test./}
+          suite = Test::Unit::TestSuite.new(name)
+          
+          tests.sort.each do |test|
+            catch(:invalid_test) do
+              suite << new(test)
+            end
+          end
+          
+          suite
+        end
+      end
+    end
+
+    class 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?(Test::Unit::TestCase)
+        @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
+end

data/lib/context/test.rb

@@ -0,0 +1,37 @@
+class Test::Unit::TestCase
+  class << self
+    # 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(' ')
+      # puts "running test #{test_name}"
+      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
+end