abide_dev_utils 0.14.2 → 0.16.0

data/lib/abide_dev_utils/xccdf/diff.rb

@@ -1,232 +1,96 @@
 # frozen_string_literal: true
 
-require 'hashdiff'
+require_relative 'parser'
 
 module AbideDevUtils
   module XCCDF
     # Contains methods and classes used to diff XCCDF-derived objects.
     module Diff
-      DEFAULT_DIFF_OPTS = {
-        similarity: 1,
-        strict: true,
-        strip: true,
-        array_path: true,
-        delimiter: '//',
-        use_lcs: true,
-      }.freeze
+      def self.benchmark_diff(xml1, xml2, opts = {})
+        bd = BenchmarkDiff.new(xml1, xml2, opts)
+        if opts[:raw]
+          return bd.diff_rules_raw if opts[:rules_only]
 
-      # Represents a change in a diff.
-      class ChangeSet
-        attr_reader :change, :key, :value, :value_to
+          bd.diff_raw
+        else
+          return bd.diff_rules if opts[:rules_only]
 
-        def initialize(change:, key:, value:, value_to: nil)
-          validate_change(change)
-          @change = change
-          @key = key
-          @value = value
-          @value_to = value_to
-        end
-
-        def to_s
-          value_change_string(value, value_to)
-        end
-
-        def to_h
-          {
-            change: change,
-            key: key,
-            value: value,
-            value_to: value_to,
-          }
-        end
-
-        def can_merge?(other)
-          return false unless (change == '-' && other.change == '+') || (change == '+' && other.change == '-')
-          return false unless key == other.key || value_hash_equality(other)
-
-          true
-        end
-
-        def merge(other)
-          unless can_merge?(other)
-            raise ArgumentError, 'Cannot merge. Possible causes: change is identical; key or value do not match'
-          end
-
-          new_to_value = value == other.value ? nil : other.value
-          ChangeSet.new(
-            change: '~',
-            key: key,
-            value: value,
-            value_to: new_to_value
-          )
-        end
-
-        def merge!(other)
-          new_props = merge(other)
-          @change = new_props.change
-          @key = new_props.key
-          @value = new_props.value
-          @value_to = new_props.value_to
-        end
-
-        private
-
-        def value_hash_equality(other)
-          equality = false
-          value.each do |k, v|
-            equality = true if v == other.value[k]
-          end
-          equality
-        end
-
-        def validate_change(chng)
-          raise ArgumentError, "Change type #{chng} in invalid" unless ['+', '-', '~'].include?(chng)
-        end
-
-        def change_string(chng)
-          case chng
-          when '-'
-            'Remove'
-          when '+'
-            'Add'
-          else
-            'Change'
-          end
-        end
-
-        def value_change_string(value, value_to)
-          change_str = []
-          change_diff = Hashdiff.diff(value, value_to || {}, AbideDevUtils::XCCDF::Diff::DEFAULT_DIFF_OPTS)
-          return if change_diff.empty?
-          return value_change_string_single_type(change_diff, value) if all_single_change_type?(change_diff)
-
-          change_diff.each do |chng|
-            change_str << if chng.length == 4
-                            "#{change_string(chng[0])} #{chng[1][0]} \"#{chng[2]}\" to \"#{chng[3]}\""
-                          else
-                            "#{change_string(chng[0])} #{chng[1][0]} with value #{chng[2]}"
-                          end
-          end
-          change_str.join(', ')
+          bd.diff
         end
+      end
 
-        def value_change_string_single_type(change_diff, value)
-          "#{change_string(change_diff[0][0])} #{value[:number]} - #{value[:level]} - #{value[:title]}"
+      # Class for benchmark diffs
+      class BenchmarkDiff
+        attr_reader :this, :other, :opts
+
+        # @param xml1 [String] path to the first benchmark XCCDF xml file
+        # @param xml2 [String] path to the second benchmark XCCDF xml file
+        # @param opts [Hash] options hash
+        def initialize(xml1, xml2, opts = {})
+          @this = new_benchmark(xml1)
+          @other = new_benchmark(xml2)
+          @opts = opts
         end
 
-        def all_single_change_type?(change_diff)
-          change_diff.length > 1 && change_diff.map { |x| x[0] }.uniq.length == 1
+        def diff_raw
+          @diff_raw ||= @this.diff(@other)
         end
-      end
 
-      # Class used to diff two Benchmark profiles.
-      class ProfileDiff
-        def initialize(profile_a, profile_b, opts = {})
-          @profile_a = profile_a
-          @profile_b = profile_b
-          @opts = opts
+        def diff
+          warn 'Full benchmark diff is not yet implemented, return rules diff for now'
+          diff_rules
         end
 
-        def diff
-          @diff ||= new_diff
+        def diff_rules_raw
+          @diff_rules_raw ||= @this.diff_only_rules(@other)
         end
 
-        private
+        def diff_rules
+          return diff_rules_raw if opts[:raw]
+          return [] if diff_rules_raw.all? { |r| r.type == :equal }
 
-        def new_diff
-          Hashdiff.diff(@profile_a, @profile_b, AbideDevUtils::XCCDF::Diff::DEFAULT_DIFF_OPTS).each_with_object({}) do |change, diff|
-            val_to = change.length == 4 ? change[3] : nil
-            change_key = change[2].is_a?(Hash) ? change[2][:title] : change[2]
-            if diff.key?(change_key)
-              diff[change_key] = merge_changes(
-                [
-                  diff[change_key][0],
-                  ChangeSet.new(change: change[0], key: change[1], value: change[2], value_to: val_to),
-                ]
-              )
+          diff_hash = {
+            from: @this.to_s,
+            to: @other.to_s,
+            rules: {}
+          }
+          diff_rules_raw.each do |rule|
+            diff_hash[:rules][rule.type] ||= []
+            case rule.type
+            when :added
+              diff_hash[:rules][rule.type] << { number: rule.new_value.number.to_s, title: rule.new_value.title.to_s }
+            when :removed
+              diff_hash[:rules][rule.type] << { number: rule.old_value.number.to_s, title: rule.old_value.title.to_s }
             else
-              diff[change_key] = [ChangeSet.new(change: change[0], key: change[1], value: change[2], value_to: val_to)]
+              rd_hash = {}
+              rd_hash[:from] = "#{rule.old_value&.number} #{rule.old_value&.title}" if rule.old_value
+              rd_hash[:to] = "#{rule.new_value&.number} #{rule.new_value&.title}" if rule.new_value
+              changes = rule.details.transform_values { |v| v.is_a?(Array) ? v.map(&:to_s) : v.to_s }
+              if opts[:ignore_changed_properties]
+                changes.delete_if { |k, _| opts[:ignore_changed_properties].include?(k.to_s) }
+                next if changes.empty? # Skip entirely if all changed filtered out
+              end
+              rd_hash[:changes] = changes unless changes.empty?
+              diff_hash[:rules][rule.type] << rd_hash
             end
           end
-        end
-
-        def merge_changes(changes)
-          return changes if changes.length < 2
-
-          if changes[0].can_merge?(changes[1])
-            [changes[0].merge(changes[1])]
-          else
-            changes
+          unless opts[:no_stats]
+            stats_hash = {}
+            diff_hash[:rules].each do |type, rules|
+              stats_hash[type] = rules.size
+            end
+            diff_hash[:stats] = stats_hash unless stats_hash.empty?
           end
-        end
-      end
-
-      # Class used to diff two AbideDevUtils::XCCDF::Benchmark objects.
-      class BenchmarkDiff
-        def initialize(benchmark_a, benchmark_b, opts = {})
-          @benchmark_a = benchmark_a
-          @benchmark_b = benchmark_b
-          @opts = opts
-        end
-
-        def properties_to_diff
-          @properties_to_diff ||= %i[title version profiles]
-        end
-
-        def title_version
-          @title_version ||= diff_title_version
-        end
-
-        def profiles(profile: nil)
-          @profiles ||= diff_profiles(profile: profile)
+          diff_hash
         end
 
         private
 
-        def diff_title_version
-          diff = Hashdiff.diff(
-            @benchmark_a.to_h.reject { |k, _| k.to_s == 'profiles' },
-            @benchmark_b.to_h.reject { |k, _| k.to_s == 'profiles' },
-            AbideDevUtils::XCCDF::Diff::DEFAULT_DIFF_OPTS
-          )
-          diff.each_with_object({}) do |change, tdiff|
-            val_to = change.length == 4 ? change[3] : nil
-            change_key = change[2].is_a?(Hash) ? change[2][:title] : change[2]
-            tdiff[change_key] = [] unless tdiff.key?(change_key)
-            tdiff[change_key] << ChangeSet.new(change: change[0], key: change[1], value: change[2], value_to: val_to)
-          end
+        # Returns a Benchmark object from a XCCDF xml file path
+        # @param xml [String] path to a XCCDF xml file
+        def new_benchmark(xml)
+          AbideDevUtils::XCCDF::Parser.parse(xml)
         end
-
-        def diff_profiles(profile: nil)
-          diff = {}
-          other_hash = @benchmark_b.to_h[:profiles]
-          @benchmark_a.to_h[:profiles].each do |name, data|
-            next if profile && profile != name
-
-            diff[name] = ProfileDiff.new(data, other_hash[name], @opts).diff
-          end
-          diff
-        end
-      end
-
-      def self.diff_benchmarks(benchmark_a, benchmark_b, opts = {})
-        profile = opts.fetch(:profile, nil)
-        profile_key = profile.nil? ? 'all_profiles' : profile
-        benchmark_diff = BenchmarkDiff.new(benchmark_a, benchmark_b, opts)
-        transform_method_sym = opts.fetch(:raw, false) ? :to_h : :to_s
-        diff = if profile.nil?
-                 benchmark_diff.profiles.each do |_, v|
-                   v.transform_values! { |x| x.map!(&transform_method_sym) }
-                 end
-               else
-                 benchmark_diff.profiles(profile: profile)[profile].transform_values! { |x| x.map!(&transform_method_sym) }
-               end
-        return diff.values.flatten if opts.fetch(:raw, false)
-
-        {
-          'benchmark' => benchmark_diff.title_version.transform_values { |x| x.map!(&:to_s) },
-          profile_key => diff.values.flatten,
-        }
       end
     end
   end

data/lib/abide_dev_utils/xccdf/parser/helpers.rb

@@ -4,99 +4,6 @@ module AbideDevUtils
   module XCCDF
     module Parser
       module Helpers
-        # Provides helper methods for working with XCCDF element children
-        module ElementChildren
-          def search_children
-            @search_children ||= SearchChildren.new(children)
-          end
-
-          # Implements methods that allow for searching an XCCDF Element's children
-          class SearchChildren
-            attr_reader :children
-
-            def initialize(children)
-              @children = children
-            end
-
-            def recursive_select_children(children_to_search = children, &block)
-              search_hits = []
-              children_to_search.each do |child|
-                found = yield child
-                if found
-                  search_hits << child
-                elsif child.respond_to?(:children)
-                  search_hits << recursive_select_children(child.children, &block)
-                end
-              end
-              search_hits.flatten.compact.uniq
-            end
-
-            def recursive_find_child(children_to_search = children, &block)
-              rescursive_select_children(children_to_search, &block).first
-            end
-
-            def find_children_that_respond_to(method, recurse: false)
-              return recursive_select_children { |child| child.respond_to?(method) } if recurse
-
-              children.select { |c| c.respond_to?(method.to_sym) }
-            end
-
-            def find_children_by_class(klass, recurse: false)
-              return recursive_select_children { |child| child.instance_of?(klass) } if recurse
-
-              children.select { |child| child.instance_of?(klass) }
-            end
-
-            def find_child_by_class(klass, recurse: false)
-              return recursive_find_child { |child| child.is_a?(klass) } if recurse
-
-              find_children_by_class(klass).first
-            end
-
-            def find_children_by_xpath(xpath, recurse: false)
-              return recursive_select_children { |child| child.xpath == xpath } if recurse
-
-              children.select { |child| child.xpath == xpath }
-            end
-
-            def find_child_by_xpath(xpath, recurse: false)
-              return recursive_find_child { |child| child.xpath == xpath } if recurse
-
-              find_children_by_xpath(xpath).first
-            end
-
-            def find_children_by_attribute(attribute, recurse: false)
-              pr = proc do |child|
-                next unless child.instance_of?(AbideDevUtils::XCCDF::Parser::Objects::AttributeValue)
-
-                child.attribute == attribute
-              end
-              return recursive_select_children(&pr) if recurse
-
-              children.select(&pr)
-            end
-
-            def find_child_by_attribute(attribute, recurse: false)
-              find_children_by_attribute(attribute, recurse: recurse).first
-            end
-
-            def find_children_by_attribute_value(attribute, value, recurse: false)
-              pr = proc do |child|
-                next unless child.instance_of?(AbideDevUtils::XCCDF::Parser::Objects::AttributeValue)
-
-                child.attribute == attribute && child.value == value
-              end
-              return recursive_select_children(&pr) if recurse
-
-              children.select(&pr)
-            end
-
-            def find_child_by_attribute_value(attribute, value, recurse: false)
-              find_children_by_attribute_value(attribute, value, recurse: recurse).first
-            end
-          end
-        end
-
         # Provides helper methods for working with XML xpaths
         module XPath
           def find_element