ruby-merge 7.1.3 → 7.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa7e44e52e059397107051f945efaceb307742e3e40c36f61bf900ac06dd84e6
-  data.tar.gz: 1bb04482ae836481586da92f9266f0e03781d351b5ac25eb7eaf7fd83ad4f649
+  metadata.gz: e110369618446503145375467571c154f6f20f6a9a9e2ea1aec9fc87c2557618
+  data.tar.gz: ec6e31d2f85b299976139c80f2dee4574d6ef70fb721bcb514b36eddd995a5a8
 SHA512:
-  metadata.gz: 1828b958a01c2017de25ef21616c5a650cf3483b20804e93c54f9158a40c8eac146bdd6cde14118fae50b2fc6e85b439072a5bce5596cadb0ee2248213fab509
-  data.tar.gz: 12f7bb144511bc0d9ff4ba0f42241666ce394f416e1e2444fd329930aae8444ce158cbee7a950a5ddccb93398816b466083ab2f40d7faf032825fdb4a934e713
+  metadata.gz: b15e47b8e03c0da7a237edb9826ea7c05d4cc7c510cbd9c6d31b32d0a4787a2510d869b86cf6bd7c9b9c836bdcd6d4a9b57a921bb679f74d9a665daac2730a4e
+  data.tar.gz: c69a81757def5610a400599c3fa9b3459557b5c88c09be084c37e240cdfa00a8d50f7909bf63cf1b30ccc34ab20890d6fa3c6d4d49bca747246340216c7e1b03

data/README.md

@@ -267,7 +267,7 @@ If none of the available licenses suit your use case, please [contact us](mailto
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-1.989-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-2.006-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/structuredmerge/structuredmerge-ruby/blob/main/SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/lib/ruby/merge/block_binding_support.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Parser-neutral naming policy for a block-local receiver.
+    module BlockBindingSupport
+      module_function
+
+      def effective_receiver(receiver, block_var, placeholder: :__block_binding__)
+        block_var && receiver == block_var ? placeholder : receiver
+      end
+
+      def preferred_block_var(template_var, destination_var)
+        template_var if template_var && destination_var && template_var != destination_var
+      end
+
+      def merged_block_var(var, preferred_var)
+        preferred_var || var
+      end
+    end
+  end
+end

data/lib/ruby/merge/block_directive_detector.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Detects Ruby comment block directive pairs in source lines.
+    #
+    # This is Ruby-specific substrate behavior shared by Ruby parser providers.
+    # Parser-specific gems may consume the spans and project them into their own
+    # node types, but directive token semantics should live here.
+    # Directive scanning intentionally keeps the paired-stack validation in one
+    # class so every caller receives identical malformed-input diagnostics.
+    # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/ClassLength
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    class BlockDirectiveDetector
+      Span = Struct.new(:kind, :start_line, :end_line, :open_marker, :close_marker, keyword_init: true)
+
+      NOCOV_TOKEN = ':nocov:'
+      SIMPLECOV_DISABLE_RE = /\A\s*#\s*simplecov\s*:\s*disable\b/i
+      SIMPLECOV_ENABLE_RE = /\A\s*#\s*simplecov\s*:\s*enable\b/i
+      DIRECTIVE_CONTENT_RE = /\A(?::nocov:|[\w-]+:(?:freeze|unfreeze))\z/i
+
+      class << self
+        def coverage_directive_line?(line, nocov_token: NOCOV_TOKEN)
+          stripped = line.to_s.chomp
+          stripped.match?(simplecov_disable_re) ||
+            stripped.match?(simplecov_enable_re) ||
+            stripped.match?(nocov_re(nocov_token))
+        end
+
+        def directive_content?(content)
+          DIRECTIVE_CONTENT_RE.match?(content.to_s.strip) ||
+            coverage_directive_line?("# #{content}")
+        end
+
+        def simplecov_disable_re
+          SIMPLECOV_DISABLE_RE
+        end
+
+        def simplecov_enable_re
+          SIMPLECOV_ENABLE_RE
+        end
+
+        def nocov_re(nocov_token = NOCOV_TOKEN)
+          /\A\s*#\s?#{Regexp.escape(nocov_token)}\s*\z/i
+        end
+      end
+
+      def initialize(lines, freeze_token: nil, nocov_token: NOCOV_TOKEN, source_label: nil)
+        @lines = lines
+        @freeze_token = freeze_token
+        @nocov_token = nocov_token
+        @source_label = source_label
+      end
+
+      def detect_spans
+        raw_spans = []
+        raw_spans.concat(detect_freeze_spans) if @freeze_token
+        raw_spans.concat(detect_nocov_spans)
+
+        validate_no_crossing(raw_spans.sort_by(&:start_line))
+      end
+
+      private
+
+      def detector_name
+        'ruby-merge'
+      end
+
+      def directive_error_class
+        Ast::Merge::Error
+      end
+
+      def warn_prefix
+        if @source_label
+          "[#{detector_name}] BlockDirectiveDetector (#{@source_label}):"
+        else
+          "[#{detector_name}] BlockDirectiveDetector:"
+        end
+      end
+
+      def report_unbalanced(message)
+        raise directive_error_class, "#{warn_prefix} #{message}" if @source_label
+
+        warn("#{warn_prefix} #{message} - ignoring")
+      end
+
+      def detect_freeze_spans
+        freeze_pat = /\A\s*#\s?#{Regexp.escape(@freeze_token)}:freeze\b/i
+        unfreeze_pat = /\A\s*#\s?#{Regexp.escape(@freeze_token)}:unfreeze\b/i
+
+        spans = []
+        stack = []
+
+        @lines.each_with_index do |line, index|
+          line_num = index + 1
+          stripped = line.to_s.chomp
+          if stripped.match?(freeze_pat)
+            stack.push({ start_line: line_num, open_marker: stripped })
+          elsif stripped.match?(unfreeze_pat)
+            if (open = stack.pop)
+              spans << Span.new(
+                kind: :freeze,
+                start_line: open[:start_line],
+                end_line: line_num,
+                open_marker: open[:open_marker],
+                close_marker: stripped
+              )
+            else
+              report_unbalanced("unmatched #{@freeze_token}:unfreeze at line #{line_num}")
+            end
+          end
+        end
+
+        stack.each do |open|
+          report_unbalanced("unclosed #{@freeze_token}:freeze at line #{open[:start_line]}")
+        end
+
+        spans
+      end
+
+      def detect_nocov_spans
+        return [] unless @nocov_token
+
+        nocov_pat = self.class.nocov_re(@nocov_token)
+
+        spans = []
+        stack = []
+
+        @lines.each_with_index do |line, index|
+          line_num = index + 1
+          stripped = line.to_s.chomp
+          if stripped.match?(self.class.simplecov_disable_re)
+            stack.push({ start_line: line_num, open_marker: stripped })
+          elsif stripped.match?(self.class.simplecov_enable_re)
+            if (open = stack.pop)
+              spans << Span.new(
+                kind: :nocov,
+                start_line: open[:start_line],
+                end_line: line_num,
+                open_marker: open[:open_marker],
+                close_marker: stripped
+              )
+            else
+              report_unbalanced("unmatched simplecov:enable at line #{line_num}")
+            end
+          elsif stripped.match?(nocov_pat)
+            if stack.empty?
+              stack.push({ start_line: line_num, open_marker: stripped })
+            else
+              open = stack.pop
+              spans << Span.new(
+                kind: :nocov,
+                start_line: open[:start_line],
+                end_line: line_num,
+                open_marker: open[:open_marker],
+                close_marker: stripped
+              )
+            end
+          end
+        end
+
+        stack.each do |open|
+          report_unbalanced("unclosed coverage directive at line #{open[:start_line]}")
+        end
+
+        spans
+      end
+
+      def validate_no_crossing(spans)
+        valid = []
+        invalid_indices = Set.new
+
+        spans.each_with_index do |first, first_index|
+          next if invalid_indices.include?(first_index)
+
+          crossing = false
+          spans.each_with_index do |second, second_index|
+            next if first_index == second_index || invalid_indices.include?(second_index)
+            next unless crossing_spans?(first, second)
+
+            report_unbalanced(
+              "offset-overlapping #{first.kind} block (lines #{first.start_line}..#{first.end_line}) and " \
+              "#{second.kind} block (lines #{second.start_line}..#{second.end_line}) - both treated as plain comments"
+            )
+            invalid_indices.add(first_index)
+            invalid_indices.add(second_index)
+            crossing = true
+            break
+          end
+
+          valid << first unless crossing
+        end
+
+        valid
+      end
+
+      def crossing_spans?(first, second)
+        first_crosses_second = first.start_line < second.start_line &&
+                               first.end_line > second.start_line &&
+                               first.end_line < second.end_line
+        second_crosses_first = second.start_line < first.start_line &&
+                               second.end_line > first.start_line &&
+                               second.end_line < first.end_line
+        first_crosses_second || second_crosses_first
+      end
+
+      def top_level_spans_only(spans)
+        spans.reject do |span|
+          spans.any? do |other|
+            other != span &&
+              other.start_line <= span.start_line &&
+              other.end_line >= span.end_line
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/ClassLength
+  end
+end

data/lib/ruby/merge/doc_comment_support.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Ruby-specific doc-comment semantics shared by Ruby parser providers.
+    module DocCommentSupport
+      TAG_PREFIX = /\A@[a-z_]+\b/
+      EXAMPLE_TAG = /\A@example\b(?<rest>.*)\z/
+      MAGIC_COMMENT_PREFIXES = %w[
+        coding
+        encoding
+        frozen_string_literal
+        shareable_constant_value
+        typed
+        warn_indent
+      ].freeze
+
+      module_function
+
+      def normalize_comment_content(raw)
+        raw.to_s.sub(/\A\s*#\s?/, '').strip
+      end
+
+      def comment_prefix_for(raw)
+        raw.to_s[/\A\s*#\s*/] || '# '
+      end
+
+      def doc_comment_content?(raw, magic_comment: false)
+        content = normalize_comment_content(raw)
+        return false if content.empty?
+        return false if BlockDirectiveDetector.directive_content?(content)
+        return false if magic_comment || magic_comment_content?(content)
+
+        true
+      end
+
+      def magic_comment_content?(content)
+        MAGIC_COMMENT_PREFIXES.any? { |prefix| content.to_s.start_with?("#{prefix}:") }
+      end
+
+      def declared_example_language(rest)
+        match = rest.to_s.strip.match(/\A\[(?<language>[^\]]+)\]/)
+        normalize_language(match && match[:language])
+      end
+
+      def declared_example_language_for_tag(content)
+        match = EXAMPLE_TAG.match(content.to_s)
+        return unless match
+
+        declared_example_language(match[:rest])
+      end
+
+      def normalize_language(language)
+        return if language.nil?
+
+        normalized = language.to_s.strip.downcase.tr('-', '_')
+        return if normalized.empty?
+
+        normalized
+      end
+
+      def next_tag_index(normalized_lines, start_index)
+        normalized_lines.each_with_index do |content, index|
+          next if index < start_index
+
+          return index if TAG_PREFIX.match?(content)
+        end
+        nil
+      end
+
+      # Example extraction deliberately combines tag scanning and body slicing
+      # so the returned indexes remain tied to the original comment entries.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def example_blocks(entries)
+        normalized = entries.map { |entry| normalize_comment_content(entry[:raw]) }
+        normalized.each_with_index.filter_map do |content, tag_index|
+          match = EXAMPLE_TAG.match(content)
+          next unless match
+
+          body_start_index = tag_index + 1
+          body_end_index = next_tag_index(normalized, body_start_index) || normalized.length
+          next if body_start_index >= body_end_index
+
+          body_entries = entries[body_start_index...body_end_index]
+          next if body_entries.nil? || body_entries.empty?
+
+          {
+            tag_index: tag_index,
+            tag_line: entries[tag_index][:line],
+            tag_text: normalized[tag_index],
+            body_start_index: body_start_index,
+            body_end_index: body_end_index,
+            body_entries: body_entries,
+            declared_language: declared_example_language(match[:rest])
+          }
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    end
+  end
+end

data/lib/ruby/merge/gemspec_support.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'block_binding_support'
+
+module Ruby
+  module Merge
+    # Shared gemspec block-variable normalization for Ruby templating.
+    module GemspecSupport
+      GEMSPEC_VAR_PLACEHOLDER = :__gemspec_var__
+
+      module_function
+
+      def effective_receiver(receiver, gemspec_block_var)
+        BlockBindingSupport.effective_receiver(receiver, gemspec_block_var, placeholder: GEMSPEC_VAR_PLACEHOLDER)
+      end
+
+      def preferred_block_var(template_var, dest_var)
+        BlockBindingSupport.preferred_block_var(template_var, dest_var)
+      end
+
+      def merged_block_var(var, preferred_var)
+        BlockBindingSupport.merged_block_var(var, preferred_var)
+      end
+
+      def opening_line_with_preferred_block_var(opening_line, dest_var:, preferred_var:, node_preference:)
+        return opening_line unless preferred_var && dest_var && dest_var != preferred_var
+        return opening_line unless node_preference == :destination
+
+        opening_line.sub("|#{dest_var}|", "|#{preferred_var}|")
+      end
+    end
+  end
+end

data/lib/ruby/merge/magic_comment_support.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Ruby magic comment detection and file-header prefix handling.
+    # Header scanning intentionally preserves source order and duplicate entries
+    # because those details affect comment ownership during reconstruction.
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    module MagicCommentSupport
+      MAGIC_COMMENT_PATTERNS = {
+        frozen_string_literal: /^frozen_string_literal:\s*(true|false)$/i,
+        encoding: /^(encoding|coding):\s*\S+$/i,
+        warn_indent: /^warn_indent:\s*(true|false)$/i,
+        shareable_constant_value: /^shareable_constant_value:\s*\S+$/i
+      }.freeze
+
+      module_function
+
+      def magic_comment_type_for_text(text)
+        stripped = DocCommentSupport.normalize_comment_content(text)
+
+        MAGIC_COMMENT_PATTERNS.each do |type, pattern|
+          return type if stripped.match?(pattern)
+        end
+
+        nil
+      end
+
+      def comment_only_prefix_info(lines)
+        entries = []
+        suppressed_line_nums = Set.new
+        duplicate_magic_line_nums = Set.new
+
+        if shebang_line?(lines.first)
+          entries << { line_num: 1, text: lines.first.to_s, kind: :shebang }
+          suppressed_line_nums << 1
+        end
+
+        header_magic_types = header_magic_comment_types_for_lines(lines)
+        seen_magic_types = Set.new
+
+        header_magic_types.keys.sort.each do |line_num|
+          magic_type = header_magic_types[line_num]
+          suppressed_line_nums << line_num
+          entries << { line_num: line_num, text: lines[line_num - 1].to_s.chomp, kind: :magic }
+
+          if seen_magic_types.include?(magic_type)
+            duplicate_magic_line_nums << line_num
+          else
+            seen_magic_types << magic_type
+          end
+        end
+
+        if header_magic_types.any?
+          blank_line_num = header_magic_types.keys.max + 1
+
+          while blank_line_num <= lines.length && lines[blank_line_num - 1].to_s.rstrip.empty?
+            entries << { line_num: blank_line_num, text: lines[blank_line_num - 1].to_s, kind: :blank }
+            suppressed_line_nums << blank_line_num
+            blank_line_num += 1
+          end
+        end
+
+        {
+          entries: entries,
+          suppressed_line_nums: suppressed_line_nums,
+          duplicate_magic_line_nums: duplicate_magic_line_nums,
+          header_magic_comment_types: header_magic_types
+        }
+      end
+
+      def header_magic_comment_types_for_lines(lines)
+        types = {}
+        index = shebang_line?(lines.first) ? 1 : 0
+        previous_line_num = shebang_line?(lines.first) ? 1 : nil
+
+        while index < lines.length
+          line_num = index + 1
+          stripped = lines[index].to_s.rstrip
+          break if stripped.empty?
+
+          expected_line_num = previous_line_num ? previous_line_num + 1 : 1
+          break unless line_num == expected_line_num
+
+          magic_type = magic_comment_type_for_text(stripped)
+          break unless magic_type
+
+          types[line_num] = magic_type
+          previous_line_num = line_num
+          index += 1
+        end
+
+        types
+      end
+
+      def prefix_comment_line_numbers_for_comments(comments)
+        prefix_line_nums = Set.new
+        previous_line_num = nil
+        index = 0
+
+        if shebang_comment?(comments.first)
+          prefix_line_nums << 1
+          previous_line_num = 1
+          index = 1
+        end
+
+        while index < comments.length
+          comment = comments[index]
+          line_num = comment.location.start_line
+          expected_line_num = previous_line_num ? previous_line_num + 1 : 1
+          break unless line_num == expected_line_num
+          break unless magic_comment_type_for_text(comment.slice)
+
+          prefix_line_nums << line_num
+          previous_line_num = line_num
+          index += 1
+        end
+
+        prefix_line_nums
+      end
+
+      def shebang_line?(line)
+        line.to_s.start_with?('#!')
+      end
+
+      def shebang_comment?(comment)
+        comment&.slice&.start_with?('#!')
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+  end
+end

data/lib/ruby/merge/method_similarity.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Computes stable name/parameter similarity scores for Ruby methods.
+    #
+    # The dynamic-programming distance calculation is intentionally kept local
+    # to this value object so the matching contract stays easy to audit.
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    class MethodSimilarity
+      DEFAULT_NAME_WEIGHT = 0.7
+      DEFAULT_PARAMS_WEIGHT = 0.3
+
+      attr_reader :name_weight, :params_weight
+
+      def initialize(name_weight: DEFAULT_NAME_WEIGHT, params_weight: DEFAULT_PARAMS_WEIGHT)
+        @name_weight = name_weight
+        @params_weight = params_weight
+      end
+
+      def call(template_name:, template_params:, dest_name:, dest_params:)
+        name_score = string_similarity(template_name.to_s, dest_name.to_s)
+        param_score = param_similarity(Array(template_params), Array(dest_params))
+
+        (name_score * name_weight) + (param_score * params_weight)
+      end
+
+      def param_similarity(template_params, dest_params)
+        return 1.0 if template_params.empty? && dest_params.empty?
+        return 0.0 if template_params.empty? || dest_params.empty?
+
+        common = (template_params & dest_params).size
+        total = [template_params.size, dest_params.size].max
+        count_ratio = [template_params.size, dest_params.size].min.to_f / total
+        name_match_ratio = common.to_f / total
+
+        (name_match_ratio * 0.7) + (count_ratio * 0.3)
+      end
+
+      def string_similarity(str1, str2)
+        return 1.0 if str1 == str2
+        return 0.0 if str1.empty? || str2.empty?
+
+        distance = levenshtein_distance(str1, str2)
+        max_len = [str1.length, str2.length].max
+
+        1.0 - (distance.to_f / max_len)
+      end
+
+      def levenshtein_distance(str1, str2)
+        return str2.length if str1.empty?
+        return str1.length if str2.empty?
+
+        str1, str2 = str2, str1 if str1.length > str2.length
+
+        m = str1.length
+        n = str2.length
+        previous_row = (0..m).to_a
+        current_row = Array.new(m + 1, 0)
+
+        (1..n).each do |j|
+          current_row[0] = j
+
+          (1..m).each do |i|
+            cost = str1[i - 1] == str2[j - 1] ? 0 : 1
+            current_row[i] = [
+              previous_row[i] + 1,
+              current_row[i - 1] + 1,
+              previous_row[i - 1] + cost
+            ].min
+          end
+
+          previous_row, current_row = current_row, previous_row
+        end
+
+        previous_row[m]
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+  end
+end

data/lib/ruby/merge/nocov_node_base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Shared Ruby synthetic node for a balanced coverage-exclusion block.
+    #
+    # Parser-specific merge gems subclass this when they need native AST location
+    # or comment attachment behavior. The structural Ruby semantics live here:
+    # nocov blocks follow file preference and match by their inner content.
+    # Nocov nodes preserve source locations and marker text as one structural
+    # unit; the initializer mirrors the node's complete serialized shape.
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    class NocovNodeBase
+      include Ast::Merge::BlockDirective
+
+      InvalidStructureError = Class.new(StandardError)
+
+      Location = Struct.new(:start_line, :end_line) do
+        def cover?(line)
+          (start_line..end_line).cover?(line)
+        end
+      end
+
+      attr_reader :start_line, :end_line, :nodes, :analysis, :start_marker, :close_marker
+
+      def initialize(start_line:, end_line:, analysis:, nodes: [], start_marker: nil, close_marker: nil)
+        @start_line = start_line
+        @end_line = end_line
+        @analysis = analysis
+        @nodes = nodes
+        @start_marker = start_marker
+        @close_marker = close_marker
+      end
+
+      def kind = :nocov
+
+      def children = @nodes
+
+      def merge_policy = nil
+
+      def location
+        @location ||= Location.new(@start_line, @end_line)
+      end
+
+      def slice
+        return unless @analysis
+
+        lines = @analysis.lines
+        return unless lines
+
+        lines[(@start_line - 1)..(@end_line - 1)]&.join
+      end
+
+      def signature
+        return [:NocovNode, nil] if @nodes.empty? || @analysis.nil?
+
+        if @nodes.length == 1
+          @analysis.generate_signature(@nodes.first)
+        else
+          inner_lines = @analysis.lines && @analysis.lines[@start_line..(@end_line - 2)]
+          [:nocov_multi, inner_lines&.map(&:strip)&.join("\n")]
+        end
+      end
+
+      def merge_type = :nocov_block
+
+      alias type merge_type
+
+      def nocov_node? = true
+
+      def inspect
+        "#<#{self.class} lines=#{@start_line}..#{@end_line} nodes=#{@nodes.length}>"
+      end
+
+      alias to_s inspect
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/PerceivedComplexity
+  end
+end