RubyGems - hashrocket-clearance - Versions diffs - 0.4.3 → 0.4.4 - Mend

hashrocket-clearance 0.4.3 → 0.4.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (478) hide show

data/test/rails_root/vendor/gems/mocha-0.9.1/Rakefile DELETED

@@ -1,188 +0,0 @@
-require 'rubygems'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'rake/testtask'
-require 'rake/contrib/sshpublisher'
-module Mocha
-  VERSION = "0.9.1"
-end
-desc "Run all tests"
-task 'default' => ['test:units', 'test:acceptance', 'test:performance']
-namespace 'test' do
-  unit_tests = FileList['test/unit/**/*_test.rb']
-  acceptance_tests = FileList['test/acceptance/*_test.rb']
-  desc "Run unit tests"
-  Rake::TestTask.new('units') do |t|
-    t.libs << 'test'
-    t.test_files = unit_tests
-    t.verbose = true
-    t.warning = true
-  end
-  desc "Run acceptance tests"
-  Rake::TestTask.new('acceptance') do |t|
-    t.libs << 'test'
-    t.test_files = acceptance_tests
-    t.verbose = true
-    t.warning = true
-  end
-  # require 'rcov/rcovtask'
-  # Rcov::RcovTask.new('coverage') do |t|
-  #   t.libs << 'test'
-  #   t.test_files = unit_tests + acceptance_tests
-  #   t.verbose = true
-  #   t.warning = true
-  #   t.rcov_opts << '--sort coverage'
-  #   t.rcov_opts << '--xref'
-  # end
-  desc "Run performance tests"
-  task 'performance' do
-    require 'test/acceptance/stubba_example_test'
-    require 'test/acceptance/mocha_example_test'
-    iterations = 1000
-    puts "\nBenchmarking with #{iterations} iterations..."
-    [MochaExampleTest, StubbaExampleTest].each do |test_case|
-      puts "#{test_case}: #{benchmark_test_case(test_case, iterations)} seconds."
-    end
-  end
-end
-def benchmark_test_case(klass, iterations)
-  require 'test/unit/ui/console/testrunner'
-  require 'benchmark'
-  time = Benchmark.realtime { iterations.times { Test::Unit::UI::Console::TestRunner.run(klass, Test::Unit::UI::SILENT) } }
-end
-desc 'Generate RDoc'
-Rake::RDocTask.new('rdoc') do |task|
-  task.main = 'README'
-  task.title = "Mocha #{Mocha::VERSION}"
-  task.rdoc_dir = 'doc'
-  task.template = File.expand_path(File.join(File.dirname(__FILE__), "templates", "html_with_google_analytics"))
-  task.rdoc_files.include(
-    'README',
-    'RELEASE',
-    'COPYING',
-    'MIT-LICENSE',
-    'agiledox.txt',
-    'lib/mocha/standalone.rb',
-    'lib/mocha/mock.rb',
-    'lib/mocha/expectation.rb',
-    'lib/mocha/object.rb',
-    'lib/mocha/parameter_matchers.rb',
-    'lib/mocha/parameter_matchers',
-    'lib/mocha/state_machine.rb',
-    'lib/mocha/configuration.rb',
-    'lib/mocha/stubbing_error.rb'
-  )
-end
-task 'rdoc' => 'examples'
-desc "Upload RDoc to RubyForge"
-task 'publish_rdoc' => ['rdoc', 'examples'] do
-  Rake::SshDirPublisher.new("jamesmead@rubyforge.org", "/var/www/gforge-projects/mocha", "doc").upload
-end
-desc "Generate agiledox-like documentation for tests"
-file 'agiledox.txt' do
-  File.open('agiledox.txt', 'w') do |output|
-    tests = FileList['test/**/*_test.rb']
-    tests.each do |file|
-      m = %r".*/([^/].*)_test.rb".match(file)
-      output << m[1]+" should:\n"
-      test_definitions = File::readlines(file).select {|line| line =~ /.*def test.*/}
-      test_definitions.sort.each do |definition|
-        m = %r"test_(should_)?(.*)".match(definition)
-        output << " - "+m[2].gsub(/_/," ") << "\n"
-      end
-    end
-  end
-end
-desc "Convert example ruby files to syntax-highlighted html"
-task 'examples' do
-  $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "vendor", "coderay-0.7.4.215", "lib"))
-  require 'coderay'
-  mkdir_p 'doc/examples'
-  File.open('doc/examples/coderay.css', 'w') do |output|
-    output << CodeRay::Encoders[:html]::CSS.new.stylesheet
-  end
-  ['mocha', 'stubba', 'misc'].each do |filename|
-    File.open("doc/examples/#{filename}.html", 'w') do |file|
-      file << "<html>"
-      file << "<head>"
-      file << %q(<link rel="stylesheet" media="screen" href="coderay.css" type="text/css">)
-      file << "</head>"
-      file << "<body>"
-      file << CodeRay.scan_file("examples/#{filename}.rb").html.div
-      file << "</body>"
-      file << "</html>"
-    end
-  end
-end
-Gem::manage_gems
-specification = Gem::Specification.new do |s|
-  s.name   = "mocha"
-  s.summary = "Mocking and stubbing library"
-  s.version = Mocha::VERSION
-  s.platform = Gem::Platform::RUBY
-  s.author = 'James Mead'
-  s.description = <<-EOF
-    Mocking and stubbing library with JMock/SchMock syntax, which allows mocking and stubbing of methods on real (non-mock) classes.
-  EOF
-  s.email = 'mocha-developer@rubyforge.org'
-  s.homepage = 'http://mocha.rubyforge.org'
-  s.rubyforge_project = 'mocha'
-  s.has_rdoc = true
-  s.extra_rdoc_files = ['README', 'COPYING']
-  s.rdoc_options << '--title' << 'Mocha' << '--main' << 'README' << '--line-numbers'
-  s.autorequire = 'mocha'
-  s.add_dependency('rake')
-  s.files = FileList['{lib,test,examples}/**/*.rb', '[A-Z]*'].exclude('TODO').to_a
-end
-Rake::GemPackageTask.new(specification) do |package|
-   package.need_zip = true
-   package.need_tar = true
-end
-task 'verify_user' do
-  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
-end
-task 'verify_password' do
-  raise "RUBYFORGE_PASSWORD environment variable not set!" unless ENV['RUBYFORGE_PASSWORD']
-end
-desc "Publish package files on RubyForge."
-task 'publish_packages' => ['verify_user', 'verify_password', 'package'] do
-  $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "vendor", "meta_project-0.4.15", "lib"))
-  require 'meta_project'
-  require 'rake/contrib/xforge'
-  release_files = FileList[
-    "pkg/mocha-#{Mocha::VERSION}.gem",
-    "pkg/mocha-#{Mocha::VERSION}.tgz",
-    "pkg/mocha-#{Mocha::VERSION}.zip"
-  ]
-  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new('mocha')) do |release|
-    release.user_name = ENV['RUBYFORGE_USER']
-    release.password = ENV['RUBYFORGE_PASSWORD']
-    release.files = release_files.to_a
-    release.release_name = "Mocha #{Mocha::VERSION}"
-    release.release_changes = ''
-    release.release_notes = ''
-  end
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/examples/misc.rb DELETED

@@ -1,44 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-require 'mocha'
-class MiscExampleTest < Test::Unit::TestCase
-  def test_mocking_a_class_method
-    product = Product.new
-    Product.expects(:find).with(1).returns(product)
-    assert_equal product, Product.find(1)
-  end
-  def test_mocking_an_instance_method_on_a_real_object
-    product = Product.new
-    product.expects(:save).returns(true)
-    assert product.save
-  end
-  def test_stubbing_instance_methods_on_real_objects
-    prices = [stub(:pence => 1000), stub(:pence => 2000)]
-    product = Product.new
-    product.stubs(:prices).returns(prices)
-    assert_equal [1000, 2000], product.prices.collect {|p| p.pence}
-  end
-  def test_stubbing_an_instance_method_on_all_instances_of_a_class
-    Product.any_instance.stubs(:name).returns('stubbed_name')
-    product = Product.new
-    assert_equal 'stubbed_name', product.name
-  end
-  def test_traditional_mocking
-    object = mock()
-    object.expects(:expected_method).with(:p1, :p2).returns(:result)
-    assert_equal :result, object.expected_method(:p1, :p2)
-  end
-  def test_shortcuts
-    object = stub(:method1 => :result1, :method2 => :result2)
-    assert_equal :result1, object.method1
-    assert_equal :result2, object.method2
-  end
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/examples/mocha.rb DELETED

@@ -1,26 +0,0 @@
-class Enterprise
-  def initialize(dilithium)
-    @dilithium = dilithium
-  end
-  def go(warp_factor)
-    warp_factor.times { @dilithium.nuke(:anti_matter) }
-  end
-end
-require 'test/unit'
-require 'rubygems'
-require 'mocha'
-class EnterpriseTest < Test::Unit::TestCase
-  def test_should_boldly_go
-    dilithium = mock()
-    dilithium.expects(:nuke).with(:anti_matter).at_least_once  # auto-verified at end of test
-    enterprise = Enterprise.new(dilithium)
-    enterprise.go(2)
-  end
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/examples/stubba.rb DELETED

@@ -1,65 +0,0 @@
-class Order
-  attr_accessor :shipped_on
-  def total_cost
-    line_items.inject(0) { |total, line_item| total + line_item.price } + shipping_cost
-  end
-  def total_weight
-    line_items.inject(0) { |total, line_item| total + line_item.weight }
-  end
-  def shipping_cost
-    total_weight * 5 + 10
-  end
-  class << self
-    def find_all
-      # Database.connection.execute('select * from orders...
-    end
-    def number_shipped_since(date)
-      find_all.select { |order| order.shipped_on > date }.length
-    end
-    def unshipped_value
-      find_all.inject(0) { |total, order| order.shipped_on ? total : total + order.total_cost }
-    end
-  end
-end
-require 'test/unit'
-require 'rubygems'
-require 'mocha'
-class OrderTest < Test::Unit::TestCase
-  # illustrates stubbing instance method
-  def test_should_calculate_shipping_cost_based_on_total_weight
-    order = Order.new
-    order.stubs(:total_weight).returns(10)
-    assert_equal 60, order.shipping_cost
-  end
-  # illustrates stubbing class method
-  def test_should_count_number_of_orders_shipped_after_specified_date
-    now = Time.now; week_in_secs = 7 * 24 * 60 * 60
-    order_1 = Order.new; order_1.shipped_on = now - 1 * week_in_secs
-    order_2 = Order.new; order_2.shipped_on = now - 3 * week_in_secs
-    Order.stubs(:find_all).returns([order_1, order_2])
-    assert_equal 1, Order.number_shipped_since(now - 2 * week_in_secs)
-  end
-  # illustrates stubbing instance method for all instances of a class
-  def test_should_calculate_value_of_unshipped_orders
-    Order.stubs(:find_all).returns([Order.new, Order.new, Order.new])
-    Order.any_instance.stubs(:shipped_on).returns(nil)
-    Order.any_instance.stubs(:total_cost).returns(10)
-    assert_equal 30, Order.unshipped_value
-  end
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha.rb DELETED

@@ -1,20 +0,0 @@
-require 'mocha_standalone'
-require 'mocha/test_case_adapter'
-require 'mocha/configuration'
-require 'test/unit/testcase'
-module Test
-  module Unit
-    class TestCase
-      include Mocha::Standalone
-      include Mocha::TestCaseAdapter
-    end
-  end
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/any_instance_method.rb DELETED

@@ -1,54 +0,0 @@
-require 'mocha/class_method'
-module Mocha
-  class AnyInstanceMethod < ClassMethod
-    def unstub
-      remove_new_method
-      restore_original_method
-      stubbee.any_instance.reset_mocha
-    end
-    def mock
-      stubbee.any_instance.mocha
-    end
-    def hide_original_method
-      if method_exists?(method)
-        begin
-          stubbee.class_eval("alias_method :#{hidden_method}, :#{method}", __FILE__, __LINE__)
-        rescue NameError
-          # deal with nasties like ActiveRecord::Associations::AssociationProxy
-        end
-      end
-    end
-    def define_new_method
-      stubbee.class_eval("def #{method}(*args, &block); self.class.any_instance.mocha.method_missing(:#{method}, *args, &block); end", __FILE__, __LINE__)
-    end
-    def remove_new_method
-      stubbee.class_eval("remove_method :#{method}", __FILE__, __LINE__)
-    end
-    def restore_original_method
-      if method_exists?(hidden_method)
-        begin
-          stubbee.class_eval("alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}", __FILE__, __LINE__)
-        rescue NameError
-          # deal with nasties like ActiveRecord::Associations::AssociationProxy
-        end
-      end
-    end
-    def method_exists?(method)
-      return true if stubbee.public_instance_methods(false).include?(method)
-      return true if stubbee.protected_instance_methods(false).include?(method)
-      return true if stubbee.private_instance_methods(false).include?(method)
-      return false
-    end
-  end
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/backtrace_filter.rb DELETED

@@ -1,17 +0,0 @@
-module Mocha
-  class BacktraceFilter
-    LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), "..")) + File::SEPARATOR
-    def initialize(lib_directory = LIB_DIRECTORY)
-      @lib_directory = lib_directory
-    end
-    def filtered(backtrace)
-      backtrace.reject { |location| Regexp.new(@lib_directory).match(File.expand_path(location)) }
-    end
-  end
-end

data/test/rails_root/vendor/gems/mocha-0.9.1/lib/mocha/cardinality.rb DELETED

@@ -1,95 +0,0 @@
-module Mocha
-  class Cardinality
-    INFINITY = 1 / 0.0
-    class << self
-      def exactly(count)
-        new(count, count)
-      end
-      def at_least(count)
-        new(count, INFINITY)
-      end
-      def at_most(count)
-        new(0, count)
-      end
-      def times(range_or_count)
-        case range_or_count
-          when Range then new(range_or_count.first, range_or_count.last)
-          else new(range_or_count, range_or_count)
-        end
-      end
-    end
-    def initialize(required, maximum)
-      @required, @maximum = required, maximum
-    end
-    def invocations_allowed?(invocation_count)
-      invocation_count < maximum
-    end
-    def satisfied?(invocations_so_far)
-      invocations_so_far >= required
-    end
-    def needs_verifying?
-      !allowed_any_number_of_times?
-    end
-    def verified?(invocation_count)
-      (invocation_count >= required) && (invocation_count <= maximum)
-    end
-    def allowed_any_number_of_times?
-      required == 0 && infinite?(maximum)
-    end
-    def used?(invocation_count)
-      (invocation_count > 0) || (maximum == 0)
-    end
-    def mocha_inspect
-      if allowed_any_number_of_times?
-        "allowed any number of times"
-      else
-        if required == 0 && maximum == 0
-          "expected never"
-        elsif required == maximum
-          "expected exactly #{times(required)}"
-        elsif infinite?(maximum)
-          "expected at least #{times(required)}"
-        elsif required == 0
-          "expected at most #{times(maximum)}"
-        else
-          "expected between #{required} and #{times(maximum)}"
-        end
-      end
-    end
-    protected
-    attr_reader :required, :maximum
-    def times(number)
-      case number
-        when 0 then "no times"
-        when 1 then "once"
-        when 2 then "twice"
-        else "#{number} times"
-      end
-    end
-    def infinite?(number)
-      number.respond_to?(:infinite?) && number.infinite?
-    end
-  end
-end