plain-merge 7.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd3d000aba244c2628a3216cb39596c0019700c11ae89568efef00a6aa3aa796
+  data.tar.gz: 3e2c8c645cc153e6e48194d8ce9860b0adf8c4ce1d5582ab6b9f14d8a85fe2f7
+SHA512:
+  metadata.gz: f4ac184c99e041ed6b0f0551022fc9e0163b681db893344a07b1f30503220250ffe9fd19092b5b60fe05a5ed78c627fc736ec0c3d7a9884259977a60f03e7278
+  data.tar.gz: eaf6d3f57d5cf225ef29e5aa9e0f5021df15d6b74d6aaa2b2d62bf9fa495dfe91fbd784b8775fbe443c38756749ea2c1282b6f784eaf69f2158cb3908f7a54ca

checksums.yaml.gz.sig

@@ -0,0 +1,2 @@
+\s�(���V0;����%s���Z@O	���n��v&-���$K�(dz��d
+Z�z:�:������p?�Hg��v��|����)#�B��K�c:�A�ܨ�3kk!��A+1K�'��~�G�q�j�#jlo}w��F���bA0w�D|���C#O{�	h�Sx�mM���/�ZI���3����ڌ�VM�n.̽�ٛ4��G`)������������I[��Z	iE�d��b

data/lib/plain/merge/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Plain
+  module Merge
+    module Version
+      VERSION = "7.0.0"
+    end
+
+    VERSION = Version::VERSION
+  end
+end

data/lib/plain/merge.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "tree_haver"
+
+module Plain
+  module Merge
+    PACKAGE_NAME = "plain-merge"
+    DEFAULT_TEXT_REFINEMENT_THRESHOLD = 0.7
+    DEFAULT_TEXT_REFINEMENT_WEIGHTS = {
+      content: 0.7,
+      length: 0.15,
+      position: 0.15
+    }.freeze
+
+    module_function
+
+    def text_feature_profile
+      {
+        family: "text",
+        supported_dialects: [],
+        supported_policies: []
+      }
+    end
+
+    def text_parse_request(source)
+      TreeHaver::ParserRequest.new(source: source, language: "text")
+    end
+
+    def normalize_text(source)
+      source
+        .gsub(/\r\n?/, "\n")
+        .strip
+        .split(/\n\s*\n+/)
+        .map { |block| block.strip.gsub(/\s+/, " ") }
+        .reject(&:empty?)
+        .join("\n\n")
+    end
+
+    def analyze_text(source)
+      normalized_source = normalize_text(source)
+      parts = normalized_source.empty? ? [] : normalized_source.split("\n\n")
+      cursor = 0
+
+      blocks = parts.each_with_index.map do |normalized, index|
+        start_offset = cursor
+        end_offset = start_offset + normalized.length
+        cursor = end_offset + 2
+
+        {
+          index: index,
+          normalized: normalized,
+          span: {
+            start: start_offset,
+            end: end_offset
+          }
+        }
+      end
+
+      {
+        kind: "text",
+        normalized_source: normalized_source,
+        blocks: blocks
+      }
+    end
+
+    def similarity_score(left_source, right_source)
+      left = analyze_text(left_source)
+      right = analyze_text(right_source)
+      total = [left[:blocks].length, right[:blocks].length].max
+      return 1.0 if total.zero?
+
+      sum = 0.0
+      total.times do |index|
+        left_block = left[:blocks][index]
+        right_block = right[:blocks][index]
+        next unless left_block && right_block
+
+        sum += jaccard(left_block[:normalized], right_block[:normalized])
+      end
+
+      sum / total
+    end
+
+    def is_similar(left_source, right_source, threshold)
+      score = similarity_score(left_source, right_source)
+      {
+        score: score,
+        threshold: threshold,
+        matched: score >= threshold
+      }
+    end
+
+    def match_text_blocks(template_source, destination_source)
+      template = analyze_text(template_source)
+      destination = analyze_text(destination_source)
+      matched_template = {}
+      matched_destination = {}
+      matched = []
+
+      destination[:blocks].each_with_index do |destination_block, destination_index|
+        template_index = template[:blocks].find_index.with_index do |template_block, candidate_index|
+          !matched_template[candidate_index] && template_block[:normalized] == destination_block[:normalized]
+        end
+        next unless template_index
+
+        matched_template[template_index] = true
+        matched_destination[destination_index] = true
+        matched << {
+          template_index: template_index,
+          destination_index: destination_index,
+          phase: "exact",
+          score: 1.0
+        }
+      end
+
+      destination[:blocks].each_with_index do |destination_block, destination_index|
+        next if matched_destination[destination_index]
+
+        best_template_index = nil
+        best_score = 0.0
+        template[:blocks].each_with_index do |template_block, template_index|
+          next if matched_template[template_index]
+
+          score = refined_text_similarity(
+            template_block,
+            destination_block,
+            template[:blocks].length,
+            destination[:blocks].length
+          )
+          next unless score >= DEFAULT_TEXT_REFINEMENT_THRESHOLD && score > best_score
+
+          best_score = score
+          best_template_index = template_index
+        end
+
+        next unless best_template_index
+
+        matched_template[best_template_index] = true
+        matched_destination[destination_index] = true
+        matched << {
+          template_index: best_template_index,
+          destination_index: destination_index,
+          phase: "refined",
+          score: best_score
+        }
+      end
+
+      {
+        matched: matched,
+        unmatched_template: template[:blocks].each_index.reject { |index| matched_template[index] },
+        unmatched_destination: destination[:blocks].each_index.reject { |index| matched_destination[index] }
+      }
+    end
+
+    def merge_text(template_source, destination_source)
+      template = analyze_text(template_source)
+      destination = analyze_text(destination_source)
+      matches = match_text_blocks(template_source, destination_source)
+      matched_template = matches[:matched].each_with_object({}) { |match, memo| memo[match[:template_index]] = true }
+      merged_blocks = destination[:blocks].map { |block| block[:normalized] }
+
+      template[:blocks].each_with_index do |block, index|
+        next if matched_template[index]
+
+        merged_blocks << block[:normalized]
+      end
+
+      {
+        ok: true,
+        diagnostics: [],
+        output: merged_blocks.join("\n\n")
+      }
+    end
+
+    def refined_text_similarity(template_block, destination_block, template_total, destination_total, weights = DEFAULT_TEXT_REFINEMENT_WEIGHTS)
+      content = string_similarity(template_block[:normalized], destination_block[:normalized])
+      length = length_similarity(template_block[:normalized], destination_block[:normalized])
+      position = position_similarity(
+        template_block[:index],
+        destination_block[:index],
+        template_total,
+        destination_total
+      )
+
+      (weights[:content] * content) + (weights[:length] * length) + (weights[:position] * position)
+    end
+
+    def token_set(normalized)
+      normalized.split(/\s+/).reject(&:empty?).to_h { |token| [token, true] }
+    end
+    private_class_method :token_set
+
+    def jaccard(left, right)
+      left_tokens = token_set(left)
+      right_tokens = token_set(right)
+      return 1.0 if left_tokens.empty? && right_tokens.empty?
+
+      intersection = left_tokens.keys.count { |token| right_tokens[token] }
+      union = (left_tokens.keys + right_tokens.keys).uniq.length
+      union.zero? ? 1.0 : intersection.to_f / union
+    end
+    private_class_method :jaccard
+
+    def levenshtein_distance(left, right)
+      return 0 if left == right
+      return right.length if left.empty?
+      return left.length if right.empty?
+
+      previous = (0..left.length).to_a
+      current = Array.new(left.length + 1, 0)
+
+      (1..right.length).each do |right_index|
+        current[0] = right_index
+
+        (1..left.length).each do |left_index|
+          cost = left[left_index - 1] == right[right_index - 1] ? 0 : 1
+          current[left_index] = [
+            current[left_index - 1] + 1,
+            previous[left_index] + 1,
+            previous[left_index - 1] + cost
+          ].min
+        end
+
+        previous = current.dup
+      end
+
+      previous[left.length]
+    end
+    private_class_method :levenshtein_distance
+
+    def string_similarity(left, right)
+      return 1.0 if left == right
+      return 0.0 if left.empty? || right.empty?
+
+      distance = levenshtein_distance(left, right)
+      1.0 - (distance.to_f / [left.length, right.length].max)
+    end
+    private_class_method :string_similarity
+
+    def length_similarity(left, right)
+      return 1.0 if left.length == right.length
+      max_length = [left.length, right.length].max
+      return 1.0 if max_length.zero?
+
+      [left.length, right.length].min.to_f / max_length
+    end
+    private_class_method :length_similarity
+
+    def relative_position(index, total)
+      total > 1 ? index.to_f / (total - 1) : 0.5
+    end
+    private_class_method :relative_position
+
+    def position_similarity(template_index, destination_index, template_total, destination_total)
+      1.0 - (
+        relative_position(template_index, template_total) -
+        relative_position(destination_index, destination_total)
+      ).abs
+    end
+    private_class_method :position_similarity
+  end
+end

data/lib/plain-merge.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "plain/merge"

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: plain-merge
+version: !ruby/object:Gem::Version
+  version: 7.0.0
+platform: ruby
+authors:
+- Peter H. Boling
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIEgDCCAuigAwIBAgIBATANBgkqhkiG9w0BAQsFADBDMRUwEwYDVQQDDAxwZXRl
+  ci5ib2xpbmcxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkW
+  A2NvbTAeFw0yNTA1MDQxNTMzMDlaFw00NTA0MjkxNTMzMDlaMEMxFTATBgNVBAMM
+  DHBldGVyLmJvbGluZzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+  LGQBGRYDY29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAruUoo0WA
+  uoNuq6puKWYeRYiZekz/nsDeK5x/0IEirzcCEvaHr3Bmz7rjo1I6On3gGKmiZs61
+  LRmQ3oxy77ydmkGTXBjruJB+pQEn7UfLSgQ0xa1/X3kdBZt6RmabFlBxnHkoaGY5
+  mZuZ5+Z7walmv6sFD9ajhzj+oIgwWfnEHkXYTR8I6VLN7MRRKGMPoZ/yvOmxb2DN
+  coEEHWKO9CvgYpW7asIihl/9GMpKiRkcYPm9dGQzZc6uTwom1COfW0+ZOFrDVBuV
+  FMQRPswZcY4Wlq0uEBLPU7hxnCL9nKK6Y9IhdDcz1mY6HZ91WImNslOSI0S8hRpj
+  yGOWxQIhBT3fqCBlRIqFQBudrnD9jSNpSGsFvbEijd5ns7Z9ZMehXkXDycpGAUj1
+  to/5cuTWWw1JqUWrKJYoifnVhtE1o1DZ+LkPtWxHtz5kjDG/zR3MG0Ula0UOavlD
+  qbnbcXPBnwXtTFeZ3C+yrWpE4pGnl3yGkZj9SMTlo9qnTMiPmuWKQDatAgMBAAGj
+  fzB9MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQE8uWvNbPVNRXZ
+  HlgPbc2PCzC4bjAhBgNVHREEGjAYgRZwZXRlci5ib2xpbmdAZ21haWwuY29tMCEG
+  A1UdEgQaMBiBFnBldGVyLmJvbGluZ0BnbWFpbC5jb20wDQYJKoZIhvcNAQELBQAD
+  ggGBAJbnUwfJQFPkBgH9cL7hoBfRtmWiCvdqdjeTmi04u8zVNCUox0A4gT982DE9
+  wmuN12LpdajxZONqbXuzZvc+nb0StFwmFYZG6iDwaf4BPywm2e/Vmq0YG45vZXGR
+  L8yMDSK1cQXjmA+ZBKOHKWavxP6Vp7lWvjAhz8RFwqF9GuNIdhv9NpnCAWcMZtpm
+  GUPyIWw/Cw/2wZp74QzZj6Npx+LdXoLTF1HMSJXZ7/pkxLCsB8m4EFVdb/IrW/0k
+  kNSfjtAfBHO8nLGuqQZVH9IBD1i9K6aSs7pT6TW8itXUIlkIUI2tg5YzW6OFfPzq
+  QekSkX3lZfY+HTSp/o+YvKkqWLUV7PQ7xh1ZYDtocpaHwgxe/j3bBqHE+CUPH2vA
+  0V/FwdTRWcwsjVoOJTrYcff8pBZ8r2MvtAc54xfnnhGFzeRHfcltobgFxkAXdE6p
+  DVjBtqT23eugOqQ73umLcYDZkc36vnqGxUBSsXrzY9pzV5gGr2I8YUxMqf6ATrZt
+  L9nRqA==
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ast-merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: tree_haver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+description: Portable text normalization, similarity, matching, and merge behavior
+  for Structured Merge.
+email:
+- info@structuredmerge.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/plain-merge.rb
+- lib/plain/merge.rb
+- lib/plain/merge/version.rb
+homepage: https://github.com/structuredmerge/structuredmerge-ruby
+licenses:
+- AGPL-3.0-only
+- PolyForm-Small-Business-1.0.0
+metadata:
+  homepage_uri: https://structuredmerge.org
+  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.0.0
+  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.0.0/CHANGELOG.md
+  bug_tracker_uri: https://github.com/structuredmerge/structuredmerge-ruby/issues
+  documentation_uri: https://www.rubydoc.info/gems/plain-merge/7.0.0
+  funding_uri: https://github.com/sponsors/pboling
+  wiki_uri: https://github.com/structuredmerge/structuredmerge-ruby/wiki
+  discord_uri: https://discord.gg/3qme4XHNKN
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Structured Merge plain text analysis and merge for Ruby
+test_files: []