mutant 0.9.5 → 0.9.10

data/.circleci/config.yml

@@ -1,53 +0,0 @@
-defaults: &defaults
-  working_directory: ~/mutant
-  docker:
-  - image: circleci/ruby:2.6.0
-version: 2
-jobs:
-  unit_specs:
-    <<: *defaults
-    steps:
-      - checkout
-      - run: bundle install
-      - run: bundle exec rspec spec/unit spec/integration/mutant/test_mutator_handles_types_spec.rb
-  integration_minitest:
-    <<: *defaults
-    steps:
-      - checkout
-      - run: bundle install
-      - run: bundle exec rspec spec/integration -e minitest
-  integration_rspec:
-    <<: *defaults
-    steps:
-      - checkout
-      - run: bundle install
-      - run: bundle exec rspec spec/integration -e rspec
-  integration_mutation_generation:
-    <<: *defaults
-    steps:
-      - checkout
-      - run: bundle install
-      - run: bundle exec rspec spec/integration -e generation
-  metrics:
-    <<: *defaults
-    steps:
-      - checkout
-      - run: bundle install
-      - run: bundle exec rake metrics:rubocop
-      - run: bundle exec rake metrics:reek
-  mutant:
-    <<: *defaults
-    steps:
-      - checkout
-      - run: bundle install
-      - run: bundle exec mutant --jobs 4 --since HEAD~1 --zombie -- 'Mutant*'
-workflows:
-  version: 2
-  test:
-    jobs:
-      - unit_specs
-      - integration_rspec
-      - integration_minitest
-      - integration_mutation_generation
-      - metrics
-      - mutant

data/config/rubocop.yml

@@ -1,205 +0,0 @@
-inherit_from: ../.rubocop.yml
-
-# Avoid parameter lists longer than five parameters.
-ParameterLists:
-  Max: 3
-  CountKeywordArgs: true
-
-# Avoid more than `Max` levels of nesting.
-BlockNesting:
-  Max: 3
-
-# Align with the style guide.
-CollectionMethods:
-  Enabled: true
-  PreferredMethods:
-    collect:  'map'
-    inject:   'reduce'
-    find:     'detect'
-    find_all: 'select'
-
-AccessModifierIndentation:
-  Enabled: false
-
-# Limit line length
-LineLength:
-  Max: 120
-
-# Disable documentation checking until a class needs to be documented once
-Documentation:
-  Enabled: false
-
-# Permit
-#
-#     boolean_check? or fail
-#
-# Reject
-#
-#     if foo or bar
-#       ...
-#     end
-AndOr:
-  EnforcedStyle: conditionals
-
-# Do not favor modifier if/unless usage when you have a single-line body
-IfUnlessModifier:
-  Enabled: false
-
-# Allow case equality operator (in limited use within the specs)
-CaseEquality:
-  Enabled: false
-
-# Constants do not always have to use SCREAMING_SNAKE_CASE
-ConstantName:
-  Enabled: false
-
-# Not all trivial readers/writers can be defined with attr_* methods
-TrivialAccessors:
-  Enabled: false
-
-# Allow empty lines around class body
-EmptyLinesAroundClassBody:
-  Enabled: false
-
-# Allow empty lines around module body
-EmptyLinesAroundModuleBody:
-  Enabled: false
-
-# Allow empty lines around block body
-EmptyLinesAroundBlockBody:
-  Enabled: false
-
-# Allow multiple line operations to not require indentation
-MultilineOperationIndentation:
-  Enabled: false
-
-# Prefer String#% over Kernel#sprintf
-FormatString:
-  EnforcedStyle: percent
-
-# Use square brackets for literal Array objects
-PercentLiteralDelimiters:
-  PreferredDelimiters:
-    '%':  '{}'
-    '%i': '[]'
-    '%q': ()
-    '%Q': ()
-    '%r': '{}'
-    '%s': ()
-    '%w': '[]'
-    '%W': '[]'
-    '%x': ()
-
-# Use %i[...] for arrays of symbols
-SymbolArray:
-  Enabled: true
-
-# Prefer #kind_of? over #is_a?
-ClassCheck:
-  EnforcedStyle: kind_of?
-
-# Do not prefer double quotes to be used when %q or %Q is more appropriate
-Style/RedundantPercentQ:
-  Enabled: false
-
-# Allow a maximum ABC score
-Metrics/AbcSize:
-  Max: 21.02
-
-Metrics/BlockLength:
-  Exclude:
-  - 'spec/**/*.rb'
-  - 'mutant.gemspec'
-
-# Buggy cop, returns false positive for our code base
-NonLocalExitFromIterator:
-  Enabled: false
-
-# To allow alignment of similar expressions we want to allow more than one
-# space around operators:
-#
-# let(:a) { bar    + something }
-# let(:b) { foobar + something }
-#
-SpaceAroundOperators:
-  Enabled: false
-
-# We use parallel assignments with great success
-ParallelAssignment:
-  Enabled: false
-
-# Allow additional specs
-ExtraSpacing:
-  AllowForAlignment: true
-
-# Buggy
-FormatParameterMismatch:
-  Enabled: false
-
-# Different preference
-SignalException:
-  EnforcedStyle: semantic
-
-# Do not use `alias`
-Alias:
-  EnforcedStyle: prefer_alias_method
-
-# Do not waste my horizontal or vertical space
-Layout/FirstArrayElementIndentation:
-  Enabled: false
-
-# Prefer
-#
-#     some_receiver
-#       .foo
-#       .bar
-#       .baz
-#
-# Over
-#
-#     some_receiver.foo
-#                  .bar
-#                  .baz
-MultilineMethodCallIndentation:
-  EnforcedStyle: indented
-
-# Prefer `public_send` and `__send__` over `send`
-Send:
-  Enabled: true
-
-Layout/HashAlignment:
-  EnforcedColonStyle: table
-  EnforcedHashRocketStyle: table
-Layout/EmptyLineAfterGuardClause:
-  Enabled: false
-Layout/SpaceInsideArrayLiteralBrackets:
-  Enabled: false
-Lint/BooleanSymbol:
-  Enabled: false
-Lint/InterpolationCheck:
-  Enabled: false
-Lint/MissingCopEnableDirective:
-  Enabled: false
-Lint/UnifiedInteger:
-  Enabled: false
-Naming/FileName:
-  Enabled: false
-Style/AccessModifierDeclarations:
-  Enabled: false
-Style/CommentedKeyword:
-  Enabled: false
-Style/MixinGrouping:
-  Enabled: false
-Style/RaiseArgs:
-  Enabled: false
-Style/RescueStandardError:
-  Enabled: false
-Style/StderrPuts:
-  Enabled: false
-# suggesting single letter variablesl bah
-Naming/RescuedExceptionsVariableName:
-  Enabled: false
-# false positive on private keywords
-Layout/IndentationWidth:
-  Enabled: false
-

data/lib/mutant/color.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  # Class to colorize strings
-  class Color
-    include Adamantium::Flat, Concord.new(:code)
-
-    # Format text with color
-    #
-    # @param [String] text
-    #
-    # @return [String]
-    def format(text)
-      "\e[#{code}m#{text}\e[0m"
-    end
-
-    NONE = Class.new(self) do
-
-      # Format null color
-      #
-      # @param [String] text
-      #
-      # @return [String]
-      #   the argument string
-      def format(text)
-        text
-      end
-
-    private
-
-      # Initialize null color
-      #
-      # @return [undefined]
-      def initialize; end
-
-    end.new
-
-    RED   = Color.new(31)
-    GREEN = Color.new(32)
-    BLUE  = Color.new(34)
-
-  end # Color
-end # Mutant

data/lib/mutant/diff.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  # Class to create diffs from source code
-  class Diff
-    include Adamantium::Flat, Concord.new(:old, :new)
-
-    ADDITION = '+'
-    DELETION = '-'
-    NEWLINE  = "\n"
-
-    # Unified source diff between old and new
-    #
-    # @return [String]
-    #   if there is exactly one diff
-    #
-    # @return [nil]
-    #   otherwise
-    def diff
-      return if diffs.empty?
-
-      minimized_hunk.diff(:unified) + NEWLINE
-    end
-    memoize :diff
-
-    # Colorized unified source diff between old and new
-    #
-    # @return [String]
-    #   if there is a diff
-    #
-    # @return [nil]
-    #   otherwise
-    def colorized_diff
-      return unless diff
-      diff.lines.map(&self.class.method(:colorize_line)).join
-    end
-    memoize :colorized_diff
-
-    # Build new object from source strings
-    #
-    # @param [String] old
-    # @param [String] new
-    #
-    # @return [Diff]
-    def self.build(old, new)
-      new(lines(old), lines(new))
-    end
-
-    # Break up source into lines
-    #
-    # @param [String] source
-    #
-    # @return [Array<String>]
-    def self.lines(source)
-      source.lines.map(&:chomp)
-    end
-    private_class_method :lines
-
-  private
-
-    # Diffs between old and new
-    #
-    # @return [Array<Array>]
-    def diffs
-      ::Diff::LCS.diff(old, new)
-    end
-
-    # Raw diff-lcs hunks
-    #
-    # @return [Array<Diff::LCS::Hunk>]
-    def hunks
-      diffs.map do |diff|
-        ::Diff::LCS::Hunk.new(old.map(&:dup), new, diff, max_length, 0)
-      end
-    end
-
-    # Minimized hunk
-    #
-    # @return Diff::LCS::Hunk
-    def minimized_hunk
-      head, *tail = hunks
-
-      tail.reduce(head) do |left, right|
-        right.merge(left)
-        right
-      end
-    end
-
-    # Max length of source line in new and old
-    #
-    # @return [Integer]
-    def max_length
-      [old, new].map(&:length).max
-    end
-
-    # Colorized a unified diff line
-    #
-    # @param [String] line
-    #
-    # @return [String]
-    def self.colorize_line(line)
-      case line[0]
-      when ADDITION
-        Color::GREEN
-      when DELETION
-        Color::RED
-      else
-        Color::NONE
-      end.format(line)
-    end
-    private_class_method :colorize_line
-
-  end # Diff
-end # Mutant

data/lib/mutant/variable.rb

@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  # Lightweight shared variables
-  #
-  # ignore :reek:TooManyMethods
-  class Variable
-    EMPTY = Class.new do
-      const_set(:INSPECT, 'Mutant::Variable::EMPTY')
-    end.new.freeze
-
-    TIMEOUT = Class.new do
-      const_set(:INSPECT, 'Mutant::Variable::TIMEOUT')
-    end.new.freeze
-
-    # Result of operation that may time out
-    class Result
-      include AbstractType, Adamantium::Flat
-
-      # Test if take resulted in a timeout
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      def timeout?
-        instance_of?(Timeout)
-      end
-
-      abstract_method :value
-
-      # Instance returned on timeouts
-      class Timeout < self
-        include Equalizer.new
-
-        INSTANCE = new
-
-        # Construct new object
-        #
-        # @return [Timeout]
-        def self.new
-          INSTANCE
-        end
-      end # Timeout
-
-      # Instance returned without timeouts
-      class Value < self
-        include Concord::Public.new(:value)
-      end # Value
-    end # Result
-
-    private_constant(*constants(false))
-
-    # Initialize object
-    #
-    # @param [Object] value
-    #   the initial value
-    #
-    # @return [undefined]
-    def initialize(condition_variable:, mutex:, value: EMPTY)
-      @full  = condition_variable.new
-      @mutex = mutex.new
-      @value = value
-    end
-
-    # Take value from mvar, block on empty
-    #
-    # @return [Object]
-    def take
-      synchronize do
-        wait_full
-        perform_take
-      end
-    end
-
-    # Take value from mvar, with timeout
-    #
-    # @param [Float] Timeout
-    #
-    # @return [Result::Timeout]
-    #   in case take resulted in a timeout
-    #
-    # @return [Result::Value]
-    #   in case take resulted in a value
-    def take_timeout(timeout)
-      synchronize do
-        if wait_timeout(@full, timeout, &method(:full?))
-          Result::Timeout.new
-        else
-          Result::Value.new(perform_take)
-        end
-      end
-    end
-
-    # Read value from variable
-    #
-    # @return [Object]
-    #   the contents of the mvar
-    def read
-      synchronize do
-        wait_full
-        @value
-      end
-    end
-
-    # Try put value into the variable, non blocking
-    #
-    # @param [Object] value
-    #
-    # @return [self]
-    def try_put(value)
-      synchronize do
-        perform_put(value) if empty?
-      end
-
-      self
-    end
-
-    # Execute block with value, blocking
-    #
-    # @yield [Object]
-    #
-    # @return [Object]
-    #   the blocks return value
-    def with
-      synchronize do
-        wait_full
-        yield @value
-      end
-    end
-
-  private
-
-    # Perform the put
-    #
-    # @param [Object] value
-    def perform_put(value)
-      (@value = value).tap { @full.signal }
-    end
-
-    # Execute block under mutex
-    #
-    # @return [self]
-    def synchronize(&block)
-      @mutex.synchronize(&block)
-    end
-
-    # Wait for block predicate
-    #
-    # @param [ConditionVariable] event
-    #
-    # @return [undefined]
-    def wait(event)
-      event.wait(@mutex) until yield
-    end
-
-    # Wait with timeout for block predicate
-    #
-    # @param [ConditionVariable] event
-    #
-    # @return [Boolean]
-    #   if wait was terminated due a timeout
-    #
-    # @return [undefined]
-    #   otherwise
-    def wait_timeout(event, timeout)
-      loop do
-        break true if timeout <= 0
-        break if yield
-        timeout -= Timer.elapsed { event.wait(@mutex, timeout) }
-      end
-    end
-
-    # Wait till mvar is full
-    #
-    # @return [undefined]
-    def wait_full
-      wait(@full, &method(:full?))
-    end
-
-    # Test if state is full
-    #
-    # @return [Boolean]
-    def full?
-      !empty?
-    end
-
-    # Test if state is empty
-    #
-    # @return [Boolean]
-    def empty?
-      @value.equal?(EMPTY)
-    end
-
-    # Shared variable that can be written at most once
-    #
-    # ignore :reek:InstanceVariableAssumption
-    class IVar < self
-
-      # Exception raised on ivar errors
-      class Error < RuntimeError; end
-
-      # Put valie into the mvar, raises if already full
-      #
-      # @param [Object] value
-      #
-      # @return [self]
-      #
-      # @raise Error
-      #   if already full
-      def put(value)
-        synchronize do
-          fail Error, 'is immutable' if full?
-          perform_put(value)
-        end
-
-        self
-      end
-
-    private
-
-      # Perform take operation
-      #
-      # @return [Object]
-      def perform_take
-        @value
-      end
-    end # IVar
-
-    # Shared variable that can be written multiple times
-    #
-    # ignore :reek:InstanceVariableAssumption
-    class MVar < self
-
-      # Initialize object
-      #
-      # @param [Object] value
-      #   the initial value
-      #
-      # @return [undefined]
-      def initialize(condition_variable:, mutex:, value: EMPTY)
-        super
-        @empty = condition_variable.new
-      end
-
-      # Put value into mvar, block on full
-      #
-      # @param [Object] value
-      #
-      # @return [self]
-      def put(value)
-        synchronize do
-          wait(@empty, &method(:empty?))
-          perform_put(value)
-        end
-
-        self
-      end
-
-      # Modify mvar
-      #
-      # @return [Object]
-      def modify
-        synchronize do
-          wait_full
-          perform_put(yield(@value))
-        end
-      end
-
-    private
-
-      # Empty the mvar
-      #
-      # @return [Object]
-      def perform_take
-        @value.tap do
-          @value = EMPTY
-          @empty.signal
-        end
-      end
-    end # MVar
-  end # Variable
-end # Mutant