mutant 0.2.20 → 0.3.0.beta2

data/tasks/metrics/heckle.rake

@@ -1,216 +0,0 @@
-$LOAD_PATH.unshift(File.expand_path('../../../lib', __FILE__))
-
-# original code by Ashley Moran:
-# http://aviewfromafar.net/2007/11/1/rake-task-for-heckling-your-specs
-
-begin
-  require 'pathname'
-  require 'backports'
-  require 'active_support/inflector'
-  require 'heckle'
-  require 'mspec'
-  require 'mspec/utils/name_map'
-
-  SKIP_METHODS = %w[ blank_slate_method_added ].freeze
-
-  class NameMap
-    def file_name(method, constant)
-      map  = MAP[method]
-      name = if map
-        map[constant] || map[:default]
-      else
-        method.
-          gsub('?','_ques').
-          gsub('!','_bang').
-          gsub('=','_assign')
-      end
-      "#{name}_spec.rb"
-    end
-  end
-
-  desc 'Heckle each module and class'
-  task :heckle do
-    unless Ruby2Ruby::VERSION == '1.2.2'
-      raise "ruby2ruby version #{Ruby2Ruby::VERSION} may not work properly, 1.2.2 *only* is recommended for use with heckle"
-    end
-
-    require File.expand_path('../../../spec/support/fake_ast',__FILE__)
-    require 'mutant'
-
-    root_module_regexp = Regexp.union('Mutant')
-
-    spec_dir = Pathname('spec/unit')
-
-    NameMap::MAP.each do |op, method|
-      next if method.kind_of?(Hash)
-      NameMap::MAP[op] = { :default => method }
-    end
-
-    aliases = Hash.new { |h,mod| h[mod] = Hash.new { |h,method| h[method] = method } }
-    map     = NameMap.new
-
-    heckle_caught_modules = Hash.new { |hash, key| hash[key] = [] }
-    unhandled_mutations = 0
-
-    ObjectSpace.each_object(Module) do |mod|
-      next unless mod.name =~ /\A#{root_module_regexp}(?::|\z)/
-
-      # Mutation::Loader is to rbx specific
-      next if mod == Mutant::Loader
-      # Mutation::Matcher::Method is to rbx specific
-      next if mod == Mutant::Matcher::Method
-      # Mutation::Context::Constant is to rbx specific
-      next if mod == Mutant::Context::Constant
-
-      spec_prefix = spec_dir.join(mod.name.underscore)
-
-      specs = []
-
-      # get the public class methods
-      metaclass  = class << mod; self end
-      ancestors  = metaclass.ancestors
-
-      spec_class_methods = mod.singleton_methods(false)
-
-      spec_class_methods.reject! do |method|
-        %w[ yaml_new yaml_tag_subclasses? included nesting constants ].include?(method.to_s)
-      end
-
-      if mod.ancestors.include?(Singleton)
-        spec_class_methods.reject! { |method| method.to_s == 'instance' }
-      end
-
-      # get the protected and private class methods
-      other_class_methods = metaclass.protected_instance_methods(false) |
-                            metaclass.private_instance_methods(false)
-
-      ancestors.each do |ancestor|
-        other_class_methods -= ancestor.protected_instance_methods(false) |
-                               ancestor.private_instance_methods(false)
-      end
-
-      other_class_methods.reject! do |method|
-        method.to_s == 'allocate' || SKIP_METHODS.include?(method.to_s)
-      end
-
-      other_class_methods.reject! do |method|
-        next unless spec_class_methods.any? { |specced| specced.to_s == $1 }
-
-        spec_class_methods << method
-      end
-
-      # get the instances methods
-      spec_methods = mod.public_instance_methods(false)
-
-      other_methods = mod.protected_instance_methods(false) |
-                      mod.private_instance_methods(false)
-
-      other_methods.reject! do |method|
-        next unless spec_methods.any? { |specced| specced.to_s == $1 }
-
-        spec_methods << method
-      end
-
-      # map the class methods to spec files
-      spec_class_methods.each do |method|
-        method = aliases[mod.name][method]
-        next if SKIP_METHODS.include?(method.to_s)
-
-        spec_file = spec_prefix.join('class_methods').join(map.file_name(method, mod.name))
-
-        unless spec_file.file?
-          raise "No spec file #{spec_file} for #{mod}.#{method}"
-          next
-        end
-
-        specs << [ ".#{method}", [ spec_file ] ]
-      end
-
-      # map the instance methods to spec files
-      spec_methods.each do |method|
-        method = aliases[mod.name][method]
-        next if SKIP_METHODS.include?(method.to_s)
-
-        spec_file = spec_prefix.join(map.file_name(method, mod.name))
-
-        unless spec_file.file?
-          raise "No spec file #{spec_file} for #{mod}##{method}"
-          next
-        end
-
-        specs << [ "##{method}", [ spec_file ] ]
-      end
-
-      # non-public methods are considered covered if they can be mutated
-      # and any spec fails for the current or descendant modules
-      other_methods.each do |method|
-        descedant_specs = []
-
-        ObjectSpace.each_object(Module) do |descedant|
-          next unless descedant.name =~ /\A#{root_module_regexp}(?::|\z)/ && mod >= descedant
-          descedant_spec_prefix = spec_dir.join(descedant.name.underscore)
-          descedant_specs << descedant_spec_prefix
-
-          if method.to_s == 'initialize'
-            descedant_specs.concat(Pathname.glob(descedant_spec_prefix.join('class_methods/new_spec.rb')))
-          end
-        end
-
-        specs << [ "##{method}", descedant_specs ]
-      end
-
-      other_class_methods.each do |method|
-        descedant_specs = []
-
-        ObjectSpace.each_object(Module) do |descedant|
-          next unless descedant.name =~ /\A#{root_module_regexp}(?::|\z)/ && mod >= descedant
-          descedant_specs << spec_dir.join(descedant.name.underscore).join('class_methods')
-        end
-
-        specs << [ ".#{method}", descedant_specs ]
-      end
-
-      specs.sort.each do |(method, spec_files)|
-        puts "Heckling #{mod}#{method}"
-        IO.popen("spec #{spec_files.join(' ')} --heckle '#{mod}#{method}'") do |pipe|
-          while line = pipe.gets
-            case line = line.chomp
-              when "The following mutations didn't cause test failures:"
-                heckle_caught_modules[mod.name] << method
-              when '+++ mutation'
-                unhandled_mutations += 1
-            end
-          end
-        end
-      end
-    end
-
-    if unhandled_mutations > 0
-      error_message_lines = [ "*************\n" ]
-
-      error_message_lines << "Heckle found #{unhandled_mutations} " \
-        "mutation#{"s" unless unhandled_mutations == 1} " \
-        "that didn't cause spec violations\n"
-
-      heckle_caught_modules.each do |mod, methods|
-        error_message_lines << "#{mod} contains the following " \
-          'poorly-specified methods:'
-        methods.each do |method|
-          error_message_lines << " - #{method}"
-        end
-        error_message_lines << ''
-      end
-
-      error_message_lines << 'Get your act together and come back ' \
-        'when your specs are doing their job!'
-
-      raise error_message_lines.join("\n")
-    else
-      puts 'Well done! Your code withstood a heckling.'
-    end
-  end
-rescue LoadError
-  task :heckle => :spec do
-    $stderr.puts 'Heckle or mspec is not available. In order to run heckle, you must: gem install heckle mspec'
-  end
-end

data/tasks/metrics/metric_fu.rake

@@ -1,31 +0,0 @@
-begin
-  # Require veritas before metric foo pulls AS
-  require 'veritas'
-  require 'metric_fu'
-  require 'json'
-
-  # XXX: temporary hack until metric_fu is fixed
-  MetricFu::Saikuro.class_eval { include FileUtils }
-
-  MetricFu::Configuration.run do |config|
-    config.rcov = {
-      :environment => 'test',
-      :test_files  => %w[ spec/**/*_spec.rb ],
-      :rcov_opts   => %w[
-        --sort coverage
-        --no-html
-        --text-coverage
-        --no-color
-        --profile
-        --exclude spec/,^/
-        --include lib:spec
-      ],
-    }
-  end
-rescue LoadError
-  namespace :metrics do
-    task :all do
-      $stderr.puts 'metric_fu is not available. In order to run metrics:all, you must: gem install metric_fu'
-    end
-  end
-end

data/tasks/metrics/reek.rake

@@ -1,15 +0,0 @@
-begin
-  require 'reek/rake/task'
-
-  if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx'
-    task :reek do
-      $stderr.puts 'Reek fails under rubinius, fix rubinius and remove guard'
-    end
-  else
-    Reek::Rake::Task.new
-  end
-rescue LoadError
-  task :reek do
-    $stderr.puts 'Reek is not available. In order to run reek, you must: gem install reek'
-  end
-end

data/tasks/metrics/roodi.rake

@@ -1,15 +0,0 @@
-begin
-  require 'roodi'
-  require 'rake/tasklib'
-  require 'roodi_task'
-
-  RoodiTask.new do |t|
-    t.verbose  = false
-    t.config   = File.expand_path('../../../config/roodi.yml', __FILE__)
-    t.patterns = %w[ lib/**/*.rb ]
-  end
-rescue LoadError
-  task :roodi do
-    abort 'Roodi is not available. In order to run roodi, you must: gem install roodi'
-  end
-end

data/tasks/metrics/yardstick.rake

@@ -1,23 +0,0 @@
-begin
-  require 'pathname'
-  require 'yardstick'
-  require 'yardstick/rake/measurement'
-  require 'yardstick/rake/verify'
-  require 'yaml'
-
-  config = YAML.load_file(File.expand_path('../../../config/yardstick.yml', __FILE__))
-
-  # yardstick_measure task
-  Yardstick::Rake::Measurement.new
-
-  # verify_measurements task
-  Yardstick::Rake::Verify.new do |verify|
-    verify.threshold = config.fetch('threshold')
-  end
-rescue LoadError
-  %w[ yardstick_measure verify_measurements ].each do |name|
-    task name.to_s do
-      abort "Yardstick is not available. In order to run #{name}, you must: gem install yardstick"
-    end
-  end
-end

data/tasks/spec.rake

@@ -1,45 +0,0 @@
-begin
-
-  begin
-    require 'rspec/core/rake_task'
-  rescue LoadError
-    require 'spec/rake/spectask'
-
-    module RSpec
-      module Core
-        RakeTask = Spec::Rake::SpecTask
-      end
-    end
-  end
-
-  desc 'run all specs'
-  task :spec => %w[ spec:unit spec:integration ]
-
-  namespace :spec do
-    RSpec::Core::RakeTask.new(:integration) do |t|
-      t.pattern = 'spec/integration/**/*_spec.rb'
-    end
-
-    RSpec::Core::RakeTask.new(:unit) do |t|
-      t.pattern = 'spec/unit/**/*_spec.rb'
-    end
-  end
-rescue LoadError
-  task :spec do
-    abort 'rspec is not available. In order to run spec, you must: gem install rspec'
-  end
-end
-
-begin
-  desc "Generate code coverage"
-  RSpec::Core::RakeTask.new(:rcov) do |t|
-    t.rcov      = true
-    t.rcov_opts = File.read('spec/rcov.opts').split(/\s+/)
-  end
-rescue LoadError
-  task :rcov do
-    abort 'rcov is not available. In order to run rcov, you must: gem install rcov'
-  end
-end
-
-task :test => 'spec'

data/tasks/yard.rake

@@ -1,9 +0,0 @@
-begin
-  require 'yard'
-
-  YARD::Rake::YardocTask.new
-rescue LoadError
-  task :yard do
-    abort 'YARD is not available. In order to run yard, you must: gem install yard'
-  end
-end