shoulda-matchers 4.0.0.rc1 → 4.0.1

data/spec/support/tests/database.rb

@@ -1,28 +0,0 @@
-require_relative 'database_configuration'
-
-module Tests
-  class Database
-    NAME = 'shoulda-matchers-test'
-    ADAPTER_NAME = ENV.fetch('DATABASE_ADAPTER', 'sqlite3').to_sym
-
-    include Singleton
-
-    attr_reader :config
-
-    def initialize
-      @config = Tests::DatabaseConfiguration.for(NAME, ADAPTER_NAME)
-    end
-
-    def name
-      config.database
-    end
-
-    def adapter_name
-      config.adapter
-    end
-
-    def adapter_class
-      config.adapter_class
-    end
-  end
-end

data/spec/support/tests/database_adapters/postgresql.rb

@@ -1,25 +0,0 @@
-module Tests
-  module DatabaseAdapters
-    class PostgreSQL
-      def self.name
-        :postgresql
-      end
-
-      attr_reader :database
-
-      def initialize(database)
-        @database = database
-      end
-
-      def adapter
-        self.class.name
-      end
-
-      def require_dependencies
-        require 'pg'
-      end
-    end
-
-    DatabaseConfigurationRegistry.instance.register(PostgreSQL)
-  end
-end

data/spec/support/tests/database_adapters/sqlite3.rb

@@ -1,26 +0,0 @@
-module Tests
-  module DatabaseAdapters
-    class SQLite3
-      def self.name
-        :sqlite3
-      end
-
-      def initialize(_database)
-      end
-
-      def adapter
-        self.class.name
-      end
-
-      def database
-        'db/db.sqlite3'
-      end
-
-      def require_dependencies
-        require 'sqlite3'
-      end
-    end
-
-    DatabaseConfigurationRegistry.instance.register(SQLite3)
-  end
-end

data/spec/support/tests/database_configuration.rb

@@ -1,33 +0,0 @@
-require_relative 'database_configuration_registry'
-require 'delegate'
-
-module Tests
-  class DatabaseConfiguration < SimpleDelegator
-    ENVIRONMENTS = %w(development test production)
-
-    attr_reader :adapter_class
-
-    def self.for(database_name, adapter_name)
-      config_class = DatabaseConfigurationRegistry.instance.get(adapter_name)
-      config = config_class.new(database_name)
-      new(config)
-    end
-
-    def initialize(config)
-      @adapter_class = config.class.to_s.split('::').last
-      super(config)
-    end
-
-    def to_hash
-      ENVIRONMENTS.each_with_object({}) do |env, config_as_hash|
-        config_as_hash[env] = inner_config_as_hash
-      end
-    end
-
-    private
-
-    def inner_config_as_hash
-      { 'adapter' => adapter.to_s, 'database' => database.to_s }
-    end
-  end
-end

data/spec/support/tests/database_configuration_registry.rb

@@ -1,28 +0,0 @@
-require 'singleton'
-
-module Tests
-  class DatabaseConfigurationRegistry
-    include Singleton
-
-    def initialize
-      @registry = {}
-    end
-
-    def register(config_class)
-      registry[config_class.name] = config_class
-    end
-
-    def get(name)
-      registry.fetch(name) do
-        raise KeyError, "No such adapter registered: #{name}"
-      end
-    end
-
-    protected
-
-    attr_reader :registry
-  end
-end
-
-require_relative 'database_adapters/postgresql'
-require_relative 'database_adapters/sqlite3'

data/spec/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 = Pathname.new('/tmp/shoulda-matchers-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/spec/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/spec/support/unit/active_record/create_table.rb

@@ -1,54 +0,0 @@
-module UnitTests
-  module ActiveRecord
-    class CreateTable
-      def self.call(table_name, columns)
-        new(table_name, columns).call
-      end
-
-      def initialize(table_name, columns)
-        @table_name = table_name
-        @columns = columns
-      end
-
-      def call
-        if columns.key?(:id) && columns[:id] == false
-          columns.delete(:id)
-          UnitTests::ModelBuilder.create_table(
-            table_name,
-            id: false,
-            &method(:add_columns_to_table)
-          )
-        else
-          UnitTests::ModelBuilder.create_table(
-            table_name,
-            &method(:add_columns_to_table)
-          )
-        end
-      end
-
-      protected
-
-      attr_reader :table_name, :columns
-
-      private
-
-      def add_columns_to_table(table)
-        columns.each do |column_name, column_specification|
-          add_column_to_table(table, column_name, column_specification)
-        end
-      end
-
-      def add_column_to_table(table, column_name, column_specification)
-        if column_specification.is_a?(Hash)
-          column_type = column_specification.fetch(:type)
-          column_options = column_specification.fetch(:options, {})
-        else
-          column_type = column_specification
-          column_options = {}
-        end
-
-        table.column(column_name, column_type, column_options)
-      end
-    end
-  end
-end

data/spec/support/unit/attribute.rb

@@ -1,45 +0,0 @@
-module UnitTests
-  class Attribute
-    DEFAULT_COLUMN_TYPE = :string
-    DEFAULT_COLUMN_OPTIONS = {
-      null: false,
-      array: false
-    }
-
-    def initialize(args)
-      @args = args
-    end
-
-    def name
-      args.fetch(:name)
-    end
-
-    def column_type
-      args.fetch(:column_type, DEFAULT_COLUMN_TYPE)
-    end
-
-    def column_options
-      DEFAULT_COLUMN_OPTIONS.
-        merge(args.fetch(:column_options, {})).
-        merge(type: column_type)
-    end
-
-    def array?
-      column_options[:array]
-    end
-
-    def default_value
-      args.fetch(:default_value) do
-        if column_options[:null]
-          nil
-        else
-          Shoulda::Matchers::Util.dummy_value_for(value_type, array: array?)
-        end
-      end
-    end
-
-    protected
-
-    attr_reader :args
-  end
-end

data/spec/support/unit/capture.rb

@@ -1,46 +0,0 @@
-module Kernel
-  # #capture, #silence_stream, and #silence_stderr are deprecated after Rails
-  # 4.2 and will be removed in 5.0, so just override them completely here
-
-  if method_defined?(:capture)
-    undef_method :capture
-  end
-
-  def capture(stream)
-    stream = stream.to_s
-    captured_stream = Tempfile.new(stream)
-    stream_io = eval("$#{stream}")
-    origin_stream = stream_io.dup
-    stream_io.reopen(captured_stream)
-
-    yield
-
-    stream_io.rewind
-    return captured_stream.read
-  ensure
-    captured_stream.unlink
-    stream_io.reopen(origin_stream)
-  end
-
-  if method_defined?(:silence_stream)
-    undef_method :silence_stream
-  end
-
-  def silence_stream(stream)
-    old_stream = stream.dup
-    stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
-    stream.sync = true
-    yield
-  ensure
-    stream.reopen(old_stream)
-    old_stream.close
-  end
-
-  if method_defined?(:silence_stderr)
-    undef_method :silence_stderr
-  end
-
-  def silence_stderr
-    silence_stream(STDERR) { yield }
-  end
-end

data/spec/support/unit/change_value.rb

@@ -1,111 +0,0 @@
-module UnitTests
-  class ChangeValue
-    def self.call(column_type, value, value_changer)
-      new(column_type, value, value_changer).call
-    end
-
-    def initialize(column_type, value, value_changer)
-      @column_type = column_type
-      @value = value
-      @value_changer = value_changer
-    end
-
-    def call
-      if value_changer.is_a?(Proc)
-        value_changer.call(value)
-      elsif respond_to?(value_changer, true)
-        send(value_changer)
-      else
-        value.public_send(value_changer)
-      end
-    end
-
-    protected
-
-    attr_reader :column_type, :value, :value_changer
-
-    private
-
-    def previous_value
-      if value.is_a?(String)
-        value[0..-2] + (value[-1].ord - 1).chr
-      else
-        value - 1
-      end
-    end
-
-    def next_value
-      if value.is_a?(Array)
-        value + [value.first.class.new]
-      elsif value.respond_to?(:next)
-        value.next
-      else
-        value + 1
-      end
-    end
-
-    def next_next_value
-      change_value(change_value(value, :next_value), :next_value)
-    end
-
-    def next_value_or_numeric_value
-      if value
-        change_value(value, :next_value)
-      else
-        change_value(value, :numeric_value)
-      end
-    end
-
-    def next_value_or_non_numeric_value
-      if value
-        change_value(value, :next_value)
-      else
-        change_value(value, :non_numeric_value)
-      end
-    end
-
-    def never_falsy
-      value || dummy_value_for_column
-    end
-
-    def truthy_or_numeric
-      value || 1
-    end
-
-    def never_blank
-      value.presence || dummy_value_for_column
-    end
-
-    def nil_to_blank
-      value || ''
-    end
-
-    def always_nil
-      nil
-    end
-
-    def add_character
-      value + 'a'
-    end
-
-    def remove_character
-      value.chop
-    end
-
-    def numeric_value
-      '1'
-    end
-
-    def non_numeric_value
-      'a'
-    end
-
-    def change_value(value, value_changer)
-      self.class.call(column_type, value, value_changer)
-    end
-
-    def dummy_value_for_column
-      Shoulda::Matchers::Util.dummy_value_for(column_type)
-    end
-  end
-end