mutant 0.8.24 → 0.9.0

data/lib/mutant/license.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mutant
+  module License
+    def self.apply(world)
+      soft_fail(world, license_result(world))
+    end
+
+    def self.license_result(world)
+      Subscription.from_json(world.json.load(license_path(world))).apply(world)
+    end
+    private_class_method :license_result
+
+    def self.soft_fail(world, license_result)
+      license_result.lmap do |message|
+        stderr = world.stderr
+        stderr.puts(message)
+        stderr.puts('Soft fail, continuing in 10 seconds')
+        world.kernel.sleep(10)
+      end
+
+      Either::Right.new(true)
+    end
+    private_class_method :soft_fail
+
+    def self.license_path(world)
+      world
+        .pathname
+        .new(world.gem.loaded_specs.fetch('mutant-license').full_gem_path)
+        .join('license.json')
+    end
+    private_class_method :license_path
+  end
+end

data/lib/mutant/license/subscription.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mutant
+  module License
+    class Subscription
+
+      MESSAGE_FORMAT = <<~'MESSAGE'
+        Can not validate %<subscription_name>s license.
+        Licensed:
+        %<expected>s
+        Present:
+        %<actual>s
+      MESSAGE
+
+      def self.from_json(value)
+        {
+          'com' => Commercial,
+          'oss' => Opensource
+        }.fetch(value.fetch('type')).from_json(value.fetch('contents'))
+      end
+
+    private
+
+      def failure(expected, actual)
+        Either::Left.new(message(expected, actual))
+      end
+
+      # ignore :reek:UtilityFunction
+      def success
+        # masked by soft fail
+        Either::Right.new(nil)
+      end
+
+      def subscription_name
+        self.class.name.split('::').last.downcase
+      end
+
+      def message(expected, actual)
+        MESSAGE_FORMAT % {
+          actual:            actual.any? ? actual.map(&:to_s).join("\n") : '[none]',
+          expected:          expected.map(&:to_s).join("\n"),
+          subscription_name: subscription_name
+        }
+      end
+    end # Subscription
+  end # License
+end # Mutant

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Mutant
+  module License
+    class Subscription
+      class Commercial < self
+        include Concord.new(:authors)
+
+        class Author
+          include Concord.new(:email)
+
+          alias_method :to_s, :email
+          public :to_s
+        end
+
+        def self.from_json(value)
+          new(value.fetch('authors').map(&Author.method(:new)).to_set)
+        end
+
+        def apply(world)
+          candidates = candidates(world)
+
+          if (authors & candidates).any?
+            success
+          else
+            failure(authors, candidates)
+          end
+        end
+
+      private
+
+        def candidates(world)
+          git_author(world).merge(commit_author(world))
+        end
+
+        def git_author(world)
+          capture(world, %w[git config --get user.email])
+        end
+
+        def commit_author(world)
+          capture(world, %w[git show --quiet --pretty=format:%ae])
+        end
+
+        # ignore :reek:UtilityFunction
+        def capture(world, command)
+          world
+            .capture_stdout(command)
+            .fmap(&:chomp)
+            .fmap(&Author.method(:new))
+            .fmap { |value| Set.new([value]) }
+            .from_right { Set.new }
+        end
+
+      end # Commercial
+    end # Subscription
+  end # License
+end # Mutant

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Mutant
+  module License
+    class Subscription
+      class Opensource < self
+        include Concord.new(:repositories)
+
+        class Repository
+          include Concord.new(:host, :path)
+
+          REMOTE_REGEXP    = /\A[^\t]+\t(?<url>[^ ]+) \((?:fetch|push)\)\n\z/.freeze
+          GIT_SSH_REGEXP   = %r{\A[^@]+@(?<host>[^:/]+)[:/](?<path>.+?)(?:\.git)?\z}.freeze
+          GIT_HTTPS_REGEXP = %r{\Ahttps://(?<host>[^/]+)/(?<path>.+?)(?:\.git)?\z}.freeze
+
+          private_constant(*constants(false))
+
+          def to_s
+            [host, path].join('/')
+          end
+
+          def self.parse(input)
+            new(*input.split('/', 2))
+          end
+
+          def self.parse_remote(input)
+            match = REMOTE_REGEXP.match(input) or
+              fail "Unmatched remote line: #{input.inspect}"
+
+            parse_url(match[:url])
+          end
+          private_class_method :parse_remote
+
+          def self.parse_url(input)
+            match = GIT_SSH_REGEXP.match(input) || GIT_HTTPS_REGEXP.match(input)
+
+            unless match
+              fail "Unmatched git remote URL: #{input.inspect}"
+            end
+
+            new(match[:host], match[:path])
+          end
+          private_class_method :parse_url
+        end
+
+        private_constant(*constants(false))
+
+        def self.from_json(value)
+          new(value.fetch('repositories').map(&Repository.method(:parse)))
+        end
+
+        def apply(world)
+          world
+            .capture_stdout(%w[git remote --verbose])
+            .fmap(&method(:parse_remotes))
+            .apply(&method(:check_subscription))
+        end
+
+      private
+
+        def check_subscription(actual)
+          if (repositories.to_set & actual).any?
+            success
+          else
+            failure(repositories, actual)
+          end
+        end
+
+        # ignore :reek:UtilityFunction
+        def parse_remotes(input)
+          input.lines.map(&Repository.method(:parse_remote)).to_set
+        end
+
+      end # Opensource
+    end # Subscription
+  end # License
+end # Mutant

data/lib/mutant/loader.rb

@@ -1,26 +1,40 @@
 # frozen_string_literal: true
 
 module Mutant
-  # Base class for code loaders
   class Loader
     include Anima.new(:binding, :kernel, :source, :subject)
 
     FROZEN_STRING_FORMAT = "# frozen_string_literal: true\n%s"
+    VOID_VALUE_REGEXP    = /\A[^:]+:\d+: void value expression/.freeze
 
     private_constant(*constants(false))
 
+    class Result
+      include Singleton
+
+      # Vale returned on successful load
+      class Success < self
+      end # Success
+
+      # Vale returned on MRI detecting void value expressions
+      class VoidValue < self
+      end # voidValue
+    end # Result
+
     # Call loader
     #
-    # @return [self]
+    # @return [Result]
     def self.call(*arguments)
       new(*arguments).call
     end
 
     # Call loader
     #
-    # One off the very few valid uses of eval
+    # One off the very few valid uses of eval ever.
+    #
+    # @return [Result]
     #
-    # @return [undefined]
+    # rubocop:disable Metrics/MethodLength
     def call
       kernel.eval(
         FROZEN_STRING_FORMAT % source,
@@ -28,6 +42,15 @@ module Mutant
         subject.source_path.to_s,
         subject.source_line
       )
+    rescue SyntaxError => exception
+      # rubocop:disable Style/GuardClause
+      if VOID_VALUE_REGEXP.match?(exception.message)
+        Result::VoidValue.instance
+      else
+        raise
+      end
+    else
+      Result::Success.instance
     end
   end # Loader
 end # Mutant

data/lib/mutant/matcher.rb

@@ -7,11 +7,58 @@ module Mutant
 
     # Call matcher
     #
-    # @param [Env::Bootstrap] env
+    # @param [Env] env
     #
     # @return [Enumerable<Subject>]
     #
     abstract_method :call
 
+    # Turn config into matcher
+    #
+    # @param [Config] config
+    #
+    # @return [Matcher]
+    def self.from_config(config)
+      Filter.new(
+        Chain.new(config.match_expressions.map(&:matcher)),
+        method(:allowed_subject?).curry.call(config)
+      )
+    end
+
+    # Test if subject is allowed do
+    #
+    # @param [Config] config
+    # @param [Subject] subject
+    #
+    # @return [Boolean]
+    def self.allowed_subject?(config, subject)
+      select_subject?(config, subject) && !ignore_subject?(config, subject)
+    end
+    private_class_method :allowed_subject?
+
+    # Predicate that tests for selected subject
+    #
+    # @param [Config] config
+    # @param [Subject] subject
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def self.select_subject?(config, subject)
+      config.subject_filters.all? { |filter| filter.call(subject) }
+    end
+    private_class_method :select_subject?
+
+    # Predicate that tests for ignored subject
+    #
+    # @param [Config] config
+    # @param [Subject] subject
+    #
+    # @return [Boolean]
+    def self.ignore_subject?(config, subject)
+      config.ignore_expressions.any? do |expression|
+        expression.prefix?(subject.expression)
+      end
+    end
   end # Matcher
 end # Mutant

data/lib/mutant/matcher/chain.rb

@@ -8,7 +8,7 @@ module Mutant
 
       # Call matcher
       #
-      # @param [Env::Bootstrap] env
+      # @param [Env] env
       #
       # @return [Enumerable<Subject>]
       def call(env)

data/lib/mutant/matcher/config.rb

@@ -3,8 +3,6 @@
 module Mutant
   class Matcher
     # Subject matcher configuration
-    #
-    # :reek:TooManyConstants
     class Config
       include Adamantium, Anima.new(
         :ignore_expressions,

data/lib/mutant/matcher/filter.rb

@@ -8,7 +8,7 @@ module Mutant
 
       # Enumerate matches
       #
-      # @param [Env::Bootstrap] env
+      # @param [Env] env
       #
       # @return [Enumerable<Subject>]
       def call(env)

data/lib/mutant/matcher/method.rb

@@ -8,9 +8,8 @@ module Mutant
               Adamantium::Flat,
               Concord::Public.new(:scope, :target_method, :evaluator)
 
-      # Methods within rbx kernel directory are precompiled and their source
-      # cannot be accessed via reading source location. Same for methods created by eval.
-      BLACKLIST = %r{\A(kernel/|\(eval\)\z)}.freeze
+      # Source locations we cannot acces
+      BLACKLIST = %w[(eval) <internal:prelude>].to_set.freeze
 
       SOURCE_LOCATION_WARNING_FORMAT =
         '%s does not have a valid source location, unable to emit subject'
@@ -20,7 +19,7 @@ module Mutant
 
       # Matched subjects
       #
-      # @param [Env::Bootstrap] env
+      # @param [Env] env
       #
       # @return [Enumerable<Subject>]
       def call(env)
@@ -55,7 +54,7 @@ module Mutant
         # @return [Truthy]
         def skip?
           location = source_location
-          if location.nil? || BLACKLIST.match(location.first)
+          if location.nil? || BLACKLIST.include?(location.first)
             env.warn(SOURCE_LOCATION_WARNING_FORMAT % target_method)
           elsif matched_node_path.any?(&method(:n_block?))
             env.warn(CLOSURE_WARNING_FORMAT % target_method)
@@ -87,7 +86,7 @@ module Mutant
         #
         # @return [Pathname]
         def source_path
-          env.config.pathname.new(source_location.first)
+          env.world.pathname.new(source_location.first)
         end
         memoize :source_path
 
@@ -114,7 +113,12 @@ module Mutant
         #   otherwise
         def subject
           node = matched_node_path.last || return
-          self.class::SUBJECT_CLASS.new(context, node)
+
+          self.class::SUBJECT_CLASS.new(
+            context:  context,
+            node:     node,
+            warnings: env.world.warnings
+          )
         end
         memoize :subject
 

data/lib/mutant/matcher/methods.rb

@@ -16,7 +16,7 @@ module Mutant
 
       # Enumerate subjects
       #
-      # @param [Env::Bootstrap] env
+      # @param [Env] env
       #
       # @return [Enumerable<Subject>]
       def call(env)

data/lib/mutant/matcher/namespace.rb

@@ -8,7 +8,7 @@ module Mutant
 
       # Enumerate subjects
       #
-      # @param [Env::Bootstrap] env
+      # @param [Env] env
       #
       # @return [Enumerable<Subject>]
       def call(env)

data/lib/mutant/matcher/null.rb

@@ -8,7 +8,7 @@ module Mutant
 
       # Enumerate subjects
       #
-      # @param [Env::Bootstrap] env
+      # @param [Env] env
       #
       # @return [Enumerable<Subject>]
       def call(_env)