vtd_xml 0.0.3-java

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/lib/shoulda/context/context.rb

@@ -0,0 +1,481 @@
+module Shoulda
+  module Context
+    class << self
+      def contexts # :nodoc:
+        @contexts ||= []
+      end
+      attr_writer :contexts
+
+      def current_context # :nodoc:
+        self.contexts.last
+      end
+
+      def add_context(context) # :nodoc:
+        self.contexts.push(context)
+      end
+
+      def remove_context # :nodoc:
+        self.contexts.pop
+      end
+    end
+
+    module ClassMethods
+      # == Should statements
+      #
+      # Should statements are just syntactic sugar over normal Test::Unit test
+      # methods.  A should block contains all the normal code and assertions
+      # you're used to seeing, with the added benefit that they can be wrapped
+      # inside context blocks (see below).
+      #
+      # === Example:
+      #
+      #  class UserTest < Test::Unit::TestCase
+      #
+      #    def setup
+      #      @user = User.new("John", "Doe")
+      #    end
+      #
+      #    should "return its full name"
+      #      assert_equal 'John Doe', @user.full_name
+      #    end
+      #
+      #  end
+      #
+      # ...will produce the following test:
+      # * <tt>"test: User should return its full name. "</tt>
+      #
+      # Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
+      #
+      # Should statements can also take a Proc as a <tt>:before </tt>option.  This proc runs after any
+      # parent context's setups but before the current context's setup.
+      #
+      # === Example:
+      #
+      #  context "Some context" do
+      #    setup { puts("I run after the :before proc") }
+      #
+      #    should "run a :before proc", :before => lambda { puts("I run before the setup") }  do
+      #      assert true
+      #    end
+      #  end
+      #
+      # Should statements can also wrap matchers, making virtually any matcher
+      # usable in a macro style. The matcher's description is used to generate a
+      # test name and failure message, and the test will pass if the matcher
+      # matches the subject.
+      #
+      # === Example:
+      #
+      #   should validate_presence_of(:first_name).with_message(/gotta be there/)
+      #
+
+      def should(name_or_matcher, options = {}, &blk)
+        if Shoulda::Context.current_context
+          Shoulda::Context.current_context.should(name_or_matcher, options, &blk)
+        else
+          context_name = self.name.gsub(/Test/, "") if self.name
+          context = Shoulda::Context::Context.new(context_name, self) do
+            should(name_or_matcher, options, &blk)
+          end
+          context.build
+        end
+      end
+
+      # Allows negative tests using matchers. The matcher's description is used
+      # to generate a test name and negative failure message, and the test will
+      # pass unless the matcher matches the subject.
+      #
+      # === Example:
+      #
+      #   should_not set_the_flash
+      def should_not(matcher)
+        if Shoulda::Context.current_context
+          Shoulda::Context.current_context.should_not(matcher)
+        else
+          context_name = self.name.gsub(/Test/, "") if self.name
+          context = Shoulda::Context::Context.new(context_name, self) do
+            should_not(matcher)
+          end
+          context.build
+        end
+      end
+
+      # == Before statements
+      #
+      # Before statements are should statements that run before the current
+      # context's setup. These are especially useful when setting expectations.
+      #
+      # === Example:
+      #
+      #  class UserControllerTest < Test::Unit::TestCase
+      #    context "the index action" do
+      #      setup do
+      #        @users = [Factory(:user)]
+      #        User.stubs(:find).returns(@users)
+      #      end
+      #
+      #      context "on GET" do
+      #        setup { get :index }
+      #
+      #        should respond_with(:success)
+      #
+      #        # runs before "get :index"
+      #        before_should "find all users" do
+      #          User.expects(:find).with(:all).returns(@users)
+      #        end
+      #      end
+      #    end
+      #  end
+      def before_should(name, &blk)
+        should(name, :before => blk) { assert true }
+      end
+
+      # Just like should, but never runs, and instead prints an 'X' in the Test::Unit output.
+      def should_eventually(name, options = {}, &blk)
+        context_name = self.name.gsub(/Test/, "")
+        context = Shoulda::Context::Context.new(context_name, self) do
+          should_eventually(name, &blk)
+        end
+        context.build
+      end
+
+      # == Contexts
+      #
+      # A context block groups should statements under a common set of setup/teardown methods.
+      # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
+      # and readability of your test code.
+      #
+      # A context block can contain setup, should, should_eventually, and teardown blocks.
+      #
+      #  class UserTest < Test::Unit::TestCase
+      #    context "A User instance" do
+      #      setup do
+      #        @user = User.find(:first)
+      #      end
+      #
+      #      should "return its full name"
+      #        assert_equal 'John Doe', @user.full_name
+      #      end
+      #    end
+      #  end
+      #
+      # This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
+      #
+      # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each
+      # should statement.  They then run their teardown blocks from in to out after each should statement.
+      #
+      #  class UserTest < Test::Unit::TestCase
+      #    context "A User instance" do
+      #      setup do
+      #        @user = User.find(:first)
+      #      end
+      #
+      #      should "return its full name"
+      #        assert_equal 'John Doe', @user.full_name
+      #      end
+      #
+      #      context "with a profile" do
+      #        setup do
+      #          @user.profile = Profile.find(:first)
+      #        end
+      #
+      #        should "return true when sent :has_profile?"
+      #          assert @user.has_profile?
+      #        end
+      #      end
+      #    end
+      #  end
+      #
+      # This code will produce the following methods
+      # * <tt>"test: A User instance should return its full name. "</tt>
+      # * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
+      #
+      # <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt>
+      # tests</b>.  This means you do not have to fully commit to the context/should syntax in a test file.
+
+      def context(name, &blk)
+        if Shoulda::Context.current_context
+          Shoulda::Context.current_context.context(name, &blk)
+        else
+          context = Shoulda::Context::Context.new(name, self, &blk)
+          context.build
+        end
+      end
+
+      # Returns the class being tested, as determined by the test class name.
+      #
+      #   class UserTest; described_type; end
+      #   # => User
+      def described_type
+        @described_type ||= self.name.
+          gsub(/Test$/, '').
+          split('::').
+          inject(Object) { |parent, local_name| parent.const_get(local_name) }
+      end
+
+      # Sets the return value of the subject instance method:
+      #
+      #   class UserTest < Test::Unit::TestCase
+      #     subject { User.first }
+      #
+      #     # uses the existing user
+      #     should validate_uniqueness_of(:email)
+      #   end
+      def subject(&block)
+        @subject_block = block
+      end
+
+      def subject_block # :nodoc:
+        @subject_block ||= nil
+      end
+    end
+
+    module InstanceMethods
+      # Returns an instance of the class under test.
+      #
+      #   class UserTest
+      #     should "be a user" do
+      #       assert_kind_of User, subject # passes
+      #     end
+      #   end
+      #
+      # The subject can be explicitly set using the subject class method:
+      #
+      #   class UserTest
+      #     subject { User.first }
+      #     should "be an existing user" do
+      #       assert !subject.new_record? # uses the first user
+      #     end
+      #   end
+      #
+      # The subject is used by all macros that require an instance of the class
+      # being tested.
+      def subject
+        @shoulda_subject ||= construct_subject
+      end
+
+      def subject_block # :nodoc:
+        (@shoulda_context && @shoulda_context.subject_block) || self.class.subject_block
+      end
+
+      def get_instance_of(object_or_klass) # :nodoc:
+        if object_or_klass.is_a?(Class)
+          object_or_klass.new
+        else
+          object_or_klass
+        end
+      end
+
+      def instance_variable_name_for(klass) # :nodoc:
+        klass.to_s.split('::').last.underscore
+      end
+
+      private
+
+      def construct_subject
+        if subject_block
+          instance_eval(&subject_block)
+        else
+          get_instance_of(self.class.described_type)
+        end
+      end
+    end
+
+    class Context # :nodoc:
+
+      attr_accessor :name               # my name
+      attr_accessor :parent             # may be another context, or the original test::unit class.
+      attr_accessor :subcontexts        # array of contexts nested under myself
+      attr_accessor :setup_blocks       # blocks given via setup methods
+      attr_accessor :teardown_blocks    # blocks given via teardown methods
+      attr_accessor :shoulds            # array of hashes representing the should statements
+      attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
+
+      # accessor with cache
+      def subject_block
+        return @subject_block if @subject_block
+        parent.subject_block
+      end
+      attr_writer :subject_block
+
+      def initialize(name, parent, &blk)
+        Shoulda::Context.add_context(self)
+        self.name               = name
+        self.parent             = parent
+        self.setup_blocks       = []
+        self.teardown_blocks    = []
+        self.shoulds            = []
+        self.should_eventuallys = []
+        self.subcontexts        = []
+        self.subject_block      = nil
+
+        if block_given?
+          merge_block(&blk)
+        else
+          merge_block { warn "  * WARNING: Block missing for context '#{full_name}'" }
+        end
+        Shoulda::Context.remove_context
+      end
+
+      def merge_block(&blk)
+        if self.respond_to?(:instance_exec)
+          self.instance_exec(&blk)
+        else
+          # deprecated in Rails 4.x
+          blk.bind(self).call
+        end
+      end
+
+      def context(name, &blk)
+        self.subcontexts << Context.new(name, self, &blk)
+      end
+
+      def setup(&blk)
+        self.setup_blocks << blk
+      end
+
+      def teardown(&blk)
+        self.teardown_blocks << blk
+      end
+
+      def should(name_or_matcher, options = {}, &blk)
+        if name_or_matcher.respond_to?(:description) && name_or_matcher.respond_to?(:matches?)
+          name = name_or_matcher.description
+          blk = lambda { assert_accepts name_or_matcher, subject }
+        else
+          name = name_or_matcher
+        end
+
+        if blk
+          self.shoulds << { :name => name, :before => options[:before], :block => blk }
+        else
+          self.should_eventuallys << { :name => name }
+        end
+      end
+
+      def should_not(matcher)
+        name = matcher.description
+        blk = lambda { assert_rejects matcher, subject }
+        self.shoulds << { :name => "not #{name}", :block => blk }
+      end
+
+      def should_eventually(name, &blk)
+        self.should_eventuallys << { :name => name, :block => blk }
+      end
+
+      def subject(&block)
+        self.subject_block = block
+      end
+
+      def full_name
+        parent_name = parent.full_name if am_subcontext?
+        return [parent_name, name].join(" ").strip
+      end
+
+      def am_subcontext?
+        parent.is_a?(self.class) # my parent is the same class as myself.
+      end
+
+      def test_unit_class
+        am_subcontext? ? parent.test_unit_class : parent
+      end
+
+      def test_methods
+        @test_methods ||= Hash.new { |h,k|
+          h[k] = Hash[k.instance_methods.map { |n| [n, true] }]
+        }
+      end
+
+      def create_test_from_should_hash(should)
+        test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
+
+        if test_methods[test_unit_class][test_name.to_s] then
+          raise DuplicateTestError, "'#{test_name}' is defined more than once."
+        end
+
+        test_methods[test_unit_class][test_name.to_s] = true
+
+        context = self
+        test_unit_class.send(:define_method, test_name) do
+          @shoulda_context = context
+          begin
+            context.run_parent_setup_blocks(self)
+            if should[:before]
+              if self.respond_to?(:instance_exec)
+                self.instance_exec(&should[:before])
+              else
+                # deprecated in Rails 4.x
+                should[:before].bind(self).call
+              end
+            end
+            context.run_current_setup_blocks(self)
+            if self.respond_to?(:instance_exec)
+              self.instance_exec(&should[:block])
+            else
+              # deprecated in Rails 4.x
+              should[:block].bind(self).call
+            end
+          ensure
+            context.run_all_teardown_blocks(self)
+          end
+        end
+      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 am_subcontext?
+      end
+
+      def run_current_setup_blocks(binding)
+        setup_blocks.each do |setup_block|
+          if binding.respond_to?(:instance_exec)
+            binding.instance_exec(&setup_block)
+          else
+            # deprecated in Rails 4.x
+            setup_block.bind(binding).call
+          end
+        end
+      end
+
+      def run_all_teardown_blocks(binding)
+        teardown_blocks.reverse.each do |teardown_block|
+          if binding.respond_to?(:instance_exec)
+            binding.instance_exec(&teardown_block)
+          else
+            # deprecated in Rails 4.x
+            teardown_block.bind(binding).call
+          end
+        end
+        self.parent.run_all_teardown_blocks(binding) if am_subcontext?
+      end
+
+      def print_should_eventuallys
+        should_eventuallys.each do |should|
+          test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
+          puts "  * DEFERRED: " + test_name
+        end
+      end
+
+      def build
+        shoulds.each do |should|
+          create_test_from_should_hash(should)
+        end
+
+        subcontexts.each { |context| context.build }
+
+        print_should_eventuallys
+      end
+
+      def method_missing(method, *args, &blk)
+        test_unit_class.send(method, *args, &blk)
+      end
+
+    end
+  end
+end
+
+class DuplicateTestError < RuntimeError; end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/lib/shoulda/context/proc_extensions.rb

@@ -0,0 +1,14 @@
+# Stolen straight from ActiveSupport
+
+class Proc #:nodoc:
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/lib/shoulda/context/tasks/list_tests.rake

@@ -0,0 +1,29 @@
+namespace :shoulda do
+  desc "List the names of the test methods in a specification like format"
+  task :list do
+    $LOAD_PATH.unshift("test")
+
+    require 'test/unit'
+    require 'rubygems'
+    require 'active_support'
+
+    # bug in test unit.  Set to true to stop from running.
+    Test::Unit.run = true
+
+    test_files = Dir.glob(File.join('test', '**', '*_test.rb'))
+    test_files.each do |file|
+      load file
+      klass = File.basename(file, '.rb').classify
+      unless Object.const_defined?(klass.to_s)
+        puts "Skipping #{klass} because it doesn't map to a Class"
+        next
+      end
+      klass = klass.constantize
+
+      puts klass.name.gsub('Test', '')
+
+      test_methods = klass.instance_methods.grep(/^test/).map {|s| s.gsub(/^test: /, '')}.sort
+      test_methods.each {|m| puts "  " + m }
+    end
+  end
+end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/lib/shoulda/context/tasks/yaml_to_shoulda.rake

@@ -0,0 +1,28 @@
+namespace :shoulda do
+  # From http://blog.internautdesign.com/2007/11/2/a-yaml_to_shoulda-rake-task
+  # David.Lowenfels@gmail.com
+  desc "Converts a YAML file (FILE=./path/to/yaml) into a Shoulda skeleton"
+  task :from_yaml do
+    require 'yaml'
+
+    def yaml_to_context(hash, indent = 0)
+      indent1 = '  ' * indent
+      indent2 = '  ' * (indent + 1)
+      hash.each_pair do |context, shoulds|
+        puts indent1 + "context \"#{context}\" do"
+        puts
+        shoulds.each do |should|
+          yaml_to_context( should, indent + 1 ) and next if should.is_a?( Hash )
+          puts indent2 + "should_eventually \"" + should.gsub(/^should +/,'') + "\" do"
+          puts indent2 + "end"
+          puts
+        end
+        puts indent1 + "end"
+      end
+    end
+
+    puts("Please pass in a FILE argument.") and exit unless ENV['FILE']
+
+    yaml_to_context( YAML.load_file( ENV['FILE'] ) )
+  end
+end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/lib/shoulda/context/tasks.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), 'tasks', '*.rake')].each do |f|
+  load f
+end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/lib/shoulda/context/version.rb

@@ -0,0 +1,5 @@
+module Shoulda
+  module Context
+    VERSION = '1.1.6'.freeze
+  end
+end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/lib/shoulda/context.rb

@@ -0,0 +1,33 @@
+begin
+  # if present, load and set base_test_case
+  ActiveSupport::TestCase
+  if defined?([ActiveSupport::TestCase, MiniTest::Unit::TestCase]) &&
+     (ActiveSupport::TestCase.ancestors.include?(MiniTest::Unit::TestCase))
+    base_test_case = MiniTest::Unit::TestCase
+  end
+rescue
+end
+
+# no base_test_case set, using Test:Unit:TestCase
+unless base_test_case
+  require 'test/unit/testcase' unless defined?(Test::Unit::TestCase)
+  base_test_case = Test::Unit::TestCase
+end
+
+require 'shoulda/context/version'
+require 'shoulda/context/proc_extensions'
+require 'shoulda/context/assertions'
+require 'shoulda/context/context'
+require 'shoulda/context/autoload_macros'
+
+module ShouldaContextLoadable
+  def self.included(base)
+    base.class_eval do
+      include Shoulda::Context::Assertions
+      include Shoulda::Context::InstanceMethods
+    end
+    base.extend(Shoulda::Context::ClassMethods)
+  end
+end
+
+base_test_case.class_eval { include ShouldaContextLoadable }

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/lib/shoulda-context.rb

@@ -0,0 +1 @@
+require "shoulda/context"

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/rails/init.rb

@@ -0,0 +1,4 @@
+if RAILS_ENV == 'test'
+  require "shoulda/context"
+  Shoulda.autoload_macros RAILS_ROOT, File.join("vendor", "{plugins,gems}", "*")
+end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/shoulda-context.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'shoulda/context/version'
+
+Gem::Specification.new do |s|
+  s.name        = %q{shoulda-context}
+  s.version     = Shoulda::Context::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["thoughtbot, inc.", "Tammer Saleh", "Joe Ferris",
+                   "Ryan McGeary", "Dan Croak", "Matt Jankowski"]
+  s.email       = %q{support@thoughtbot.com}
+  s.homepage    = %q{http://thoughtbot.com/community/}
+  s.summary     = %q{Context framework extracted from Shoulda}
+  s.description = %q{Context framework extracted from Shoulda}
+  s.license     = %q{MIT}
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+
+  s.add_development_dependency("appraisal", "~> 0.5")
+  s.add_development_dependency("rails", ">= 3.0")
+  s.add_development_dependency("mocha", "~> 0.9.10")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("test-unit", "~> 2.1.0")
+end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/tasks/shoulda.rake

@@ -0,0 +1 @@
+load File.join(File.dirname(__FILE__), "..", "lib", "shoulda", "context", "tasks.rb")

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/test/fake_rails_root/test/shoulda_macros/custom_macro.rb

@@ -0,0 +1,6 @@
+module CustomMacro
+  def custom_macro
+  end
+end
+Test::Unit::TestCase.extend(CustomMacro)
+

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/test/shoulda/autoload_macro_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class AutoloadMacroTest < Test::Unit::TestCase # :nodoc:
+  context "The macro auto-loader" do
+    should "load macros from the plugins" do
+      assert self.class.respond_to?('plugin_macro')
+    end
+
+    should "load macros from the gems" do
+      assert self.class.respond_to?('gem_macro')
+    end
+
+    should "load custom macros from ROOT/test/shoulda_macros" do
+      assert self.class.respond_to?('custom_macro')
+    end
+  end
+end
+