henitai 0.5.3 → 0.6.0

data/lib/henitai/integration.rb

@@ -6,12 +6,15 @@ require_relative "process_wakeup"
 require_relative "integration/child_bootstrap"
 require_relative "integration/rspec_process_runner"
 require_relative "integration/scenario_log_support"
+require_relative "integration/child_report_store"
 require_relative "integration/coverage_suppression"
 require_relative "integration/child_debug_log"
 require_relative "integration/loaded_features"
 require_relative "integration/base"
 require_relative "integration/mutant_run_support"
 require_relative "integration/rspec_child_runner"
+require_relative "rspec_outcomes"
+require_relative "integration/rspec_preload"
 require_relative "integration/rspec_test_selection"
 
 module Henitai
@@ -50,6 +53,7 @@ module Henitai
     class Rspec < Base
       include MutantRunSupport
       include RspecChildRunner
+      include RspecPreload
       include RspecTestSelection
 
       DEFAULT_SUITE_TIMEOUT = 300.0
@@ -98,7 +102,7 @@ module Henitai
         File.open(log_paths[:stdout_path], "w") do |stdout_file|
           File.open(log_paths[:stderr_path], "w") do |stderr_file|
             Process.spawn(
-              subprocess_env,
+              suite_process_env,
               *suite_command(test_files),
               out: stdout_file,
               err: stderr_file,
@@ -110,14 +114,23 @@ module Henitai
 
       private
 
-      def run_tests(test_files)
+      def outcome_recording_hook(outcomes, after_load)
+        lambda do
+          RspecOutcomes.register(outcomes, ::RSpec.__send__(:configuration).reporter)
+          after_load.nil? || after_load.call
+        end
+      end
+
+      # Yields once the spec files are loaded and before they run; a falsy
+      # block result skips the run (see MutantRunSupport#run_tests_in_child).
+      def run_tests(test_files, outcomes, &after_load)
         require "rspec/core"
         ::RSpec.__send__(:configuration).fail_if_no_examples = true
         log = child_debug_log
         log.rspec_trace(test_files:, rspec_options: [], rspec_argv: test_files)
         log.example_count("before_run")
         log.write("[henitai-debug-child] runner_run_start")
-        status = run_rspec_runner(test_files)
+        status = run_rspec_runner(test_files, &outcome_recording_hook(outcomes, after_load))
         log.write("[henitai-debug-child] runner_run_return status=#{status.inspect}")
         log.example_count("after_run")
         log.rspec_exit(status)

data/lib/henitai/minitest_coverage_reporter.rb

@@ -2,6 +2,8 @@
 
 require "minitest"
 require "henitai/per_test_coverage_collector"
+require "henitai/test_file_outcomes"
+require "henitai/minitest_result_file"
 
 module Henitai
   # Minitest reporter that collects per-test line coverage deltas.
@@ -11,26 +13,40 @@ module Henitai
   # to PerTestCoverageCollector so the JSON output format is identical to the
   # RSpec integration.
   class MinitestCoverageReporter < Minitest::Reporter
-    def initialize(io = $stdout, options = {})
+    def initialize(io = $stdout, options = {}, boot_clock: SuiteBootClock.from_env(ENV))
+      super(io, options)
+      @collector = PerTestCoverageCollector.new(boot_clock:)
+      @outcomes = TestFileOutcomes.new
+    end
+
+    def prerecord(klass, name)
       super
-      @collector = PerTestCoverageCollector.new
+      @collector.test_started
     end
 
     def record(result)
       super
-      @collector.record_test(
-        relative_to_pwd(result.source_location.first),
-        duration: result.time
-      )
+      record_coverage(result)
+      MinitestResultFile.record(@outcomes, result)
     end
 
     def report
       super
       @collector.write_report
+      @outcomes.write(TestFileOutcomes.default_report_path)
     end
 
     private
 
+    # A result without a resolvable file is skipped, so its coverage delta is
+    # not attributed to the next recorded test.
+    def record_coverage(result)
+      file = MinitestResultFile.for(result)
+      return @collector.skip_test unless file
+
+      @collector.record_test(relative_to_pwd(file), duration: result.time)
+    end
+
     def relative_to_pwd(path)
       prefix = "#{Dir.pwd}#{File::SEPARATOR}"
       path.start_with?(prefix) ? path.sub(prefix, "") : path

data/lib/henitai/minitest_result_file.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Finds the test file a Minitest result belongs to.
+  #
+  # `Result#source_location` is where the test method is defined. For tests
+  # inherited from a base class or an included module that is a shared file,
+  # not the file of the test class that ran, so the file that defines the
+  # result's class is used for those. A method defined directly on the class
+  # keeps its own file: the class may have been reopened in another test file.
+  # The method location is also the fallback for classes that cannot be
+  # resolved (anonymous or removed).
+  module MinitestResultFile
+    module_function
+
+    # Records the result's outcome; a failure with no usable file is
+    # recorded as unattributed rather than dropped.
+    def record(outcomes, result)
+      failed = !result.passed? && !result.skipped?
+      file = self.for(result)
+      if file
+        outcomes.record(file, failed:)
+      elsif failed
+        outcomes.record_unattributed_failure
+      end
+    end
+
+    # @return [String, nil] the test file, or nil when none can be found
+    def for(result)
+      return usable(method_file(result)) || usable(class_file(result)) if defined_on_class?(result)
+
+      usable(class_file(result)) || usable(method_file(result))
+    end
+
+    def defined_on_class?(result)
+      klass = Object.const_get(result.klass.to_s)
+      klass.instance_method(result.name).owner == klass
+    rescue NameError
+      false
+    end
+
+    def class_file(result)
+      class_file_of(result.klass.to_s)
+    end
+
+    # The file that defines the named class; nil for anonymous or unknown names.
+    def class_file_of(name)
+      usable(Object.const_source_location(name)&.first)
+    rescue NameError
+      nil
+    end
+
+    def method_file(result)
+      result.source_location&.first
+    end
+
+    # Minitest reports no location for some results and "unknown" for others.
+    def usable(file)
+      file if file.is_a?(String) && !file.empty? && file != "unknown" && file != "(eval)"
+    end
+  end
+end

data/lib/henitai/mutant/activation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Henitai
+  class Mutant
+    # The Ruby source that puts a mutant in place, and how to evaluate it.
+    #
+    # +mode+ is :toplevel for a real +def+ re-evaluated inside the original
+    # module and class openers (ADR-13), evaluated at the top level with
+    # +file+ and +line+ so +__FILE__+, +__LINE__+ and backtraces stay those of
+    # the original source; +def_offset+ is the index of the +def+ line within
+    # +source+. +mode+ is :class_eval for the +define_method+ fallback,
+    # evaluated inside the target module.
+    #
+    # For :toplevel, +lexical_scope+ holds the opener lines (e.g. "module A",
+    # "class B"), +owner+ the expression the +def+ is defined on ("self" or
+    # the receiver of +def Other.name+), and +singleton+ whether it is a
+    # +defs+. They let a replayed recipe reopen the scope without the AST.
+    Activation = Struct.new(:source, :mode, :file, :line, :def_offset, :lexical_scope, :owner, :singleton,
+                            keyword_init: true) do
+      def self.from_h(hash)
+        new(source: hash.fetch("source"), mode: hash.fetch("mode").to_sym, file: hash["file"],
+            line: hash["line"], def_offset: hash["defOffset"], lexical_scope: hash["lexicalScope"],
+            owner: hash["owner"], singleton: hash["singleton"])
+      end
+
+      def to_h
+        { "source" => source, "mode" => mode.to_s, "file" => file, "line" => line, "defOffset" => def_offset,
+          "lexicalScope" => lexical_scope, "owner" => owner, "singleton" => singleton }
+      end
+    end
+  end
+end

data/lib/henitai/mutant/activator.rb

@@ -7,10 +7,16 @@ module Henitai
   class Mutant
     # Activates a mutant inside the forked child process.
     class Activator
+      SubjectNotLoadedError = LexicalTarget::SubjectNotLoadedError
+
+      # File name the activation source is evaluated under. It decides what
+      # +__FILE__+ and +__LINE__+ mean inside an activated mutant.
+      EVAL_FILE = __FILE__
+
       # Filters "already initialized constant" C-level warnings that fire when
       # a source file is loaded into a process that already has the constant
       # defined via require. Uses a thread-local flag so the filter is active
-      # only during load_source_file, leaving all other warnings untouched.
+      # only during LexicalTarget#load_source_file, leaving all other warnings untouched.
       module ConstantRedefinitionFilter
         PATTERN = /already initialized constant|previous definition of/
         private_constant :PATTERN
@@ -27,23 +33,34 @@ module Henitai
         new.activate!(mutant)
       end
 
-      # Returns the +define_method+ source string for +mutant+ without
-      # actually evaluating it. Used to pre-compute activation recipes.
-      # Returns nil if the source cannot be computed (e.g. unsupported AST node).
-      def self.activation_source_for(mutant)
-        new.send(:method_source, mutant)
+      # Returns the Activation for +mutant+ without evaluating it: a real
+      # +def+ in the original lexical scope when the subject can be reopened
+      # (ADR-13), otherwise the +define_method+ fallback. Used by the fidelity
+      # check and to pre-compute activation recipes. Returns nil if the source
+      # cannot be computed (e.g. unsupported AST node).
+      def self.activation_for(mutant)
+        new.activation_for(mutant)
       rescue StandardError
         nil
       end
 
+      def self.activation_source_for(mutant)
+        activation_for(mutant)&.source
+      end
+
+      def activation_for(mutant)
+        DefInjection.build(mutant, def_replacement(mutant)) ||
+          Activation.new(source: method_source(mutant), mode: :class_eval, file: EVAL_FILE)
+      end
+
       def activate!(mutant)
         subject = mutant.subject
         raise ArgumentError, "Cannot activate wildcard subjects" if subject.method_name.nil?
 
-        source = mutant.precomputed_activation_source || method_source(mutant)
-        target = target_for(subject)
+        activation = mutant.precomputed_activation || activation_for(mutant)
+        target = activation.mode == :toplevel ? LexicalTarget.resolve(subject, activation) : target_for(subject)
         Henitai::WarningSilencer.silence do
-          target.class_eval(source, __FILE__, __LINE__ + 1)
+          evaluate(activation, target, subject)
           nil
         end
       rescue Unparser::UnsupportedNodeError, SyntaxError
@@ -52,8 +69,44 @@ module Henitai
 
       private
 
+      def evaluate(activation, target, subject)
+        return inject_def(activation, target, subject) if activation.mode == :toplevel
+
+        target.class_eval(activation.source, EVAL_FILE, __LINE__)
+      end
+
+      # A re-evaluated +def+ is public, so the method's visibility -- or its
+      # +module_function+ copy -- is read before and restored after. +target+
+      # is already the singleton class for a class method.
+      def inject_def(activation, target, subject)
+        name = subject.method_name.to_sym
+        visibility = visibility_of(target, name)
+        copy = module_function_copy?(target, name, subject)
+        TOPLEVEL_BINDING.eval(activation.source, activation.file, activation.line)
+        return target.send(:module_function, name) if copy
+
+        target.send(visibility, name) if visibility
+      end
+
+      def visibility_of(owner, name)
+        return :private if owner.private_method_defined?(name)
+
+        :protected if owner.protected_method_defined?(name)
+      end
+
+      def module_function_copy?(target, name, subject)
+        subject.method_type == :instance && !target.is_a?(Class) &&
+          target.private_method_defined?(name) && target.singleton_class.method_defined?(name) &&
+          target.instance_method(name).source_location == target.method(name).source_location
+      end
+
+      def def_replacement(mutant)
+        original_range = mutant.original_node&.location&.expression
+        replacement_source(mutant, original_range) if original_range
+      end
+
       def target_for(subject)
-        target = load_target(subject)
+        target = LexicalTarget.load_target(subject)
         subject.method_type == :class ? target.singleton_class : target
       end
 
@@ -73,7 +126,8 @@ module Henitai
         <<~RUBY
           __henitai_module_function__ = !is_a?(Class) &&
             private_method_defined?(:#{method_name}) &&
-            singleton_class.method_defined?(:#{method_name})
+            singleton_class.method_defined?(:#{method_name}) &&
+            instance_method(:#{method_name}).source_location == method(:#{method_name}).source_location
           define_method(:#{method_name}) do |#{parameters}|
             #{replacement}
           end
@@ -96,8 +150,13 @@ module Henitai
         location = body.location
         return source_body(location, body) unless original_range && location
 
-        replacement = compile_safe_unparse(mutant.mutated_node)
-        body_source_for_location(location, original_range, replacement, body)
+        body_source_for_location(location, original_range, replacement_source(mutant, original_range), body)
+      end
+
+      # An unmutated control keeps the original text: re-rendering it would
+      # test the unparser, not the activation path.
+      def replacement_source(mutant, original_range)
+        Replacement.render(mutant, original_range)
       end
 
       def body_source_for_location(location, original_range, replacement, body)
@@ -157,55 +216,16 @@ module Henitai
       end
 
       def expression_source(location, original_range, replacement)
-        source_range = location.expression
-        return unless source_range
-
-        replace_source_fragment(source_range, original_range, replacement)
-      end
-
-      def load_target(subject)
-        Object.const_get(subject.namespace.delete_prefix("::"))
-      rescue NameError
-        load_source_file(subject)
-        Object.const_get(subject.namespace.delete_prefix("::"))
-      end
-
-      def load_source_file(subject)
-        source_file = subject.source_file || source_file_from_ast(subject)
-        return unless source_file && File.file?(source_file)
-
-        Thread.current[:henitai_filter_const_warnings] = true
-        load(source_file)
-        loaded_feature = File.expand_path(source_file)
-        $LOADED_FEATURES << loaded_feature unless $LOADED_FEATURES.include?(loaded_feature)
-      ensure
-        Thread.current[:henitai_filter_const_warnings] = false
-      end
-
-      def source_file_from_ast(subject)
-        ast_node = subject.ast_node
-        return unless ast_node
-
-        location = ast_node.location
-        return unless location
-
-        expression = location.expression
-        return unless expression
-
-        expression.source_buffer.name
+        replace_source_fragment(location.expression, original_range, replacement)
       end
 
       def replace_source_fragment(source_range, original_range, replacement)
         source = source_range.source
         start = original_range.begin_pos - source_range.begin_pos
         stop = original_range.end_pos - source_range.begin_pos
-        return unless start >= 0 && stop <= source.bytesize && start <= stop
-
-        prefix = source.byteslice(0, start)
-        suffix = source.byteslice(stop, source.bytesize - stop)
-        return unless prefix && suffix
+        return unless start >= 0 && stop <= source.length && start <= stop
 
-        prefix + replacement + suffix
+        source[0, start] + replacement + source[stop..]
       end
 
       def compile_safe_unparse(node)

data/lib/henitai/mutant/def_injection.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Henitai
+  class Mutant
+    # Builds the :toplevel activation for a mutant (ADR-13): the subject's
+    # own +def+, with the mutation spliced in, wrapped in the module and class
+    # openers that surround it in the source.
+    #
+    # Re-evaluating a real +def+ in its lexical scope keeps everything a
+    # +define_method+ block loses: constant lookup through the enclosing
+    # modules, implicit +super+, +yield+ and +block_given?+, the exact
+    # parameter list, +__FILE__+ and +__LINE__+, and the file's
+    # +frozen_string_literal+ comment. Visibility is restored by the Activator.
+    #
+    # Returns nil when the subject cannot be reopened this way (a
+    # +define_method+ subject, a method in +class << obj+, a subject without
+    # recorded scope); the Activator then falls back to +define_method+.
+    class DefInjection
+      # Matches +# key: value+ and the emacs form +# -*- key: value -*-+ only,
+      # so prose that merely mentions a magic comment does not match.
+      MAGIC_COMMENT = /
+        \A\#\s*(?:-\*-(?:[^;:]*:[^;]*;)*\s*)?
+        (?:frozen_string_literal|shareable_constant_value|warn_indent)\s*:
+      /ix
+
+      def self.build(mutant, replacement)
+        new.build(mutant, replacement)
+      end
+
+      def build(mutant, replacement)
+        subject = mutant.subject
+        node = subject.ast_node
+        scope = subject.lexical_scope
+        return unless injectable?(node, scope)
+
+        def_source = spliced_def(node.location.expression, mutant.original_node, replacement)
+        return unless def_source
+
+        assemble(node, scope, def_source)
+      end
+
+      private
+
+      # A top-level +def Other.name+ has no openers; an instance method needs
+      # at least one, or it would land on Object.
+      def injectable?(node, scope)
+        return false unless node && scope
+
+        node.type == :defs || (node.type == :def && !scope.empty?)
+      end
+
+      # Splices by character offsets, as parser ranges count characters. A
+      # heredoc's expression range covers only its opener, so the bodies of
+      # heredocs inside the replaced node are removed as well; otherwise they
+      # would stay behind as code.
+      def spliced_def(def_range, original_node, replacement)
+        original_range = original_node&.location&.expression
+        return unless original_range && within?(original_range, def_range)
+        # An unmutated control splices the original text back. Its heredoc
+        # bodies must stay, so the def is used verbatim.
+        return def_range.source if replacement == original_range.source
+
+        edits = heredoc_bodies(original_node).map { |range| [range, ""] } << [original_range, replacement]
+        apply(def_range, edits)
+      end
+
+      # Applies non-overlapping edits from the last to the first, so earlier
+      # offsets stay valid.
+      def apply(def_range, edits)
+        edits.sort_by { |range, _| -range.begin_pos }.each_with_object(def_range.source.dup) do |(range, insert), text|
+          start = range.begin_pos - def_range.begin_pos
+          text[start...(range.end_pos - def_range.begin_pos)] = insert
+        end
+      end
+
+      def heredoc_bodies(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+
+        own = node.location.respond_to?(:heredoc_body) && node.location.heredoc_body
+        bodies = own ? [own.join(node.location.heredoc_end)] : []
+        bodies + node.children.flat_map { |child| heredoc_bodies(child) }
+      end
+
+      def within?(inner, outer)
+        inner.begin_pos.between?(outer.begin_pos, inner.end_pos) && inner.end_pos <= outer.end_pos
+      end
+
+      def assemble(node, scope, def_source)
+        def_range = node.location.expression
+        prefix = prefix_lines(def_range)
+        Activation.new(source: source_lines(prefix, scope, def_source), mode: :toplevel,
+                       **location_fields(def_range, prefix), **owner_fields(node, scope))
+      end
+
+      # Only magic-comment header lines precede the def; the openers share
+      # its line, so the def keeps its original line number.
+      def prefix_lines(def_range)
+        magic_comments(def_range.source_buffer.source)
+      end
+
+      def location_fields(def_range, prefix)
+        { file: File.expand_path(def_range.source_buffer.name),
+          line: [def_range.line - prefix.size, 1].max, def_offset: prefix.size }
+      end
+
+      def owner_fields(node, scope)
+        { lexical_scope: scope, owner: owner_source(node), singleton: node.type == :defs }
+      end
+
+      # The expression the +def+ is defined on, as the openers must evaluate
+      # it: +self+, or the receiver of +def Other.name+.
+      def owner_source(node)
+        node.type == :defs ? node.children.first.location.expression.source : "self"
+      end
+
+      # The expression starts at column 0, so its leading indent is dropped.
+      def source_lines(prefix, scope, def_source)
+        lines = prefix + [wrap_in_scope(def_source.lstrip, scope)]
+        "#{lines.join("\n")}\n"
+      end
+
+      # Openers and closers go on the def's own line; with an empty scope
+      # the def stands alone.
+      def wrap_in_scope(definition, scope)
+        return definition if scope.empty?
+
+        "#{scope.join('; ')}; #{definition}; #{Array.new(scope.size, 'end').join('; ')}"
+      end
+
+      def magic_comments(file_source)
+        header = file_source.each_line.take_while { |line| line.strip.empty? || line.start_with?("#") }
+        header.map(&:chomp).grep(MAGIC_COMMENT)
+      end
+    end
+  end
+end

data/lib/henitai/mutant/lexical_scope_check.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Henitai
+  class Mutant
+    # Decides whether the scope openers of an activation can be reopened.
+    #
+    # Evaluating an opener such as "class Inner" creates the class when it is
+    # missing, which would inject a mutant into an empty phantom class. This
+    # check walks the openers the way Ruby resolves them, but never evaluates
+    # them, so it never defines a constant.
+    class LexicalScopeCheck
+      CLASS_EVAL_SUFFIX = ".class_eval do"
+      SINGLETON_PREFIX = "class << "
+
+      # The lexical nesting (innermost first, ending with Object, mirroring
+      # Ruby's cref chain) and the current +self+, which a class_eval block
+      # changes without changing the nesting.
+      Scope = Data.define(:nesting, :receiver)
+
+      def self.resolves?(openers)
+        new.resolves?(openers)
+      end
+
+      def resolves?(openers)
+        scope = Scope.new(nesting: [Object], receiver: Object)
+        openers.all? { |opener| scope = next_scope(opener, scope) }
+      end
+
+      private
+
+      def next_scope(opener, scope)
+        return singleton_scope(opener, scope) if opener.start_with?(SINGLETON_PREFIX)
+        return class_eval_scope(opener, scope) if opener.end_with?(CLASS_EVAL_SUFFIX)
+
+        target = opener_target(opener, scope)
+        target && Scope.new(nesting: [target, *scope.nesting], receiver: target)
+      end
+
+      # A singleton opener cannot create a constant, but its receiver must
+      # resolve; its singleton class becomes both the cref and +self+.
+      def singleton_scope(opener, scope)
+        found, value = resolve_expression(opener.delete_prefix(SINGLETON_PREFIX), scope)
+        return unless found
+
+        singleton = value.singleton_class
+        Scope.new(nesting: [singleton, *scope.nesting], receiver: singleton)
+      rescue TypeError
+        nil
+      end
+
+      # A block evaluated with class_eval keeps the enclosing constant lookup
+      # and only changes +self+ to its receiver.
+      def class_eval_scope(opener, scope)
+        found, value = resolve_expression(opener.delete_suffix(CLASS_EVAL_SUFFIX), scope)
+        found && value.is_a?(Module) && scope.with(receiver: value)
+      end
+
+      def opener_target(opener, scope)
+        kind, path = opener.split(" ", 2)
+        segments = path.delete_prefix("::").split("::")
+        parent = path.start_with?("::") ? walk(Object, segments[0...-1]) : parent_of(segments[0...-1], scope)
+        value = parent.is_a?(Module) && constant_value(parent, segments.last)
+        value if matches_kind?(value, kind)
+      end
+
+      # Resolves a constant expression such as +Point+, +self::Inner+ or
+      # +::Outer::Point+. Returns whether it resolved and its value.
+      def resolve_expression(path, scope)
+        return [true, scope.receiver] if path == "self"
+
+        value = path.match?(/\A\w+\z/) ? lexical_lookup(path, scope.nesting) : qualified_value(path, scope)
+        [!value.nil?, value]
+      end
+
+      def qualified_value(path, scope)
+        segments = path.delete_prefix("::").split("::")
+        base = path.start_with?("::") ? Object : parent_of(segments.first(1), scope)
+        walk(base, segments.drop(path.start_with?("::") ? 0 : 1))
+      end
+
+      # A leading +self+ (as in +class self::Inner+) is the current receiver.
+      def parent_of(segments, scope)
+        return scope.nesting.first if segments.empty?
+
+        first = segments.first == "self" ? scope.receiver : lexical_lookup(segments.first, scope.nesting)
+        walk(first, segments.drop(1))
+      end
+
+      def walk(base, segments)
+        segments.reduce(base) { |current, name| current.is_a?(Module) ? own_constant(current, name) : nil }
+      end
+
+      # Ruby's order: the own constants of each lexical scope (innermost
+      # first, without Object), then the ancestors of the innermost scope,
+      # then the top level.
+      def lexical_lookup(name, nesting)
+        scope = nesting[0...-1].find { |candidate| candidate.const_defined?(name, false) }
+        return scope.const_get(name, false) if scope
+
+        innermost = nesting.first
+        innermost.const_get(name) if innermost.const_defined?(name) || Object.const_defined?(name)
+      end
+
+      def own_constant(base, name)
+        base.const_get(name, false) if base.const_defined?(name, false)
+      end
+
+      def constant_value(parent, name)
+        inherit = parent.equal?(Object)
+        parent.const_get(name, inherit) if parent.const_defined?(name, inherit)
+      end
+
+      def matches_kind?(value, kind)
+        return false unless value.is_a?(Module)
+
+        kind == "class" ? value.is_a?(Class) : !value.is_a?(Class)
+      end
+    end
+  end
+end