mutant 0.9.13 → 0.10.3

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      class Root < self
+        SUBCOMMANDS       = [Run, Subscription].freeze
+        SHORT_DESCRIPTION = 'mutation testing engine main command'
+        NAME              = 'mutant'
+      end
+    end # Command
+  end # CLI
+end # Mutant

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      # rubocop:disable Metrics/ClassLength
+      class Run < self
+        NAME              = 'run'
+        SHORT_DESCRIPTION = 'Run code analysis'
+
+        OPTIONS =
+          %i[
+            add_environment_options
+            add_runner_options
+            add_integration_options
+            add_matcher_options
+          ].freeze
+
+        SLEEP = 40
+
+        UNLICENSED = <<~MESSAGE.lines.freeze
+          Soft fail, continuing in #{SLEEP} seconds
+          Next major version will enforce the license
+          See https://github.com/mbj/mutant#licensing
+        MESSAGE
+
+        # Test if command needs to be executed in zombie environment
+        #
+        # @return [Bool]
+        def zombie?
+          config.zombie
+        end
+
+      private
+
+        def execute
+          soft_fail(License.apply(world))
+            .bind { Config.load_config_file(world, config) }
+            .bind { |cli_config| Bootstrap.apply(world, cli_config) }
+            .bind(&Runner.public_method(:apply))
+            .from_right { |error| world.stderr.puts(error); return false }
+            .success?
+        end
+
+        def soft_fail(result)
+          result.either(
+            lambda do |message|
+              stderr = world.stderr
+              stderr.puts(message)
+              UNLICENSED.each { |line| stderr.puts(unlicensed(line)) }
+              world.kernel.sleep(SLEEP)
+              Either::Right.new(nil)
+            end,
+            ->(_subscription) { Either::Right.new(nil) }
+          )
+        end
+
+        def unlicensed(message)
+          "[Mutant-License-Error]: #{message}"
+        end
+
+        def parse_remaining_arguments(arguments)
+          traverse(config.expression_parser.public_method(:apply), arguments)
+            .fmap do |match_expressions|
+              matcher(match_expressions: match_expressions)
+              self
+            end
+        end
+
+        def traverse(action, values)
+          Either::Right.new(
+            values.map do |value|
+              action.call(value).from_right do |error|
+                return Either::Left.new(error)
+              end
+            end
+          )
+        end
+
+        def set(**attributes)
+          @config = config.with(attributes)
+        end
+
+        def matcher(**attributes)
+          set(matcher: config.matcher.with(attributes))
+        end
+
+        def add(attribute, value)
+          set(attribute => config.public_send(attribute) + [value])
+        end
+
+        def add_matcher(attribute, value)
+          set(matcher: config.matcher.add(attribute, value))
+        end
+
+        def add_environment_options(parser)
+          parser.separator('Environment:')
+          parser.on('--zombie', 'Run mutant zombified') do
+            set(zombie: true)
+          end
+          parser.on('-I', '--include DIRECTORY', 'Add DIRECTORY to $LOAD_PATH') do |directory|
+            add(:includes, directory)
+          end
+          parser.on('-r', '--require NAME', 'Require file with NAME') do |name|
+            add(:requires, name)
+          end
+        end
+
+        def add_integration_options(parser)
+          parser.separator('Integration:')
+
+          parser.on('--use INTEGRATION', 'Use INTEGRATION to kill mutations') do |name|
+            set(integration: name)
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def add_matcher_options(parser)
+          parser.separator('Matcher:')
+
+          parser.on('--ignore-subject EXPRESSION', 'Ignore subjects that match EXPRESSION as prefix') do |pattern|
+            add_matcher(:ignore_expressions, config.expression_parser.apply(pattern).from_right)
+          end
+          parser.on('--start-subject EXPRESSION', 'Start mutation testing at a specific subject') do |pattern|
+            add_matcher(:start_expressions, config.expression_parser.apply(pattern).from_right)
+          end
+          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)
+              )
+            )
+          end
+        end
+
+        def add_runner_options(parser)
+          parser.separator('Runner:')
+
+          parser.on('--fail-fast', 'Fail fast') do
+            set(fail_fast: true)
+          end
+          parser.on('-j', '--jobs NUMBER', 'Number of kill jobs. Defaults to number of processors.') do |number|
+            set(jobs: Integer(number))
+          end
+        end
+      end # Run
+      # rubocop:enable Metrics/ClassLength
+    end # Command
+  end # CLI
+end # Mutant

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      class Subscription < self
+        NAME              = 'subscription'
+        SHORT_DESCRIPTION = 'Subscription subcommands'
+
+      private
+
+        def license
+          License.apply(world)
+        end
+
+        class Test < self
+          NAME              = 'test'
+          SUBCOMMANDS       = [].freeze
+          SHORT_DESCRIPTION = 'Silently validates subscription, exits accordingly'
+
+        private
+
+          def execute
+            license.right?
+          end
+        end # Test
+
+        class Show < self
+          NAME              = 'show'
+          SUBCOMMANDS       = [].freeze
+          SHORT_DESCRIPTION = 'Show subscription status'
+
+        private
+
+          def execute
+            license.either(method(:unlicensed), method(:licensed))
+          end
+
+          def licensed(subscription)
+            world.stdout.puts(subscription.description)
+            true
+          end
+
+          def unlicensed(message)
+            world.stderr.puts(message)
+            false
+          end
+        end # Show
+
+        SUBCOMMANDS = [Show, Test].freeze
+      end # Subscription
+    end # Command
+  end # CLI
+end # Mutant

data/lib/mutant/expression.rb

@@ -59,6 +59,5 @@ module Mutant
       names = anima.attribute_names
       new(Hash[names.zip(names.map(&match.method(:[])))])
     end
-
   end # Expression
 end # Mutant

data/lib/mutant/license.rb

@@ -4,53 +4,27 @@ module Mutant
   module License
     NAME    = 'mutant-license'
     VERSION = '~> 0.1.0'
-    SLEEP   = 40
-
-    UNLICENSED =
-      IceNine.deep_freeze(
-        [
-          "Soft fail, continuing in #{SLEEP} seconds",
-          'Next major version will enforce the license',
-          'See https://github.com/mbj/mutant#licensing'
-        ]
-      )
 
+    # Load license
+    #
+    # @param [World] world
+    #
+    # @return [Either<String,Subscription>]
+    #
+    # @api private
     def self.apply(world)
-      soft_fail(world, license_result(world))
-    end
-
-    def self.license_result(world)
       load_mutant_license(world)
         .fmap { license_path(world) }
-        .fmap { |path| Subscription.from_json(world.json.load(path)) }
-        .bind { |sub| sub.apply(world) }
+        .bind { |path| Subscription.load(world, world.json.load(path)) }
     end
-    private_class_method :license_result
-
-    # ignore :reek:NestedIterators
-    def self.soft_fail(world, result)
-      result.lmap do |message|
-        stderr = world.stderr
-        stderr.puts(message)
-        UNLICENSED.each { |line| stderr.puts(unlicensed(line)) }
-        world.kernel.sleep(SLEEP)
-      end
-
-      Either::Right.new(true)
-    end
-    private_class_method :soft_fail
 
     def self.load_mutant_license(world)
       Either
         .wrap_error(LoadError) { world.gem_method.call(NAME, VERSION) }
         .lmap(&:message)
         .lmap(&method(:check_for_rubygems_mutant_license))
-        .lmap(&method(:unlicensed))
-    end
-
-    def self.unlicensed(message)
-      "[Mutant-License-Error]: #{message}"
     end
+    private_class_method :load_mutant_license
 
     def self.check_for_rubygems_mutant_license(message)
       if message.include?('already activated mutant-license-0.0.0')

data/lib/mutant/license/subscription.rb

@@ -3,8 +3,15 @@
 module Mutant
   module License
     class Subscription
+      include Concord.new(:licensed)
 
-      MESSAGE_FORMAT = <<~'MESSAGE'
+      FORMAT = <<~'MESSAGE'
+        %<subscription_name>s subscription:
+        Licensed:
+        %<licensed>s
+      MESSAGE
+
+      FAILURE_FORMAT = <<~'MESSAGE'
         Can not validate %<subscription_name>s license.
         Licensed:
         %<expected>s
@@ -12,31 +19,46 @@ module Mutant
         %<actual>s
       MESSAGE
 
-      def self.from_json(value)
+      # Load value into subscription
+      #
+      # @param [Object] value
+      #
+      # @return [Subscription]
+      def self.load(world, value)
         {
           'com' => Commercial,
           'oss' => Opensource
-        }.fetch(value.fetch('type')).from_json(value.fetch('contents'))
+        }.fetch(value.fetch('type'))
+          .from_json(value.fetch('contents'))
+          .apply(world)
+      end
+
+      # Subscription self description
+      #
+      # @return [String]
+      def description
+        FORMAT % {
+          licensed:          licensed.to_a.join("\n"),
+          subscription_name: subscription_name
+        }
       end
 
     private
 
       def failure(expected, actual)
-        Either::Left.new(message(expected, actual))
+        Either::Left.new(failure_message(expected, actual))
       end
 
-      # ignore :reek:UtilityFunction
       def success
-        # masked by soft fail
-        Either::Right.new(nil)
+        Either::Right.new(self)
       end
 
       def subscription_name
         self.class.name.split('::').last.downcase
       end
 
-      def message(expected, actual)
-        MESSAGE_FORMAT % {
+      def failure_message(expected, actual)
+        FAILURE_FORMAT % {
           actual:            actual.any? ? actual.map(&:to_s).join("\n") : '[none]',
           expected:          expected.map(&:to_s).join("\n"),
           subscription_name: subscription_name

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

@@ -4,8 +4,6 @@ module Mutant
   module License
     class Subscription
       class Commercial < self
-        include Concord.new(:authors)
-
         class Author
           include Concord.new(:email)
 
@@ -20,10 +18,10 @@ module Mutant
         def apply(world)
           candidates = candidates(world)
 
-          if (authors & candidates).any?
+          if (licensed & candidates).any?
             success
           else
-            failure(authors, candidates)
+            failure(licensed, candidates)
           end
         end
 

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

@@ -4,8 +4,6 @@ module Mutant
   module License
     class Subscription
       class Opensource < self
-        include Concord.new(:repositories)
-
         class Repository
           include Concord.new(:host, :path)
 
@@ -43,10 +41,13 @@ module Mutant
           private_class_method :parse_url
         end
 
-        private_constant(*constants(false))
-
         def self.from_json(value)
-          new(value.fetch('repositories').map(&Repository.method(:parse)))
+          new(
+            value
+              .fetch('repositories')
+              .map(&Repository.public_method(:parse))
+              .to_set
+          )
         end
 
         def apply(world)
@@ -59,10 +60,10 @@ module Mutant
       private
 
         def check_subscription(actual)
-          if (repositories.to_set & actual).any?
+          if (licensed & actual).any?
             success
           else
-            failure(repositories, actual)
+            failure(licensed, actual)
           end
         end
 

data/lib/mutant/meta/example.rb

@@ -3,7 +3,19 @@
 module Mutant
   module Meta
     class Example
-      include Adamantium, Anima.new(:file, :node, :types, :expected)
+      include Adamantium
+      include Anima.new(
+        :expected,
+        :file,
+        :lvars,
+        :node,
+        :original_source,
+        :types
+      )
+
+      class Expected
+        include Anima.new(:original_source, :node)
+      end
 
       # Verification instance for example
       #
@@ -13,13 +25,13 @@ module Mutant
       end
       memoize :verification
 
-      # Normalized source
+      # Original source as generated by unparser
       #
       # @return [String]
-      def source
+      def original_source_generated
         Unparser.unparse(node)
       end
-      memoize :source
+      memoize :original_source_generated
 
       # Generated mutations on example source
       #