shoulda 3.6.0 → 4.0.0.rc1

data/test/support/tests/command_runner.rb

@@ -1,230 +0,0 @@
-require 'timeout'
-require 'shellwords'
-
-module Tests
-  class CommandRunner
-    TimeoutError = Class.new(StandardError)
-
-    def self.run(*args)
-      new(*args).tap do |runner|
-        yield runner
-        runner.call
-      end
-    end
-
-    def self.run!(*args)
-      run(*args) do |runner|
-        runner.run_successfully = true
-        yield runner if block_given?
-      end
-    end
-
-    attr_reader :status, :options, :env
-    attr_accessor :command_prefix, :run_quickly, :run_successfully, :retries,
-      :timeout
-
-    def initialize(*args)
-      @reader, @writer = IO.pipe
-      options = (args.last.is_a?(Hash) ? args.pop : {})
-      @args = args
-      @options = options.merge(
-        err: [:child, :out],
-        out: writer,
-      )
-      @env = extract_env_from(@options)
-
-      @wrapper = ->(block) { block.call }
-      @command_prefix = ''
-      self.directory = Dir.pwd
-      @run_quickly = false
-      @run_successfully = false
-      @retries = 1
-      @num_times_run = 0
-      @timeout = 20
-    end
-
-    def around_command(&block)
-      @wrapper = block
-    end
-
-    def directory
-      @options[:chdir]
-    end
-
-    def directory=(directory)
-      @options[:chdir] = directory || Dir.pwd
-    end
-
-    def formatted_command
-      [formatted_env, Shellwords.join(command)].
-        select { |value| !value.empty? }.
-        join(' ')
-    end
-
-    def call
-      possibly_retrying do
-        possibly_running_quickly do
-          run_with_debugging
-
-          if run_successfully && !success?
-            fail!
-          end
-        end
-      end
-
-      self
-    end
-
-    def stop
-      unless writer.closed?
-        writer.close
-      end
-    end
-
-    def output
-      @_output ||= begin
-        stop
-        without_colors(reader.read)
-      end
-    end
-
-    def elided_output
-      lines = output.split(/\n/)
-      new_lines = lines[0..4]
-
-      if lines.size > 10
-        new_lines << "(...#{lines.size - 10} more lines...)"
-      end
-
-      new_lines << lines[-5..-1]
-      new_lines.join("\n")
-    end
-
-    def success?
-      status.success?
-    end
-
-    def exit_status
-      status.exitstatus
-    end
-
-    def fail!
-      raise <<-MESSAGE
-Command #{formatted_command.inspect} exited with status #{exit_status}.
-Output:
-#{divider('START') + output + divider('END')}
-      MESSAGE
-    end
-
-    def has_output?(expected_output)
-      if expected_output.is_a?(Regexp)
-        output =~ expected_output
-      else
-        output.include?(expected_output)
-      end
-    end
-
-    protected
-
-    attr_reader :args, :reader, :writer, :wrapper
-
-    private
-
-    def extract_env_from(options)
-      options.delete(:env) { {} }.inject({}) do |hash, (key, value)|
-        hash[key.to_s] = value
-        hash
-      end
-    end
-
-    def command
-      ([command_prefix] + args).flatten.flat_map do |word|
-        Shellwords.split(word)
-      end
-    end
-
-    def formatted_env
-      env.map { |key, value| "#{key}=#{value.inspect}" }.join(' ')
-    end
-
-    def run
-      pid = spawn(env, *command, options)
-      Process.waitpid(pid)
-      @status = $?
-    end
-
-    def run_with_wrapper
-      wrapper.call(method(:run))
-    end
-
-    def run_with_debugging
-      debug { "\n\e[33mChanging to directory:\e[0m #{directory}" }
-      debug { "\e[32mRunning command:\e[0m #{formatted_command}" }
-
-      run_with_wrapper
-
-      debug { "\n" + divider('START') + output + divider('END') }
-    end
-
-    def possibly_running_quickly(&block)
-      if run_quickly
-        begin
-          Timeout.timeout(timeout, &block)
-        rescue Timeout::Error
-          stop
-
-          message =
-            "Command timed out after #{timeout} seconds: #{formatted_command}\n" +
-            "Output:\n" +
-            output
-
-          raise TimeoutError, message
-        end
-      else
-        yield
-      end
-    end
-
-    def possibly_retrying
-      begin
-        @num_times_run += 1
-        yield
-      rescue => error
-        debug { "#{error.class}: #{error.message}" }
-
-        if @num_times_run < @retries
-          sleep @num_times_run
-          retry
-        else
-          raise error
-        end
-      end
-    end
-
-    def divider(title = '')
-      total_length = 72
-      start_length = 3
-
-      string = ''
-      string << ('-' * start_length)
-      string << title
-      string << '-' * (total_length - start_length - title.length)
-      string << "\n"
-      string
-    end
-
-    def without_colors(string)
-      string.gsub(/\e\[\d+(?:;\d+)?m(.+?)\e\[0m/, '\1')
-    end
-
-    def debugging_enabled?
-      ENV['DEBUG_COMMANDS'] == '1'
-    end
-
-    def debug
-      if debugging_enabled?
-        puts yield
-      end
-    end
-  end
-end

data/test/support/tests/filesystem.rb

@@ -1,100 +0,0 @@
-require 'fileutils'
-
-module Tests
-  class Filesystem
-    PROJECT_NAME = 'test-project'.freeze
-    ROOT_DIRECTORY = Pathname.new('../../../..').expand_path(__FILE__)
-    TEMP_DIRECTORY = ROOT_DIRECTORY.join('tmp/acceptance')
-    PROJECT_DIRECTORY = TEMP_DIRECTORY.join(PROJECT_NAME)
-
-    def root_directory
-      ROOT_DIRECTORY
-    end
-
-    def temp_directory
-      TEMP_DIRECTORY
-    end
-
-    def project_directory
-      PROJECT_DIRECTORY
-    end
-
-    def wrap(path)
-      if path.is_a?(Pathname)
-        path
-      else
-        find_in_project(path)
-      end
-    end
-
-    def within_project(&block)
-      Dir.chdir(project_directory, &block)
-    end
-
-    def clean
-      if temp_directory.exist?
-        temp_directory.rmtree
-      end
-    end
-
-    def create
-      project_directory.mkpath
-    end
-
-    def find_in_project(path)
-      project_directory.join(path)
-    end
-
-    def open(path, *args, &block)
-      find_in_project(path).open(*args, &block)
-    end
-
-    def read(path)
-      find_in_project(path).read
-    end
-
-    def write(path, content)
-      pathname = wrap(path)
-      create_parents_of(pathname)
-      pathname.open('w') { |f| f.write(content) }
-    end
-
-    def create_parents_of(path)
-      wrap(path).dirname.mkpath
-    end
-
-    def append_to_file(path, content, _options = {})
-      create_parents_of(path)
-      open(path, 'a') { |f| f.puts(content + "\n") }
-    end
-
-    def remove_from_file(path, pattern)
-      unless pattern.is_a?(Regexp)
-        pattern = Regexp.new('^' + Regexp.escape(pattern) + '$')
-      end
-
-      transform(path) do |lines|
-        lines.reject { |line| line =~ pattern }
-      end
-    end
-
-    def comment_lines_matching(path, pattern)
-      transform(path) do |lines|
-        lines.map do |line|
-          if line =~ pattern
-            "###{line}"
-          else
-            line
-          end
-        end
-      end
-    end
-
-    def transform(path)
-      content = read(path)
-      lines = content.split(/\n/)
-      transformed_lines = yield lines
-      write(path, transformed_lines.join("\n") + "\n")
-    end
-  end
-end

data/test/support/tests/version.rb

@@ -1,45 +0,0 @@
-module Tests
-  class Version
-    def initialize(version)
-      @version = Gem::Version.new(version.to_s + '')
-    end
-
-    def <(other_version)
-      compare?(:<, other_version)
-    end
-
-    def <=(other_version)
-      compare?(:<=, other_version)
-    end
-
-    def ==(other_version)
-      compare?(:==, other_version)
-    end
-
-    def >=(other_version)
-      compare?(:>=, other_version)
-    end
-
-    def >(other_version)
-      compare?(:>, other_version)
-    end
-
-    def =~(other_version)
-      Gem::Requirement.new(other_version).satisfied_by?(version)
-    end
-
-    def to_s
-      version.to_s
-    end
-
-    protected
-
-    attr_reader :version
-
-    private
-
-    def compare?(op, other_version)
-      Gem::Requirement.new("#{op} #{other_version}").satisfied_by?(version)
-    end
-  end
-end

data/test/warnings_spy.rb

@@ -1,62 +0,0 @@
-require 'forwardable'
-
-require File.expand_path('../warnings_spy/filesystem', __FILE__)
-require File.expand_path('../warnings_spy/reader', __FILE__)
-require File.expand_path('../warnings_spy/partitioner', __FILE__)
-require File.expand_path('../warnings_spy/reporter', __FILE__)
-
-class WarningsSpy
-  extend Forwardable
-
-  def initialize(project_name)
-    filesystem = Filesystem.new
-    @warnings_file = filesystem.warnings_file
-    @reader = Reader.new(filesystem)
-    @partitioner = Partitioner.new(reader, filesystem)
-    @reporter = Reporter.new(partitioner, filesystem, project_name)
-  end
-
-  def capture_warnings
-    $stderr.reopen(warnings_file.path)
-  end
-
-  def report_warnings_at_exit
-    at_exit do
-      printing_exceptions do
-        report_and_exit
-      end
-    end
-  end
-
-  protected
-
-  attr_reader :warnings_file, :reader, :partitioner, :reporter
-
-  private
-
-  def_delegators :partitioner, :relevant_warning_groups,
-    :irrelevant_warning_groups
-
-  def report_and_exit
-    reader.read
-    partitioner.partition
-    reporter.report
-    fail_build_if_there_are_any_warnings
-  end
-
-  def fail_build_if_there_are_any_warnings
-    if relevant_warning_groups.any?
-      exit(1)
-    end
-  end
-
-  def printing_exceptions
-    yield
-  rescue => error
-    puts "\n--- ERROR IN AT_EXIT --------------------------------"
-    puts "#{error.class}: #{error.message}"
-    puts error.backtrace.join("\n")
-    puts '-----------------------------------------------------'
-    raise error
-  end
-end

data/test/warnings_spy/filesystem.rb

@@ -1,45 +0,0 @@
-require 'fileutils'
-
-class WarningsSpy
-  class Filesystem
-    PROJECT_DIR = File.expand_path('../../..', __FILE__)
-    TEMP_DIR = File.join(PROJECT_DIR, 'tmp')
-
-    def initialize
-      @files_by_name = Hash.new do |hash, name|
-        FileUtils.mkdir_p(TEMP_DIR)
-        hash[name] = file_for(name)
-      end
-    end
-
-    def warnings_file
-      files_by_name['all_warnings']
-    end
-
-    def irrelevant_warnings_file
-      files_by_name['irrelevant_warnings']
-    end
-
-    def relevant_warnings_file
-      files_by_name['relevant_warnings']
-    end
-
-    def project_dir
-      PROJECT_DIR
-    end
-
-    protected
-
-    attr_reader :files_by_name
-
-    private
-
-    def path_for(name)
-      File.join(TEMP_DIR, "#{name}.txt")
-    end
-
-    def file_for(name)
-      File.open(path_for(name), 'w+')
-    end
-  end
-end