path_coverage 0.1.0 → 0.2.0

data/lib/path_coverage/recorder.rb

@@ -1,8 +1,17 @@
 require_relative 'condition'
+require_relative 'recorder_blocks'
+require_relative 'recorder_cases'
+require_relative 'recorder_chains'
+require_relative 'recorder_writes'
 
 module PathCoverage
   # Records the outcome of each instrumented operand.
   class Recorder
+    include RecorderBlocks
+    include RecorderCases
+    include RecorderChains
+    include RecorderWrites
+
     # One call's way through its method: the outcome of each
     # decision made so far, of the number of decisions its
     # method has.
@@ -129,54 +138,5 @@ module PathCoverage
       leave(trails(site).last, matched) if last
       matched
     end
-
-    # Starts an evaluation of a stop-early block method's call
-    # at site, its block not yet called with any item.
-    def enter_items(site)
-      trail = enter(site, 2)
-      trail.outcomes[0] = ITEMS[0]
-      trail
-    end
-
-    # Notes value, the block's answer, as its last, and one more
-    # item it was called with; returns value unchanged. A block
-    # called where its call was not entered, eg in another
-    # fiber, is counted but noted on no path.
-    def item(site, value)
-      trail = trails(site).last
-      one_more(trail) if trail
-      record(site, 1, value)
-    end
-
-    # Notes value, the block's answer for one more item, among
-    # all its answers so far: all true, all false, or both;
-    # returns value unchanged. A block called where its call
-    # was not entered is counted but noted on no path.
-    def answer(site, value)
-      trail = trails(site).last
-      if trail
-        one_more(trail)
-        now = value ? ANSWERS[0] : ANSWERS[1]
-        same = [nil, now].include?(trail.outcomes[1])
-        trail.outcomes[1] = same ? now : ANSWERS[2]
-      end
-      @counts[[site, 1]][value ? :truthy : :falsy] += 1
-      value
-    end
-
-    # Notes on trail one more item its block was called with.
-    def one_more(trail)
-      called = ITEMS.index(trail.outcomes[0]) + 1
-      trail.outcomes[0] = ITEMS[[called, 2].min]
-    end
-
-    # Ends a block method's call, counting its receiver truthy
-    # when its block was called, falsy when not, and its path;
-    # returns value, the call's, unchanged.
-    def leave_items(trail, value)
-      called = trail.outcomes[0] != ITEMS[0]
-      @counts[[trail.site, 0]][called ? :truthy : :falsy] += 1
-      leave(trail, value)
-    end
   end
 end

data/lib/path_coverage/recorder_blocks.rb

@@ -0,0 +1,68 @@
+require_relative 'condition'
+
+module PathCoverage
+  # The part of the recorder that notes block method calls, eg
+  # ids.any? { |id| id.odd? }: how many items the block was called
+  # with, as the receiver's leaf, at, and its answers, as the next
+  # leaf; at is 0 for a call that is a site of its own. It relies
+  # on its includer's counts, record and trails.
+  module RecorderBlocks
+    # Starts a block method's call in site, its receiver the
+    # site's at-th leaf, its block not yet called with any item;
+    # returns the site's current trail, nil for none.
+    def begin_items(site, at)
+      trail = trails(site).last
+      trail.outcomes[at] = ITEMS[0] if trail
+      trail
+    end
+
+    # Notes value, the block's answer, as its last, and one more
+    # item it was called with, for a call whose receiver is
+    # site's at-th leaf; returns value unchanged. A block called
+    # where its call was not entered, eg in another fiber, is
+    # counted but noted on no path.
+    def item_at(site, at, value)
+      trail = trails(site).last
+      one_more(trail, at) if trail
+      record(site, at + 1, value)
+    end
+
+    # Notes value, the block's answer for one more item, among
+    # all its answers so far: all true, all false, or both, for a
+    # call whose receiver is site's at-th leaf; returns value
+    # unchanged. A block called where its call was not entered
+    # is counted but noted on no path.
+    def answer_at(site, at, value)
+      trail = trails(site).last
+      note_answer(trail, at, value) if trail
+      @counts[[site, at + 1]][value ? :truthy : :falsy] += 1
+      value
+    end
+
+    # Notes on trail one more item, and value among the answers
+    # so far of the block whose receiver is its at-th leaf.
+    def note_answer(trail, at, value)
+      one_more(trail, at)
+      now = value ? ANSWERS[0] : ANSWERS[1]
+      same = [nil, now].include?(trail.outcomes[at + 1])
+      trail.outcomes[at + 1] = same ? now : ANSWERS[2]
+    end
+
+    # Notes on trail one more item the block whose receiver is its
+    # at-th leaf was called with.
+    def one_more(trail, at)
+      called = ITEMS.index(trail.outcomes[at]) + 1
+      trail.outcomes[at] = ITEMS[[called, 2].min]
+    end
+
+    # Ends a block method's call whose receiver is site's at-th
+    # leaf, counting the receiver truthy when its block was
+    # called, falsy when not; returns value unchanged. With no
+    # trail, as begin_items found none, it is counted as called.
+    def end_items(site, at, trail, value)
+      called = trail.nil? || trail.outcomes[at] != ITEMS[0]
+      @counts[[site, at]][called ? :truthy : :falsy] += 1
+      value
+    end
+  end
+end

data/lib/path_coverage/recorder_cases.rb

@@ -0,0 +1,23 @@
+module PathCoverage
+  # The part of the recorder that notes a case nested in another
+  # site, eg (case a when 1 then b end) && c: the site around it
+  # enters and leaves, so its patterns only note whether they
+  # matched. It relies on its includer's record.
+  module RecorderCases
+    # A stand-in for the pattern of a case nested in site, its
+    # match noted as the site's index-th leaf.
+    NestedMatch = Struct.new(:recorder, :site, :index, :pattern) do
+      # Whether pattern matches subject, exactly as pattern says,
+      # noted on the site's path.
+      def ===(subject)
+        recorder.record(site, index, pattern === subject)
+      end
+    end
+
+    # The stand-in for pattern, the index-th leaf of site, in a
+    # case nested in it.
+    def pattern(site, index, pattern)
+      NestedMatch.new(self, site, index, pattern)
+    end
+  end
+end

data/lib/path_coverage/recorder_chains.rb

@@ -0,0 +1,40 @@
+require_relative 'condition'
+
+module PathCoverage
+  # The part of the recorder that notes &. chains. It relies on
+  # its includer's counts, record and trails.
+  module RecorderChains
+    # Notes value, the index-th leaf of site, a &. receiver, as
+    # not nil or nil, and returns it unchanged; it counts truthy
+    # when not nil. A receiver after a nil one in its chain,
+    # whose leaves start at first, was never reached, as Ruby
+    # skips the rest of the chain, so is not noted.
+    def present(site, index, first, value)
+      return value unless reached?(site, first, index)
+
+      @counts[[site, index]][value.nil? ? :falsy : :truthy] += 1
+      trail = trails(site).last
+      trail.outcomes[index] = PRESENCE[value.nil? ? 1 : 0] if trail
+      value
+    end
+
+    # Notes value, a &. chain's value as the index-th leaf of
+    # site, as record does, when every receiver of the chain,
+    # whose leaves start at first, was not nil; returns value
+    # unchanged.
+    def chained(site, index, first, value)
+      return value unless reached?(site, first, index)
+
+      record(site, index, value)
+    end
+
+    # True when site's current evaluation reached its index-th
+    # leaf: every leaf of its chain before it, from first, was
+    # not nil. An evaluation with no trail, eg in another fiber,
+    # is taken to reach it.
+    def reached?(site, first, index)
+      trail = trails(site).last
+      trail.nil? || trail.outcomes[first...index].all?(PRESENCE[0])
+    end
+  end
+end

data/lib/path_coverage/recorder_writes.rb

@@ -0,0 +1,26 @@
+module PathCoverage
+  # The part of the recorder that notes ||= and &&= writes: the
+  # target's outcome at its place among its site's leaves, at 0
+  # for a write that is a site of its own. It relies on its
+  # includer's record and trails.
+  module RecorderWrites
+    # Notes outcome as the target's, site's at-th leaf, of the
+    # write whose right side ran, false for ||=, true for &&=,
+    # and returns value, the right side's, unchanged. The target
+    # is never read, as reading it could call a method twice.
+    def written_at(site, at, outcome, value)
+      record(site, at, outcome)
+      value
+    end
+
+    # Notes skipped as the outcome of the write's target, site's
+    # at-th leaf, when its right side never ran, so noted none;
+    # returns value, the write's, unchanged.
+    def settle(site, at, skipped, value)
+      trail = trails(site).last
+      unnoted = trail.nil? || trail.outcomes[at].nil?
+      record(site, at, skipped) if unnoted
+      value
+    end
+  end
+end

data/lib/path_coverage/render.rb

@@ -1,8 +1,8 @@
-require 'json'
+require_relative 'console_summary'
 require_relative 'gaps'
 require_relative 'html_report'
+require_relative 'json_reader'
 require_relative 'manifest'
-require_relative 'merge'
 require_relative 'paths_report'
 require_relative 'post'
 require_relative 'site_paths'
@@ -11,20 +11,55 @@ module PathCoverage
   # The reporters, run from operands alone: needing nothing the
   # run recorded beyond them, they can run in another process.
   module Render
-    # Runs each reporter chosen in config. operands and
-    # site_paths are as Result gives them; files is { full path
-    # => {source:, sites:} } for each covered file.
-    def self.run(operands, files, config, paths = nil, site_paths: {})
-      site_paths = every_site(site_paths, files)
+    # Runs each reporter chosen in config. operands, and taken's
+    # site_paths: and outside:, are as Result gives them; files
+    # is { full path => {source:, sites:} } for each covered file.
+    def self.run(operands, files, config, paths = nil, **taken)
+      site_paths = every_site(taken.fetch(:site_paths, {}), files)
       reporters = config.reporters
-      gaps(operands, files, site_paths) if reporters.include?(:gaps)
-      if reporters.include?(:html)
-        HtmlReport.write(operands, files, config, paths, site_paths:)
+      if reporters.include?(:gaps)
+        gaps(operands, files, site_paths, taken.fetch(:outside, {}))
       end
+      html_and_summary(operands, files, config, [paths, site_paths])
       return unless reporters.include?(:post)
 
+      post(operands, files, config, site_paths)
+    end
+
+    # Runs the :post reporter: operands, and the paths report of
+    # site_paths in files, with config's fingerprint.
+    def self.post(operands, files, config, site_paths)
       report = PathsReport.of(site_paths, files)
-      Post.deliver(operands, config.collector_url, report)
+      url = config.collector_url
+      fingerprint = config.fingerprint
+      Post.deliver(operands, url, report, fingerprint:)
+    end
+
+    # Runs the :html and :summary reporters, each when chosen.
+    def self.html_and_summary(operands, files, config, paths_pair)
+      paths, site_paths = paths_pair
+      reporters = config.reporters
+      if reporters.include?(:html)
+        HtmlReport.write(operands, files, config, paths, site_paths:)
+      end
+      return unless reporters.include?(:summary)
+
+      summary(files, config, paths, site_paths)
+    end
+
+    # Prints the summary lines: the paths taken of all possible
+    # within decisions, and, when paths are given, as they are
+    # when methods are measured, within methods; then any
+    # operators ignored.
+    def self.summary(files, config, paths, site_paths)
+      methods = files.map do |full_path, parsed|
+        path = config.relative(full_path)
+        PathManifest.methods(parsed[:source], path)
+      end
+      all = methods.reduce({}, :merge)
+      groups = config.groups
+      puts ConsoleSummary.lines(site_paths, all, paths, groups) +
+           ConsoleSummary.ignored_lines(config.ignored)
     end
 
     # site_paths with every site in files that it lacks, eg
@@ -42,51 +77,28 @@ module PathCoverage
       none.merge(site_paths)
     end
 
-    # Prints the gap lines: each path a site never took, each
-    # leaf named by its text in files.
-    def self.gaps(operands, files, site_paths)
+    # Prints the gap lines: each path a site never took, and each
+    # path taken that a treatment rules out, as outside lists
+    # them, each leaf named by its text in files.
+    def self.gaps(operands, files, site_paths, outside)
       texts = PathsReport.texts(files)
-      lines = Gaps.lines(operands, paths: site_paths, texts:)
+      paths = site_paths
+      lines = Gaps.lines(operands, paths:, texts:, outside:)
       lines.each { |line| puts line }
     end
 
     # Runs the reporters chosen in config from the JSON reports
     # at paths, their counts merged, parsing each covered file
-    # afresh. paths is config.json_path alone by default.
+    # afresh; with methods measured, the method paths they hold
+    # too. paths is config.json_path alone by default.
     def self.from_json(config, paths = [config.json_path])
-      operands = Merge.operands(paths.map { |path| read(path) })
-      site_paths = Merge.paths(paths.map { |path| paths_of(path) })
+      operands = JsonReader.operands(paths, config.fingerprint)
       files = config.files.to_h do |path|
         [path, Manifest.parse(path, config)]
       end
-      run(operands, files, config, site_paths:)
-    end
-
-    # The site paths of the JSON report at path, as
-    # Result#paths gives them; none for a report that has none.
-    def self.paths_of(path)
-      json = JSON.parse(File.read(path))
-      json.fetch('paths', {}).transform_values do |site|
-        site['taken'].map do |each|
-          { path: each['path'], count: each['count'] }
-        end
-      end
-    end
-
-    # The operands of the JSON report at path.
-    def self.read(path)
-      json = JSON.parse(File.read(path))
-      json['sites'].transform_values do |leaves|
-        leaves.map { |leaf| counts(leaf) }
-      end
-    end
-
-    # One operand's counts as JSON holds them, with the keys,
-    # and any only: value, as the symbols Result#operands uses.
-    def self.counts(leaf)
-      counts = { truthy: leaf['truthy'], falsy: leaf['falsy'] }
-      only = leaf['only']
-      only ? counts.merge(only: only.to_sym) : counts
+      methods = config.measures.include?(:methods)
+      taken = methods ? JsonReader.method_paths(paths) : nil
+      run(operands, files, config, taken, **JsonReader.taken(paths))
     end
   end
 end

data/lib/path_coverage/result.rb

@@ -30,6 +30,25 @@ module PathCoverage
       end
     end
 
+    # { site => { path => evaluations } } of each path taken
+    # that is none of its site's possible paths, eg a &. receiver
+    # nil though treated as present; only sites with one. Such a
+    # path shows a treatment to be wrong, so it is reported, never
+    # dropped.
+    def outside
+      all = @sites.to_h do |site, condition|
+        taken = @site_paths.fetch(site, {})
+        [site, taken.except(*SitePaths.possible(condition))]
+      end
+      all.reject { |_, paths| paths.empty? }
+    end
+
+    # The paths taken, as Render.run takes them: site_paths:,
+    # as paths gives them, and outside:.
+    def taken
+      { site_paths: paths, outside: }
+    end
+
     # { site => [counts of operand 0, counts of operand 1, ...] },
     # with zero counts for an operand that never ran, and
     # only: naming the one outcome a fixed leaf can have.

data/lib/path_coverage/rewriter.rb

@@ -1,4 +1,6 @@
 require_relative 'condition'
+require_relative 'kinds'
+require_relative 'rewriter_nested'
 
 module PathCoverage
   # Instruments source text so that each leaf operand records its
@@ -20,56 +22,28 @@ module PathCoverage
       apply(source.dup, inserts + path_inserts(methods))
     end
 
-    # The inserts for one site, by its kind: a case's patterns'
-    # stand-ins, a block method's call and block, or any other
-    # site's leaves' records and its leave.
+    # The inserts for one site, as its kind gives them, eg its
+    # leaves' records and its leave; a block method's call or a
+    # write is noted as if nested at leaf 0.
     def self.site_inserts(site, condition)
-      kind = condition.operator
-      return case_inserts(site, condition) if kind == 'case'
-
-      blocks = BLOCK_PATHS.key?(kind)
-      return block_inserts(site, condition) if blocks
-
-      record_inserts(site, condition) + trail_inserts(site, condition)
-    end
-
-    # The inserts that wrap a block method's call whole in a
-    # leave_items call that enters it first, inside any leave of
-    # a site it is the predicate of, and its block's expression,
-    # outside any site's leave there, in an item call, noting its
-    # last answer, or for a method that calls it with every item
-    # an answer call, noting every answer.
-    def self.block_inserts(site, condition)
-      _receiver, body = condition.leaves
-      enter = "PathCoverage.enter_items(#{site.inspect})"
-      call = "PathCoverage.leave_items(#{enter}, "
-      every = EVERY_ITEM.include?(condition.operator)
-      noter = every ? 'answer' : 'item'
-      item = "PathCoverage.#{noter}(#{site.inspect}, "
-      command = condition.commands.include?(body)
-      wrap(call, condition.extent, false, 0.5) +
-        wrap(item, body, command, 1.5)
-    end
-
-    # The inserts that wrap each pattern of a case site in a
-    # when_match call, its stand-in, which enters and leaves the
-    # site itself, as the case tries its patterns one by one.
-    def self.case_inserts(site, condition)
-      size = condition.leaves.size
-      condition.leaves.each_with_index.flat_map do |range, index|
-        call = "PathCoverage.when_match(#{site.inspect}, " \
-               "#{index}, #{size}, "
-        wrap(call, range, false, 0)
-      end
+      Kinds.of(condition.operator).site_inserts(site, condition)
     end
 
     # The inserts that wrap each of site's leaves in a record
-    # call, innermost of all.
+    # call, innermost of all; a leaf of a nested site that needs
+    # a call of its own, eg a &. chain's, in the call
+    # RewriterNested gives it, or in none, and that site's own
+    # inserts too.
     def self.record_inserts(site, condition)
-      condition.leaves.each_with_index.flat_map do |range, index|
-        command = condition.commands.include?(range)
-        wrap(record_call(site, index), range, command, 0)
+      nested = RewriterNested.calls(site, condition)
+      leaves = condition.leaves
+      records = leaves.each_with_index.flat_map do |range, i|
+        call = nested.fetch(range) { record_call(site, i) }
+        next [] unless call
+
+        wrap(call, range, condition.commands.include?(range), :leaf)
       end
+      records + RewriterNested.inserts(site, condition)
     end
 
     WORD_OPERATORS = %w[and or].freeze
@@ -83,22 +57,10 @@ module PathCoverage
       enter = "PathCoverage.enter(#{site.inspect}, " \
               "#{condition.leaves.size})"
       call = "PathCoverage.leave(#{enter}, "
-      wrapped = trailed(condition)
+      wrapped = Kinds.of(condition.operator).trailed(condition)
       nested = wrapped.is_a?(Condition)
       word = nested && WORD_OPERATORS.include?(wrapped.operator)
-      wrap(call, nested ? wrapped.extent : wrapped, word, 1)
-    end
-
-    # What a site's leave call wraps: an if's or an unless's
-    # predicate, a leaf's byte range or a nested Condition, as
-    # its path is decided there and its arms are statements that
-    # may return or raise; any other site as a whole.
-    def self.trailed(condition)
-      unless STATEMENT_CHOICES.include?(condition.operator)
-        return condition
-      end
-
-      condition.operands.first
+      wrap(call, nested ? wrapped.extent : wrapped, word, :site)
     end
 
     # The opening of the record call around operand index of
@@ -114,16 +76,23 @@ module PathCoverage
     def self.path_inserts(methods)
       methods.flat_map do |site, method|
         decisions = method.decisions
-        start = path_start(site, decisions.size)
         decides = decisions.each_with_index.flat_map do |decision, i|
           call = "PathCoverage.decide(#{PATH_NAME}, #{i}, "
           tail = decision.exits.nil? ? '' : ", #{decision.exits}"
-          wrap(call, decision.range, decision.command, 2, tail)
+          command = decision.command
+          wrap(call, decision.range, command, :decision, tail)
         end
-        [[method.entry, start, 3]] + decides
+        [start_insert(site, method)] + decides
       end
     end
 
+    # The insert at method's entry that starts a call's path,
+    # outermost of all there.
+    def self.start_insert(site, method)
+      start = path_start(site, method.decisions.size)
+      [method.entry, start, [Float::INFINITY, LAYERS.index(:path)]]
+    end
+
     # The statement that starts a call's path through the
     # method at site, which has size decisions.
     def self.path_start(site, size)
@@ -131,31 +100,43 @@ module PathCoverage
       "#{PATH_NAME} = #{call}; "
     end
 
-    # The two inserts that wrap the code at range in call, of
-    # rank among inserts at the same offset, with tail as the
-    # call's further arguments. A command call is parenthesised,
-    # as it is no bare argument; nothing else is, since
-    # parentheses make a statement, which gives its line a
-    # line-coverage count of its own.
-    def self.wrap(call, range, command, rank, tail = '')
+    # The layers of inserts, innermost first, that break a tie
+    # between inserts wrapping the same range: a leaf's call, a
+    # nested kind's call around its whole, eg end_items, a site's
+    # leave, a method's decide, and a method's path start.
+    LAYERS = %i[leaf kind site decision path].freeze
+
+    # The two inserts that wrap the code at range in call, with
+    # tail as the call's further arguments. Their order, [size,
+    # rank], nests them among inserts at the same offset: the
+    # longer range outside, the rank of layer in LAYERS breaking
+    # a tie. A command call is parenthesised, as it is no bare
+    # argument; nothing else is, since parentheses make a
+    # statement, which gives its line a line-coverage count of
+    # its own.
+    def self.wrap(call, range, command, layer, tail = '')
       open, close = command ? ['(', ")#{tail})"] : ['', "#{tail})"]
+      order = [range.size, LAYERS.index(layer)]
       [
-        [range.begin, call + open, rank],
-        [range.end, close, rank, :close]
+        [range.begin, call + open, order],
+        [range.end, close, order, :close]
       ]
     end
 
-    # Splices each [offset, text, rank] insert into source, last
-    # offset first so earlier offsets stay valid; a closing
+    # Splices each [offset, text, order] insert into source,
+    # last offset first so earlier offsets stay valid; a closing
     # insert is marked :close. Text spliced in later at an
     # offset lands before text already there, so at one offset
-    # opening inserts go in lowest rank first, leaving the
-    # highest outermost, then closing ones highest rank first,
+    # opening inserts go in lowest order first, leaving the
+    # highest outermost, then closing ones highest order first,
     # so the innermost call closes first and each tail stays
-    # with its own call.
+    # with its own call. Eg a ternary that is a method's
+    # decision is a site too: its leave, wrapping the whole
+    # ternary, opens outside the decide wrapping its predicate.
     def self.apply(source, inserts)
-      sorted = inserts.sort_by do |offset, _, rank, close|
-        close ? [-offset, 1, -rank] : [-offset, 0, rank]
+      sorted = inserts.sort_by do |offset, _, order, close|
+        size, rank = order
+        close ? [-offset, 1, -size, -rank] : [-offset, 0, size, rank]
       end
       sorted.each do |offset, text, _|
         source.bytesplice(offset, 0, text)

data/lib/path_coverage/rewriter_nested.rb

@@ -0,0 +1,62 @@
+require_relative 'condition'
+require_relative 'kinds'
+
+module PathCoverage
+  # The part of the rewriter that instruments the sites nested in
+  # another, eg the &. chain in ok && user&.admin?. The site
+  # around them enters and leaves; each nested site's leaves are
+  # noted as that site's, at their place among its leaves, by the
+  # calls its kind gives in place of plain records.
+  module RewriterNested
+    # { leaf range => the opening of its call, nil for none } for
+    # the leaves of every site nested in condition whose kind has
+    # calls of its own, condition itself included.
+    def self.calls(site, condition)
+      leaves = condition.leaves
+      rooted(condition).reduce({}) do |calls, inner|
+        kind = Kinds.of(inner.operator)
+        calls.merge(kind.calls(site, inner, leaves))
+      end
+    end
+
+    # The inserts, besides its leaves' calls, for every site
+    # nested in condition whose kind has calls of its own,
+    # condition itself included, as its kind gives them.
+    def self.inserts(site, condition)
+      leaves = condition.leaves
+      rooted(condition).flat_map do |inner|
+        at = leaves.index(inner.operands.first)
+        kind = Kinds.of(inner.operator)
+        kind.inserts(site, inner, at, condition.commands)
+      end
+    end
+
+    # condition alone when its kind has calls of its own, eg a
+    # block method's call that is a site of its own, its leaves
+    # then noted at their places from 0; else the sites nested in
+    # it.
+    def self.rooted(condition)
+      return [condition] if own_calls?(condition)
+
+      nested(condition)
+    end
+
+    # The sites nested in condition whose kind has calls of its
+    # own, in its operands and in its arms' conditions.
+    def self.nested(condition)
+      condition.operands.flat_map do |operand|
+        case operand
+        when Condition
+          own_calls?(operand) ? [operand] : nested(operand)
+        when Arm then operand.body ? nested(operand.body) : []
+        else []
+        end
+      end
+    end
+
+    # Whether condition's kind gives its leaves calls of their own.
+    def self.own_calls?(condition)
+      Kinds.of(condition.operator).own_calls?
+    end
+  end
+end