mutant 0.11.18 → 0.11.19

data/lib/mutant/bootstrap.rb

@@ -51,7 +51,7 @@ module Mutant
           env.with(
             integration: integration,
             mutations:   mutations,
-            selector:    Selector::Expression.new(integration),
+            selector:    Selector::Expression.new(integration: integration),
             subjects:    selected_subjects
           )
         end
@@ -115,7 +115,7 @@ module Mutant
 
         scopes = env.world.object_space.each_object(Module).with_object([]) do |scope, aggregate|
           expression = expression(config.reporter, config.expression_parser, scope) || next
-          aggregate << Scope.new(scope, expression)
+          aggregate << Scope.new(raw: scope, expression: expression)
         end
 
         scopes.sort_by { |scope| scope.expression.syntax }

data/lib/mutant/cli/command/environment/run.rb

@@ -36,7 +36,7 @@ module Mutant
             License.call(world)
               .bind { bootstrap }
               .bind(&method(:validate_tests))
-              .bind(&Runner.public_method(:call))
+              .bind(&Mutation::Runner.public_method(:call))
               .bind(&method(:from_result))
           end
 

data/lib/mutant/cli/command/environment.rb

@@ -105,9 +105,7 @@ module Mutant
           parser.on('--since REVISION', 'Only select subjects touched since REVISION') do |revision|
             add_matcher(
               :subject_filters,
-              Repository::SubjectFilter.new(
-                Repository::Diff.new(to: revision, world: world)
-              )
+              Repository::SubjectFilter.new(diff: Repository::Diff.new(to: revision, world: world))
             )
           end
         end

data/lib/mutant/cli/command/util.rb

@@ -35,7 +35,7 @@ module Mutant
             memoize :node
 
             class File < self
-              include Concord.new(:pathname, :source)
+              include Anima.new(:pathname, :source)
 
               public :source
 
@@ -45,7 +45,7 @@ module Mutant
             end # File
 
             class Source < self
-              include Concord::Public.new(:source)
+              include Anima.new(:source)
 
               def identification
                 '<cli-source>'
@@ -62,7 +62,7 @@ module Mutant
 
           def add_target_options(parser)
             parser.on('-e', '--evaluate SOURCE') do |source|
-              @targets << Target::Source.new(source)
+              @targets << Target::Source.new(source: source)
             end
 
             parser.on('-i', '--ignore-pattern AST_PATTERN') do |pattern|
@@ -78,8 +78,8 @@ module Mutant
               node:   target.node
             ).each do |mutation|
               Reporter::CLI::Printer::Mutation.call(
-                world.stdout,
-                Mutant::Mutation::Evil.new(target, mutation)
+                object: Mutant::Mutation::Evil.new(subject: target, node: mutation),
+                output: world.stdout
               )
             end
           end
@@ -97,7 +97,7 @@ module Mutant
           end
 
           def read_file(pathname)
-            Either::Right.new(Target::File.new(pathname, pathname.read))
+            Either::Right.new(Target::File.new(pathname: pathname, source: pathname.read))
           rescue StandardError => exception
             Either::Left.new("Cannot read file: #{exception}")
           end

data/lib/mutant/config/coverage_criteria.rb

@@ -20,12 +20,21 @@ module Mutant
 
       TRANSFORM =
         Transform::Sequence.new(
-          [
+          steps: [
             Transform::Hash.new(
               optional: [
-                Transform::Hash::Key.new('process_abort', Transform::BOOLEAN),
-                Transform::Hash::Key.new('test_result',   Transform::BOOLEAN),
-                Transform::Hash::Key.new('timeout',       Transform::BOOLEAN)
+                Transform::Hash::Key.new(
+                  transform: Transform::BOOLEAN,
+                  value:     'process_abort'
+                ),
+                Transform::Hash::Key.new(
+                  transform: Transform::BOOLEAN,
+                  value:     'test_result'
+                ),
+                Transform::Hash::Key.new(
+                  transform: Transform::BOOLEAN,
+                  value:     'timeout'
+                )
               ],
               required: []
             ),

data/lib/mutant/config.rb

@@ -101,8 +101,8 @@ module Mutant
     def self.load_contents(env, path)
       Transform::Named
         .new(
-          path.to_s,
-          sequence(env.config.reporter)
+          name:      path.to_s,
+          transform: sequence(env.config.reporter)
         )
         .call(path)
         .lmap(&:compact_message)
@@ -111,11 +111,11 @@ module Mutant
 
     def self.sequence(reporter)
       Transform::Sequence.new(
-        [
-          Transform::Exception.new(SystemCallError, :read.to_proc),
-          Transform::Exception.new(YAML::SyntaxError, YAML.public_method(:safe_load)),
-          Transform::Primitive.new(Hash),
-          Transform::Success.new(->(hash) { deprecations(reporter, hash) }),
+        steps: [
+          Transform::Exception.new(error_class: SystemCallError,   block: :read.to_proc),
+          Transform::Exception.new(error_class: YAML::SyntaxError, block: YAML.public_method(:safe_load)),
+          Transform::Primitive.new(primitive: Hash),
+          Transform::Success.new(block: ->(hash) { deprecations(reporter, hash) }),
           *TRANSFORMS
         ]
       )
@@ -130,10 +130,10 @@ module Mutant
     end
 
     PATHNAME_ARRAY = Transform::Array.new(
-      Transform::Sequence.new(
-        [
+      transform: Transform::Sequence.new(
+        steps: [
           Transform::STRING,
-          Transform::Exception.new(ArgumentError, Pathname.public_method(:new))
+          Transform::Exception.new(error_class: ArgumentError, block: Pathname.public_method(:new))
         ]
       )
     )
@@ -170,24 +170,51 @@ module Mutant
     TRANSFORMS = [
       Transform::Hash.new(
         optional: [
-          Transform::Hash::Key.new('coverage_criteria', ->(value) { CoverageCriteria::TRANSFORM.call(value) }),
           Transform::Hash::Key.new(
-            'environment_variables',
-            Transform::Sequence.new(
-              [
-                Transform::Primitive.new(Hash),
+            transform: ->(value) { CoverageCriteria::TRANSFORM.call(value) },
+            value:     'coverage_criteria'
+          ),
+          Transform::Hash::Key.new(
+            transform: Transform::Sequence.new(
+              steps: [
+                Transform::Primitive.new(primitive: Hash),
                 Transform::Block.capture(:environment_variables, &method(:parse_environment_variables))
               ]
-            )
+            ),
+            value:     'environment_variables'
+          ),
+          Transform::Hash::Key.new(
+            transform: Transform::BOOLEAN,
+            value:     'fail_fast'
+          ),
+          Transform::Hash::Key.new(
+            transform: PATHNAME_ARRAY,
+            value:     'hooks'
+          ),
+          Transform::Hash::Key.new(
+            transform: Transform::STRING_ARRAY,
+            value:     'includes'
           ),
-          Transform::Hash::Key.new('fail_fast',   Transform::BOOLEAN),
-          Transform::Hash::Key.new('hooks',       PATHNAME_ARRAY),
-          Transform::Hash::Key.new('includes',    Transform::STRING_ARRAY),
-          Transform::Hash::Key.new('integration', Transform::STRING),
-          Transform::Hash::Key.new('jobs',        Transform::INTEGER),
-          Transform::Hash::Key.new('matcher',     Matcher::Config::LOADER),
-          Transform::Hash::Key.new('mutation',    Mutation::Config::TRANSFORM),
-          Transform::Hash::Key.new('requires',    Transform::STRING_ARRAY)
+          Transform::Hash::Key.new(
+            transform: Transform::STRING,
+            value:     'integration'
+          ),
+          Transform::Hash::Key.new(
+            transform: Transform::INTEGER,
+            value:     'jobs'
+          ),
+          Transform::Hash::Key.new(
+            transform: Matcher::Config::LOADER,
+            value:     'matcher'
+          ),
+          Transform::Hash::Key.new(
+            transform: Mutation::Config::TRANSFORM,
+            value:     'mutation'
+          ),
+          Transform::Hash::Key.new(
+            transform: Transform::STRING_ARRAY,
+            value:     'requires'
+          )
         ],
         required: []
       ),

data/lib/mutant/context.rb

@@ -3,7 +3,7 @@
 module Mutant
   # An abstract context where mutations can be applied to.
   class Context
-    include Adamantium, Concord::Public.new(:scope, :source_path)
+    include Adamantium, Anima.new(:scope, :source_path)
     extend AST::Sexp
 
     NAMESPACE_DELIMITER = '::'
@@ -74,11 +74,6 @@ module Mutant
     end
     memoize :match_expressions
 
-    # Scope wrapped by context
-    #
-    # @return [Module|Class]
-    attr_reader :scope
-
   private
 
     def name_nesting

data/lib/mutant/env.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Mutant
-  # Abstract base class for mutant environments
+  # Mutation testing execution environment
   class Env
     include Adamantium, Anima.new(
       :config,

data/lib/mutant/expression/method.rb

@@ -41,11 +41,14 @@ module Mutant
       # @return [Matcher]
       def matcher
         matcher_candidates = MATCHERS.fetch(scope_symbol)
-          .map { |submatcher| submatcher.new(scope) }
+          .map { |submatcher| submatcher.new(scope: scope) }
 
-        methods_matcher = Matcher::Chain.new(matcher_candidates)
+        methods_matcher = Matcher::Chain.new(matchers: matcher_candidates)
 
-        Matcher::Filter.new(methods_matcher, ->(subject) { subject.expression.eql?(self) })
+        Matcher::Filter.new(
+          matcher:   methods_matcher,
+          predicate: ->(subject) { subject.expression.eql?(self) }
+        )
       end
 
       def self.try_parse(input)

data/lib/mutant/expression/methods.rb

@@ -36,9 +36,9 @@ module Mutant
       # @return [Matcher::Method]
       def matcher
         matcher_candidates = MATCHERS.fetch(scope_symbol)
-          .map { |submatcher| submatcher.new(scope) }
+          .map { |submatcher| submatcher.new(scope: scope) }
 
-        Matcher::Chain.new(matcher_candidates)
+        Matcher::Chain.new(matchers: matcher_candidates)
       end
 
       # Length of match with other expression

data/lib/mutant/expression/namespace.rb

@@ -35,7 +35,7 @@ module Mutant
         #
         # @return [Matcher]
         def matcher
-          Matcher::Namespace.new(self)
+          Matcher::Namespace.new(expression: self)
         end
 
         # Length of match with other expression
@@ -69,7 +69,7 @@ module Mutant
           scope = find_scope
 
           if scope
-            Matcher::Scope.new(scope)
+            Matcher::Scope.new(scope: scope)
           else
             Matcher::Null.new
           end

data/lib/mutant/expression/parser.rb

@@ -3,7 +3,7 @@
 module Mutant
   class Expression
     class Parser
-      include Concord.new(:types)
+      include Anima.new(:types)
 
       # Parse expression
       #

data/lib/mutant/hooks.rb

@@ -2,7 +2,7 @@
 
 module Mutant
   class Hooks
-    include Adamantium, Concord::Public.new(:map)
+    include Adamantium, Anima.new(:map)
 
     DEFAULTS = %i[
       env_infection_pre
@@ -23,12 +23,12 @@ module Mutant
     end
 
     def self.empty
-      new(DEFAULTS)
+      new(map: DEFAULTS)
     end
 
     def merge(other)
       self.class.new(
-        other.map.merge(map) { |_key, new, old| (old + new).freeze }.freeze
+        map: other.map.merge(map) { |_key, new, old| (old + new).freeze }.freeze
       )
     end
 
@@ -54,7 +54,7 @@ module Mutant
       end
 
       def to_hooks
-        Hooks.new(@map.transform_values(&:freeze).freeze)
+        Hooks.new(map: @map.transform_values(&:freeze).freeze)
       end
     end # Builder
 

data/lib/mutant/isolation/fork.rb

@@ -28,7 +28,7 @@ module Mutant
     # * Child process freezing after closing the pipes needs to be
     #   detected by parent process.
     class Fork < self
-      include(Adamantium, Concord.new(:world))
+      include(Adamantium, Anima.new(:world))
 
       READ_SIZE = 4096
 

data/lib/mutant/license/subscription/commercial.rb

@@ -5,14 +5,14 @@ module Mutant
     class Subscription
       class Commercial < self
         class Author
-          include Concord.new(:email)
+          include Anima.new(:email)
 
           alias_method :to_s, :email
           public :to_s
         end
 
         def self.from_json(value)
-          new(value.fetch('authors').map(&Author.public_method(:new)).to_set)
+          new(licensed: value.fetch('authors').to_set { |email| Author.new(email: email) })
         end
 
         def call(world)
@@ -43,7 +43,7 @@ module Mutant
           world
             .capture_stdout(command)
             .fmap(&:chomp)
-            .fmap(&Author.public_method(:new))
+            .fmap { |email| Author.new(email: email) }
             .fmap { |value| Set.new([value]) }
             .from_right { Set.new }
         end

data/lib/mutant/license/subscription/opensource.rb

@@ -5,7 +5,7 @@ module Mutant
     class Subscription
       class Opensource < self
         class Repository
-          include Concord.new(:host, :path)
+          include Anima.new(:host, :path)
 
           REMOTE_REGEXP    = /\A[^\t]+\t(?<url>[^ ]+) \((?:fetch|push)\)\n\z/.freeze
           GIT_SSH_REGEXP   = %r{\A[^@]+@(?<host>[^:/]+)[:/](?<path>.+?)(?:\.git)?\z}.freeze
@@ -18,7 +18,8 @@ module Mutant
           end
 
           def self.parse(input)
-            new(*input.split('/', 2).map(&:downcase))
+            host, path = *input.split('/', 2).map(&:downcase)
+            new(host: host, path: path)
           end
 
           def self.parse_remote(input)
@@ -36,7 +37,7 @@ module Mutant
               fail "Unmatched git remote URL: #{input.inspect}"
             end
 
-            new(match[:host], match[:path].downcase)
+            new(host: match[:host], path: match[:path].downcase)
           end
           private_class_method :parse_url
 
@@ -52,12 +53,7 @@ module Mutant
         end # Opensource
 
         def self.from_json(value)
-          new(
-            value
-              .fetch('repositories')
-              .map(&Repository.public_method(:parse))
-              .to_set
-          )
+          new(licensed: value.fetch('repositories').map(&Repository.public_method(:parse)).to_set)
         end
 
         def call(world)

data/lib/mutant/license/subscription.rb

@@ -3,7 +3,7 @@
 module Mutant
   module License
     class Subscription
-      include Concord.new(:licensed)
+      include Anima.new(:licensed)
 
       FORMAT = <<~'MESSAGE'
         %<subscription_name>s subscription:

data/lib/mutant/matcher/chain.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # Matcher chaining results of other matchers together
     class Chain < self
-      include Concord.new(:matchers)
+      include Anima.new(:matchers)
 
       # Call matcher
       #

data/lib/mutant/matcher/config.rb

@@ -31,15 +31,21 @@ module Mutant
         Mutant::Config::DEFAULT.expression_parser.call(input)
       end
 
-      expression_array = Transform::Array.new(expression)
+      expression_array = Transform::Array.new(transform: expression)
 
       LOADER =
         Transform::Sequence.new(
-          [
+          steps: [
             Transform::Hash.new(
               optional: [
-                Transform::Hash::Key.new('subjects', expression_array),
-                Transform::Hash::Key.new('ignore', expression_array)
+                Transform::Hash::Key.new(
+                  transform: expression_array,
+                  value:     'subjects'
+                ),
+                Transform::Hash::Key.new(
+                  transform: expression_array,
+                  value:     'ignore'
+                )
               ],
               required: []
             ),

data/lib/mutant/matcher/descendants.rb

@@ -10,7 +10,7 @@ module Mutant
         const = env.world.try_const_get(const_name) or return EMPTY_ARRAY
 
         Chain.new(
-          matched_scopes(env, const).map { |scope| Scope.new(scope.raw) }
+          matchers: matched_scopes(env, const).map { |scope| Scope.new(scope: scope.raw) }
         ).call(env)
       end
 

data/lib/mutant/matcher/filter.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # Matcher filter
     class Filter < self
-      include Concord.new(:matcher, :predicate)
+      include Anima.new(:matcher, :predicate)
 
       # Enumerate matches
       #

data/lib/mutant/matcher/method/instance.rb

@@ -12,7 +12,9 @@ module Mutant
         # @param [UnboundMethod] method
         #
         # @return [Matcher::Method::Instance]
-        def self.new(scope, target_method)
+        #
+        # rubocop:disable Metrics/MethodLength
+        def self.new(scope:, target_method:)
           evaluator =
             if memoized_method?(scope, target_method.name)
               Evaluator::Memoized
@@ -20,8 +22,13 @@ module Mutant
               Evaluator
             end
 
-          super(scope, target_method, evaluator)
+          super(
+            evaluator:     evaluator,
+            scope:         scope,
+            target_method: target_method
+          )
         end
+        # rubocop:enable Metrics/MethodLength
 
         def self.memoized_method?(scope, method_name)
           scope < Adamantium && scope.memoized?(method_name)
@@ -37,8 +44,6 @@ module Mutant
         private
 
           def match?(node)
-            n_def?(node)                           &&
-            node.location.line.equal?(source_line) &&
             node.children.fetch(NAME_INDEX).equal?(method_name)
           end
 

data/lib/mutant/matcher/method/metaclass.rb

@@ -11,12 +11,9 @@ module Mutant
 
         # New singleton method matcher
         #
-        # @param [Class, Module] scope
-        # @param [Symbol] method_name
-        #
         # @return [Matcher::Method::Singleton]
-        def self.new(scope, method_name)
-          super(scope, method_name, Evaluator)
+        def self.new(scope:, target_method:)
+          super(scope: scope, target_method: target_method, evaluator: Evaluator)
         end
 
         # Metaclass method evaluator
@@ -34,10 +31,7 @@ module Mutant
         private
 
           def match?(node)
-            n_def?(node) &&
-              name?(node) &&
-              line?(node) &&
-              metaclass_receiver?(node)
+            name?(node) && metaclass_receiver?(node)
           end
 
           def metaclass_receiver?(node)
@@ -46,14 +40,7 @@ module Mutant
           end
 
           def metaclass_containing(node)
-            AST::FindMetaclassContaining.call(ast, node)
-          end
-
-          def line?(node)
-            node
-              .location
-              .line
-              .equal?(source_line)
+            AST::FindMetaclassContaining.call(ast: ast, target: node)
           end
 
           def name?(node)

data/lib/mutant/matcher/method/singleton.rb

@@ -8,12 +8,9 @@ module Mutant
 
         # New singleton method matcher
         #
-        # @param [Class, Module] scope
-        # @param [Symbol] method_name
-        #
         # @return [Matcher::Method::Singleton]
-        def self.new(scope, method_name)
-          super(scope, method_name, Evaluator)
+        def self.new(scope:, target_method:)
+          super(scope: scope, target_method: target_method, evaluator: Evaluator)
         end
 
         # Singleton method evaluator
@@ -27,14 +24,7 @@ module Mutant
         private
 
           def match?(node)
-            n_defs?(node) && line?(node) && name?(node) && receiver?(node)
-          end
-
-          def line?(node)
-            node
-              .location
-              .line
-              .equal?(source_line)
+            name?(node) && receiver?(node)
           end
 
           def name?(node)

data/lib/mutant/matcher/method.rb

@@ -6,7 +6,7 @@ module Mutant
     class Method < self
       include AbstractType,
               Adamantium,
-              Concord::Public.new(:scope, :target_method, :evaluator)
+              Anima.new(:scope, :target_method, :evaluator)
 
       SOURCE_LOCATION_WARNING_FORMAT =
         '%s does not have a valid source location, unable to emit subject'
@@ -20,7 +20,7 @@ module Mutant
       #
       # @return [Enumerable<Subject>]
       def call(env)
-        evaluator.call(scope, target_method, env)
+        evaluator.call(scope: scope, target_method: target_method, env: env)
       end
 
       # Abstract method match evaluator
@@ -32,7 +32,7 @@ module Mutant
         include(
           AbstractType,
           Adamantium,
-          Concord.new(:scope, :target_method, :env),
+          Anima.new(:scope, :target_method, :env),
           Procto,
           AST::NodePredicates
         )
@@ -80,7 +80,7 @@ module Mutant
         end
 
         def context
-          Context.new(scope, source_path)
+          Context.new(scope: scope, source_path: source_path)
         end
 
         def ast

data/lib/mutant/matcher/methods.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # Abstract base class for matcher that returns method subjects from scope
     class Methods < self
-      include AbstractType, Concord.new(:scope)
+      include AbstractType, Anima.new(:scope)
 
       CANDIDATE_NAMES = %i[
         public_instance_methods
@@ -21,7 +21,9 @@ module Mutant
       # @return [Enumerable<Subject>]
       def call(env)
         Chain.new(
-          methods(env).map { |method| matcher.new(scope, method) }
+          matchers: methods(env).map do |target_method|
+            matcher.new(scope: scope, target_method: target_method)
+          end
         ).call(env)
       end