yaml_tools 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fe18af8ef1c5ccad515bc83b88c2a663d143e56d49a30efe748b772b9ff3572b
+  data.tar.gz: 6fc99c8e0aa6ef9385ba82a1999b763fcab26f1a6298f6f02c4228c932e8b23a
+SHA512:
+  metadata.gz: 1c771e0e390a84bf7bac523e6a81f630ee46d20540b1b4bcd251c6840a6747b0d4a54059d4325f6c655ddbec95395730db98aae2dbcee67153d94e57a96b8b01
+  data.tar.gz: eb91e0ccc7c759123cee799b7b5422975a55dff273b6e965aba62a438f64aab246e9418a2e6ccff1fe9bea2eedb2bade562dcbaa668c2e2ea7f4640f4d6fc6da

data/lib/tools/combine.rb

@@ -0,0 +1,214 @@
+require 'yaml'
+
+module YAMLTools
+  class Combiner
+    def combine_levels (s, d)
+      level = []
+
+      # Split into key/value pairs
+      sourceChildren = s.each_slice(2).to_a
+      differenceChildren = d.each_slice(2).to_a
+
+      sourceChildren.each {|sourcePair|
+        sourceKey = sourcePair[0]
+        sourceValue = sourcePair[1]
+
+        # Find difference pair
+        differencePairs = differenceChildren.find_all {|i| i[0].value == sourceKey.value}
+
+        if (differencePairs.length > 1) then
+          if (sourceKey.value == "<<") then
+            # Find merge key with matching alias
+            differencePair = differencePairs.find {|i|
+              (i[1].is_a?(Psych::Nodes::Alias) && i[1].anchor == sourceValue.anchor) ||
+              (i[1].is_a?(Psych::Nodes::Sequence) && i[1].children.any? {|a| a.is_a?(Psych::Nodes::Alias) && a.anchor == sourceValue.anchor})}
+          else
+            # Some ArchivesSpace files have duplicate keys so use the last one
+            differencePair = differencePairs.last
+          end
+        else
+          differencePair = differencePairs.first
+        end
+
+        if (differencePair == nil) then
+          # difference not found so copy node
+          level << sourceKey
+          level << sourceValue
+        else
+          differenceKey = differencePair[0]
+          differenceValue = differencePair[1]
+
+          if (differenceKey.value == '<<') then
+            # If aliases or sequences of aliases then merge
+            if ((sourceValue.is_a?(Psych::Nodes::Alias) || sourceValue.is_a?(Psych::Nodes::Sequence)) && (differenceValue.is_a?(Psych::Nodes::Alias) || differenceValue.is_a?(Psych::Nodes::Sequence))) then
+              if (sourceValue.is_a?(Psych::Nodes::Alias) && (differenceValue.is_a?(Psych::Nodes::Sequence) && differenceValue.children.all? {|a| a.is_a?(Psych::Nodes::Alias)})) then
+                # Merge aliases
+                if (differenceValue.children.none? {|a| a.anchor == sourceValue.anchor}) then
+                  # Add alias to sequence
+                  differenceValue.children = differenceValue.children << sourceValue
+                end
+
+                level.insert(0, sourceKey)
+                level.insert(1, differenceValue)
+
+              elsif (differenceValue.is_a?(Psych::Nodes::Alias) && (sourceValue.is_a?(Psych::Nodes::Sequence) && sourceValue.children.all? {|a| a.is_a?(Psych::Nodes::Alias)})) then
+                # Merge aliases
+                if (sourceValue.children.none? {|a| a.anchor == differenceValue.anchor}) then
+                  # Add alias to sequence
+                  sourceValue.children = sourceValue.children << differenceValue
+                end
+
+                level.insert(0, sourceKey)
+                level.insert(1, sourceValue)
+              elsif (sourceValue.is_a?(Psych::Nodes::Sequence) && differenceValue.is_a?(Psych::Nodes::Sequence))
+                newSequence = Psych::Nodes::Sequence.new(sourceValue.anchor, sourceValue.tag, sourceValue.implicit, Psych::Nodes::Sequence::FLOW)
+
+                newSequence.children
+                  .concat(sourceValue.children, differenceValue.children)
+                  .uniq! {|a| a.anchor}
+
+                level.insert(0, sourceKey)
+                level.insert(1, newSequence)
+              elsif (sourceValue.is_a?(Psych::Nodes::Alias) && differenceValue.is_a?(Psych::Nodes::Alias))
+                if (sourceValue.anchor == differenceValue.anchor) then
+                  level.insert(0, sourceKey)
+                  level.insert(1, sourceValue)
+                else
+                  newSequence = Psych::Nodes::Sequence.new(sourceValue.anchor, sourceValue.tag, sourceValue.implicit, Psych::Nodes::Sequence::FLOW)
+
+                  newSequence.children
+                    .concat([sourceValue, differenceValue])
+                    .uniq! {|a| a.anchor}
+
+                  level.insert(0, sourceKey)
+                  level.insert(1, newSequence)
+                end
+              end
+            end
+          elsif (differenceValue.is_a?(Psych::Nodes::Mapping)) then
+            childLevel = combine_levels(sourceValue.children, differenceValue.children)
+
+            newMapping = Psych::Nodes::Mapping.new(sourceValue.anchor, sourceValue.tag, sourceValue.implicit, sourceValue.style)
+
+            if (childLevel.length > 0) then
+              newMapping.children.push(*childLevel)
+            end
+
+            level << differenceKey
+            level << newMapping
+          else
+            level << differenceKey
+            level << differenceValue
+          end
+        end
+      }
+
+      # Add all difference pairs that don't exist in the source
+
+      differenceChildren.each {|differencePair|
+        differenceKey = differencePair[0]
+        differenceValue = differencePair[1]
+
+        if (sourceChildren.none? {|i| i[0].value == differenceKey.value}) then
+          if (differenceKey.value == '<<') then
+            level.insert(0, differenceKey)
+            level.insert(1, differenceValue)
+          else
+            level << differenceKey
+            level << differenceValue
+          end
+        end
+      }
+
+      level
+    end
+
+    # def flatten_merge_keys(s)
+    #   level = []
+
+    #   sourceChildren = s.each_slice(2).to_a
+
+    #   mergeKeys = sourceChildren.find_all {|i| i[0].value == "<<" }
+
+    #   if (mergeKeys.length > 0) then
+    #     if (mergeKeys.length == 1) then
+    #       # Add merge key
+    #       level << mergeKeys.first[0]
+    #       level << mergeKeys.first[1]
+    #     else
+    #       newSequence = Psych::Nodes::Sequence.new(nil, nil, true, Psych::Nodes::Sequence::FLOW)
+
+    #       mergeKeys.each {|m|
+    #         if (m[1].is_a?(Psych::Nodes::Alias)) then
+    #           newSequence.children << m[1]
+    #         elsif (m[1].is_a?(Psych::Nodes::Sequence)) then
+    #           newSequence.children.concat(m[1].children)
+    #         end
+    #       }
+
+    #       level << Psych::Nodes::Scalar.new("<<")
+    #       level << newSequence
+    #     end
+    #   end
+
+    #   sourceChildren.each {|sourcePair|
+    #     sourceKey = sourcePair[0]
+    #     sourceValue = sourcePair[1]
+
+    #     if (sourceValue.is_a?(Psych::Nodes::Mapping)) then
+    #       childLevel = flatten_merge_keys(sourceValue.children)
+
+    #       newMapping = Psych::Nodes::Mapping.new(sourceValue.anchor, sourceValue.tag, sourceValue.implicit, sourceValue.style)
+
+    #       if (childLevel.length > 0) then
+    #         newMapping.children.push(*childLevel)
+    #       end
+
+    #       level << sourceKey
+    #       level << newMapping
+    #     else
+    #       if (sourceKey.value != "<<") then
+    #         level << sourceKey
+    #         level << sourceValue
+    #       end
+    #     end
+    #   }
+
+    #   level
+    # end
+
+    def combine_files(sourceFilePath, differenceFilePath)
+      sourceFile = File.open(sourceFilePath, "r")
+      differenceFile = File.open(differenceFilePath, "r")
+
+      begin
+        output = combine(sourceFile, differenceFile)
+      ensure
+        sourceFile.close
+        differenceFile.close
+      end
+
+      output
+    end
+
+    def combine(source, difference)
+      # Load files
+      sourceDocument = YAML.parse(source)
+      differenceDocument = YAML.parse(difference)
+
+      # Flatten merge keys for older ArchivesSpace files
+      sourceDocument = YAMLTools.flatten_merge_keys(sourceDocument.root.children)
+      differenceDocument = YAMLTools.flatten_merge_keys(differenceDocument.root.children)
+
+      @combined = combine_levels(sourceDocument, differenceDocument)
+
+      if (@combined.length > 0) then
+        output = YAMLTools.createDocument(@combined)
+      else
+        output = ''
+      end
+
+      output
+    end
+  end
+end

data/lib/tools/compare.rb

@@ -0,0 +1,267 @@
+require 'yaml'
+
+module YAMLTools
+  class Comparer
+    @source_anchors = {}
+    @modified_anchors = []
+
+    def processLevel (s, d, includeAnchorDependencies)
+      level = []
+
+      # Split into key/value pairs
+      sourceChildren = s.each_slice(2).to_a
+      destinationChildren = d.each_slice(2).to_a
+
+      # Add all anchors for this level for use when performing potential comparisons later
+      sourceChildren.find_all {|i| !i[1].is_a?(Psych::Nodes::Alias) && !i[1].anchor.nil?}.each {|i| @source_anchors[i[1].anchor] = i[1]}
+
+      destinationChildren.each {|destinationPair|
+        destinationKey = destinationPair[0]
+        destinationValue = destinationPair[1]
+
+        # Find source pair
+        sourcePairs = sourceChildren.find_all {|i| i[0].value == destinationKey.value}
+
+        if (sourcePairs.length > 1) then
+          if (destinationKey.value == "<<") then
+            # Find merge key with matching alias
+            sourcePair = sourcePairs.find {|i| i[1].is_a?(Psych::Nodes::Alias) && i[1].anchor == destinationValue.anchor}
+          else
+            # Some ArchivesSpace files have duplicate keys so use the last one
+            sourcePair = sourcePairs.last
+          end
+        else
+          sourcePair = sourcePairs.first
+        end
+
+        if (sourcePair == nil) then
+          # Source not found so copy node
+          level << destinationKey
+          level << destinationValue
+        else
+          sourceKey = sourcePair[0]
+          sourceValue = sourcePair[1]
+
+          if (sourceKey.value == "<<") then
+            # Handle merge keys specifically since they can be an individual alias or a sequence or aliases
+
+            if (sourceValue.is_a?(Psych::Nodes::Sequence)) then
+              if (destinationValue.is_a?(Psych::Nodes::Sequence)) then
+                if (sourceValue.children.length == destinationValue.children.length) then
+                  # Compare sequences
+                  sourceValue.children.each_with_index {|a, index|
+                    if (a.anchor != destinationValue.children[index].anchor || (includeAnchorDependencies && @modified_anchors.include?(destinationValue.children[index].anchor))) then
+                      # Different aliases or ordering
+                      level << destinationKey
+                      level << destinationValue
+                      break
+                    end
+                  }
+                else
+                  # Different number of aliases
+                  level << destinationKey
+                  level << destinationValue
+                end
+              elsif (destinationValue.is_a?(Psych::Nodes::Alias)) then
+                # Sequence of aliases overriden by single alias
+                level << destinationKey
+                level << destinationValue
+              else
+                # Bad data
+              end
+            elsif (sourceValue.is_a?(Psych::Nodes::Alias)) then
+              if (destinationValue.is_a?(Psych::Nodes::Sequence)) then
+                # Single alias overriden by sequence of aliases
+                level << destinationKey
+                level << destinationValue
+              elsif (destinationValue.is_a?(Psych::Nodes::Alias)) then
+                # Compare aliases
+                if (sourceValue.anchor != destinationValue.anchor || (includeAnchorDependencies && @modified_anchors.include?(destinationValue.anchor))) then
+                  # Different aliases
+                  level << destinationKey
+                  level << destinationValue
+                end
+              else
+                # Bad data
+              end
+            else
+              # Bad data
+            end
+          elsif (destinationValue.is_a?(Psych::Nodes::Mapping)) then
+            childLevel = processLevel(sourceValue.children, destinationValue.children, includeAnchorDependencies)
+
+            if (childLevel.length > 0) then
+              newMapping = Psych::Nodes::Mapping.new(destinationValue.anchor, destinationValue.tag, destinationValue.implicit, destinationValue.style)
+              newMapping.children.push(*childLevel)
+
+              level << destinationKey
+              level << newMapping
+
+              if (destinationValue.anchor != nil) then
+                @modified_anchors << destinationValue.anchor
+              end
+            end
+          elsif (destinationValue.is_a?(Psych::Nodes::Scalar)) then
+            if (sourceValue.is_a?(Psych::Nodes::Scalar) && (destinationValue.value != sourceValue.value)) then
+              level << destinationKey
+              level << destinationValue
+
+              if destinationValue.anchor != nil then
+                @modified_anchors << destinationValue.anchor
+              end
+            elsif (sourceValue.is_a?(Psych::Nodes::Alias || (includeAnchorDependencies && @modified_anchors.include?(destinationValue.anchor)))) then
+              level << destinationKey
+              level << destinationValue
+            end
+          elsif (destinationValue.is_a?(Psych::Nodes::Alias)) then
+            if (sourceValue.is_a?(Psych::Nodes::Alias) && (destinationValue.anchor != sourceValue.anchor)) then
+              level << destinationKey
+              level << destinationValue
+            elsif (sourceValue.is_a?(Psych::Nodes::Scalar)) then
+              level << destinationKey
+              level << destinationValue
+            end
+          end
+        end
+      }
+
+      if (includeAnchorDependencies)
+        # Find source pairs where value is alias that don't exist in destination
+        # Look for aliases whose anchor was modified
+        sourceChildren.find_all {|i|
+          i[1].is_a?(Psych::Nodes::Alias) &&
+          !i[1].anchor.nil? &&
+          @modified_anchors.include?(i[1].anchor)
+        }.each {|sp|
+          dPair = destinationChildren.find_all {|i| i[0].value == sp[0].value}.last
+
+          if (dPair == nil) then
+            level << sp[0]
+            level << sp[1]
+          end
+        }
+      end
+
+      level
+    end
+
+    def processModifiedAnchors(s, anchors)
+      level = []
+
+      # Split into key/value pairs
+      sourceChildren = s.each_slice(2).to_a
+
+      sourceChildren.each {|sourcePair|
+        sourceKey = sourcePair[0]
+        sourceValue = sourcePair[1]
+
+        # Check if merge key
+        if (sourceKey.value == "<<") then
+          # Check if in modified_anchors
+
+          if (sourceValue.is_a?(Psych::Nodes::Sequence)) then
+            # Check each anchor in sequence
+            aliases = sourceValue.children.find_all {|a| anchors.include?(a.anchor)}
+
+            if (aliases.length > 0) then
+              if (aliases.length == 1) then
+                level << sourceKey
+                level << aliases[0]
+              else
+                newSequence = Psych::Nodes::Sequence.new(sourceValue.anchor, sourceValue.tag, sourceValue.implicit, sourceValue.style)
+                newSequence.children.push(*aliases)
+
+                level << sourceKey
+                level << newSequence
+              end
+            end
+          else
+            if (anchors.include?(sourceValue.anchor)) then
+              # Add the merge key and include in the level
+              level << sourceKey
+              level << sourceValue
+            end
+          end
+
+          next
+        elsif (sourceValue.is_a?(Psych::Nodes::Mapping)) then
+          childLevel = processModifiedAnchors(sourceValue.children, anchors)
+
+          if (childLevel.length > 0) then
+            newMapping = Psych::Nodes::Mapping.new(sourceValue.anchor, sourceValue.tag, sourceValue.implicit, sourceValue.style)
+            newMapping.children.push(*childLevel)
+
+            level << sourceKey
+            level << newMapping
+
+            # Add new anchors that are located
+            if (sourceValue.anchor != nil) then
+              @modified_anchors << sourceValue.anchor
+            end
+          end
+        elsif (sourceValue.is_a?(Psych::Nodes::Alias) && anchors.include?(sourceValue.anchor)) then
+            # Add the merge key and include in the level
+            level << sourceKey
+            level << sourceValue
+        end
+      }
+
+      level
+    end
+
+    def compare_files(sourceFilePath, destinationFilePath, includeAnchorDependencies = false)
+      sourceFile = File.open(sourceFilePath, "r")
+      differenceFile = File.open(destinationFilePath, "r")
+
+      begin
+        result = compare(sourceFile, differenceFile, includeAnchorDependencies)
+      ensure
+        sourceFile.close
+        differenceFile.close
+      end
+
+      result
+    end
+
+    def compare(source, destination, includeAnchorDependencies = false)
+      @source_anchors = {}
+      @modified_anchors = []
+
+      sourceDocument = YAML.parse(source)
+      destinationDocument = YAML.parse(destination)
+
+      # Flatten merge keys for older ArchivesSpace files
+      sourceRootLevel = YAMLTools.flatten_merge_keys(sourceDocument.root.children)
+      destinationRootLevel = YAMLTools.flatten_merge_keys(destinationDocument.root.children)
+
+      @differences = processLevel(sourceRootLevel, destinationRootLevel, includeAnchorDependencies)
+
+      if (includeAnchorDependencies) then
+        @current_modified_anchors = []
+
+        combiner = Combiner.new
+
+        loop do
+          @current_modified_anchors = @modified_anchors.clone
+          @modified_anchors = []
+          modified_anchor_additions = processModifiedAnchors(sourceRootLevel, @current_modified_anchors)
+
+          if (modified_anchor_additions.length > 0) then
+            mergedDifferences = combiner.combine_levels(@differences, modified_anchor_additions)
+            @differences = mergedDifferences
+          end
+
+          break if (@current_modified_anchors.length == 0)
+        end
+      end
+
+      if (@differences.length > 0) then
+        output = YAMLTools.createDocument(@differences)
+      else
+        output = ''
+      end
+
+      output
+    end
+  end
+end

data/lib/tools/utility.rb

@@ -0,0 +1,74 @@
+require 'yaml'
+
+module YAMLTools
+  def self.createDocument(levels)
+    document = Psych::Nodes::Document.new()
+    documentRoot = Psych::Nodes::Mapping.new();
+    documentRoot.children.push(*levels)
+    document.children << documentRoot
+
+    stream = Psych::Nodes::Stream.new
+    stream.children << document
+    output = stream.to_yaml
+
+    # Remove initial document start
+    document_start = (output.index("---\n") || size - 1) + 4
+    output.slice!(0, document_start)
+
+    output
+  end
+
+  def self.flatten_merge_keys(s)
+    level = []
+
+    sourceChildren = s.each_slice(2).to_a
+
+    mergeKeys = sourceChildren.find_all {|i| i[0].value == "<<" }
+
+    if (mergeKeys.length > 0) then
+      if (mergeKeys.length == 1) then
+        # Add merge key
+        level << mergeKeys.first[0]
+        level << mergeKeys.first[1]
+      else
+        newSequence = Psych::Nodes::Sequence.new(nil, nil, true, Psych::Nodes::Sequence::FLOW)
+
+        mergeKeys.each {|m|
+          if (m[1].is_a?(Psych::Nodes::Alias)) then
+            newSequence.children << m[1]
+          elsif (m[1].is_a?(Psych::Nodes::Sequence)) then
+            newSequence.children.concat(m[1].children)
+          end
+        }
+
+        level << Psych::Nodes::Scalar.new("<<")
+        level << newSequence
+      end
+    end
+
+    sourceChildren.each {|sourcePair|
+      sourceKey = sourcePair[0]
+      sourceValue = sourcePair[1]
+
+      if (sourceValue.is_a?(Psych::Nodes::Mapping)) then
+        childLevel = flatten_merge_keys(sourceValue.children)
+
+        newMapping = Psych::Nodes::Mapping.new(sourceValue.anchor, sourceValue.tag, sourceValue.implicit, sourceValue.style)
+
+        if (childLevel.length > 0) then
+          newMapping.children.push(*childLevel)
+        end
+
+        level << sourceKey
+        level << newMapping
+      else
+        if (sourceKey.value != "<<") then
+          level << sourceKey
+          level << sourceValue
+        end
+      end
+    }
+
+    level
+  end
+end

data/lib/yaml_tools.rb

@@ -0,0 +1,5 @@
+module YAMLTools
+  require 'tools/combine'
+  require 'tools/compare'
+  require 'tools/utility'
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: yaml_tools
+version: !ruby/object:Gem::Version
+  version: 1.0.4
+platform: ruby
+authors:
+- Atlas Systems, Inc.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tools/combine.rb
+- lib/tools/compare.rb
+- lib/tools/utility.rb
+- lib/yaml_tools.rb
+homepage: https://github.com/AtlasSystems/yaml_tools
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: Tools for YAML files.
+test_files: []