octocatalog-diff 0.6.1 → 1.0.0

data/lib/octocatalog-diff/api/v1/override.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module OctocatalogDiff
+  module API
+    module V1
+      # Sets up the override of a fact or ENC parameter during catalog compilation.
+      class Override
+        # Accessors
+        attr_reader :key, :value
+
+        # Constructor: Accepts a key and value.
+        # @param input [Hash] Must contain :key and :value
+        def initialize(input)
+          @key = input.fetch(:key)
+          @value = parsed_value(input.fetch(:value))
+        end
+
+        # Initialize from a parsed command line
+        # @param input [String] Command line parameter
+        # @return [OctocatalogDiff::API::V1::Override] Initialized object
+        def self.create_from_input(input, key = nil)
+          # Normally the input will be a string in the format key=(data type)value where the data
+          # type is optional and the parentheses are literal. Example:
+          #   foo=1            (auto-determine data type - in this case it would be a fixnum)
+          #   foo=(fixnum)1    (will be a fixnum)
+          #   foo=(string)1    (will be '1' the string)
+          # If input is not a string, we can still construct the object if the key is given.
+          # That input would come directly from code and not from the command line, since inputs
+          # from the command line are always strings.
+          if key.nil? && input.is_a?(String)
+            unless input.include?('=')
+              raise ArgumentError, "Fact override '#{input}' is not in 'key=(data type)value' format"
+            end
+            k, v = input.strip.split('=', 2).map(&:strip)
+            new(key: k, value: v)
+          elsif key.nil?
+            message = "Define a key when the input is not a string (#{input.class} => #{input.inspect})"
+            raise ArgumentError, message
+          else
+            new(key: key, value: input)
+          end
+        end
+
+        private
+
+        # Guess the datatype from a particular input
+        # @param input [String] Input in string format
+        # @return [?] Output in appropriate format
+        def parsed_value(input)
+          # If data type is explicitly given
+          if input =~ /^\((\w+)\)(.*)$/m
+            datatype = Regexp.last_match(1)
+            value = Regexp.last_match(2)
+            return convert_to_data_type(datatype.downcase, value)
+          end
+
+          # Guess data type
+          return input.to_i if input =~ /^-?\d+$/
+          return input.to_f if input =~ /^-?\d*\.\d+$/
+          return true if input.casecmp('true').zero?
+          return false if input.casecmp('false').zero?
+          input
+        end
+
+        # Handle data type that's explicitly given
+        # @param datatype [String] Data type (as a string)
+        # @param value [String] Value given
+        # @return [?] Value converted to specified data type
+        def convert_to_data_type(datatype, value)
+          return value if datatype == 'string'
+          return parse_json(value) if datatype == 'json'
+          return nil if datatype == 'nil'
+          if datatype == 'fixnum'
+            return Regexp.last_match(1).to_i if value =~ /^(-?\d+)$/
+            raise ArgumentError, "Illegal fixnum '#{value}'"
+          end
+          if datatype == 'float'
+            return Regexp.last_match(1).to_f if value =~ /^(-?\d*\.\d+)$/
+            return Regexp.last_match(1).to_f if value =~ /^(-?\d+)$/
+            raise ArgumentError, "Illegal float '#{value}'"
+          end
+          if datatype == 'boolean'
+            return true if value.casecmp('true').zero?
+            return false if value.casecmp('false').zero?
+            raise ArgumentError, "Illegal boolean '#{value}'"
+          end
+          raise ArgumentError, "Unknown data type '#{datatype}'"
+        end
+
+        # Parse JSON value
+        # @param input [String] Input, hopefully in JSON format
+        # @return [?] Output data structure
+        def parse_json(input)
+          JSON.parse(input)
+        rescue JSON::ParserError => exc
+          raise JSON::ParserError, "Failed to parse JSON: input=#{input} error=#{exc}"
+        end
+      end
+    end
+  end
+end

data/lib/octocatalog-diff/catalog-diff/differ.rb

@@ -7,6 +7,7 @@ require 'set'
 require 'stringio'
 
 require_relative '../catalog'
+require_relative '../errors'
 require_relative 'filter'
 
 module OctocatalogDiff
@@ -55,14 +56,12 @@ module OctocatalogDiff
     # The heavy lifting is still handled by 'hashdiff' but we're pre-simplifying the input and post-processing
     # the output to make it easier to deal with later.
     class Differ
-      # This class is to distinguish handled errors from unhandled ones, for spec testing.
-      class DifferError < RuntimeError
-      end
-
       # Constructor
       # @param catalog1_in [OctocatalogDiff::Catalog] First catalog to compare
       # @param catalog2_in [OctocatalogDiff::Catalog] Second catalog to compare
       def initialize(opts, catalog1_in, catalog2_in)
+        @catalog1_raw = catalog1_in
+        @catalog2_raw = catalog2_in
         @catalog1 = catalog_resources(catalog1_in, 'First catalog')
         @catalog2 = catalog_resources(catalog2_in, 'Second catalog')
         @logger = opts.fetch(:logger, Logger.new(StringIO.new))
@@ -105,6 +104,32 @@ module OctocatalogDiff
         self
       end
 
+      # Handle --ignore-tags option, the ability to tag resources within modules/manifests and
+      # have catalog-diff ignore them.
+      def ignore_tags
+        return unless @opts[:ignore_tags].is_a?(Array) && @opts[:ignore_tags].any?
+
+        # Go through the "to" catalog and identify any resources that have been tagged with one or more
+        # specified "ignore tags." Add any such items to the ignore list. The 'to' catalog has the authoritative
+        # list of dynamic ignores.
+        @catalog2_raw.resources.each do |resource|
+          next unless tagged_for_ignore?(resource)
+          ignore(type: resource['type'], title: resource['title'])
+          @logger.debug "Ignoring type='#{resource['type']}', title='#{resource['title']}' based on tag in to-catalog"
+        end
+
+        # Go through the "from" catalog and identify any resources that have been tagged with one or more
+        # specified "ignore tags." Only mark the resources for ignoring if they do not appear in the 'to'
+        # catalog, thereby allowing the 'to' catalog to be the authoritative ignore list. This allows deleted
+        # items that were previously ignored to continue to be ignored.
+        @catalog1_raw.resources.each do |resource|
+          next if @catalog2_raw.resource(type: resource['type'], title: resource['title'])
+          next unless tagged_for_ignore?(resource)
+          ignore(type: resource['type'], title: resource['title'])
+          @logger.debug "Ignoring type='#{resource['type']}', title='#{resource['title']}' based on tag in from-catalog"
+        end
+      end
+
       # Return catalog1 with filter_and_cleanups applied.
       # This is in the public section because it's called from spec tests as well
       # as being called internally.
@@ -123,6 +148,20 @@ module OctocatalogDiff
 
       private
 
+      # Determine if a resource is tagged with any ignore-tag.
+      # @param resource [Hash] The resource
+      # @return [Boolean] true if tagged for ignore, false if not
+      def tagged_for_ignore?(resource)
+        return false unless @opts[:ignore_tags].is_a?(Array)
+        return false unless resource.key?('tags') && resource['tags'].is_a?(Array)
+        @opts[:ignore_tags].each do |tag|
+          # tag_with_type will be like: 'ignored_catalog_diff__mymodule__mytype'
+          tag_with_type = [tag, resource['type'].downcase.gsub(/\W/, '_')].join('__')
+          return true if resource['tags'].include?(tag) || resource['tags'].include?(tag_with_type)
+        end
+        false
+      end
+
       # Actually perform the catalog diff. This implements the 3-part algorithm described in the
       # comment block at the top of this file.
       def catdiff
@@ -150,18 +189,31 @@ module OctocatalogDiff
         # Remove resources that have been explicitly ignored
         filter_diffs_for_ignored_items(result)
 
-        # If a file has ensure => absent, there are certain parameters that don't matter anymore. Filter
-        # out any such parameters from the result array.
-        filter_diffs_for_absent_files(result) if @opts[:suppress_absent_file_details]
+        # Legacy options which are now filters
+        @opts[:filters] ||= []
+        add_element_to_array(@opts[:filters], 'CompilationDir')
+        add_element_to_array(@opts[:filters], 'AbsentFile') if @opts[:suppress_absent_file_details]
 
         # Apply any additional pluggable filters.
-        OctocatalogDiff::CatalogDiff::Filter.apply_filters(result, @opts[:filters])
+        filter_opts = {
+          logger: @logger,
+          from_compilation_dir: @catalog1_raw.compilation_dir,
+          to_compilation_dir: @catalog2_raw.compilation_dir
+        }
+        OctocatalogDiff::CatalogDiff::Filter.apply_filters(result, @opts[:filters], filter_opts) if @opts[:filters].any?
 
         # That's it!
         @logger.debug "Exiting catdiff; change count: #{result.size}"
         result
       end
 
+      # Add an element to an array if it doesn't already exist in that array
+      # @param array_in [Array] Array to have element added (**mutated** by this method)
+      # @param element [?] Element to add
+      def add_element_to_array(array_in, element)
+        array_in << element unless array_in.include?(element)
+      end
+
       # Filter the differences for any items that were ignored, by some combination of type, title, and
       # attribute. This modifies the array itself by selecting only items that do not meet the ignored
       # filter.
@@ -169,43 +221,6 @@ module OctocatalogDiff
         result.reject! { |item| ignored?(item) }
       end
 
-      # If a file has ensure => absent, there are certain parameters that don't matter anymore. Filter
-      # out any such parameters from the result array.
-      # @param result [Array] Diff result list (modified by this method)
-      def filter_diffs_for_absent_files(result)
-        @logger.debug "Entering filter_diffs_for_absent_files with #{result.size} diffs"
-
-        # Scan for files in the result that are file resources with ensure => absent.
-        absent_files = Set.new
-        result.each do |diff|
-          next unless diff[0] == '~' || diff[0] == '!'
-          next unless diff[1] =~ /^File\f([^\f]+)\fparameters\fensure$/
-          next unless ['absent', 'false', false].include?(diff[3])
-          absent_files.add Regexp.last_match(1)
-        end
-
-        # If there are any absent files, remove all diffs referencing that file, except for
-        # the change to 'ensure'.
-        if absent_files.any?
-          keep = %w(ensure backup force provider)
-          result.map! do |diff|
-            if (diff[0] == '!' || diff[0] == '~') && diff[1] =~ /^File\f(.+)\fparameters\f(.+)$/
-              if absent_files.include?(Regexp.last_match(1)) && !keep.include?(Regexp.last_match(2))
-                @logger.debug "Removing file=#{Regexp.last_match(1)} parameter=#{Regexp.last_match(2)} for absent file"
-                nil
-              else
-                diff
-              end
-            else
-              diff
-            end
-          end
-          result.compact!
-        end
-
-        @logger.debug "Exiting filter_diffs_for_absent_files with #{result.size} diffs"
-      end
-
       # Pre-processing of a catalog.
       # - Remove 'before' and 'require' from parameters
       # - Sort 'tags' array, or remove the tags array if tags are being ignored
@@ -368,7 +383,11 @@ module OctocatalogDiff
         rule = rule_in.dup
 
         # Type matches?
-        return false unless rule[:type] == '*' || rule[:type].casecmp(hsh[:type]).zero?
+        if rule[:type].is_a?(Regexp)
+          return false unless hsh[:type].match(rule[:type])
+        elsif rule[:type].is_a?(String)
+          return false unless rule[:type] == '*' || rule[:type].casecmp(hsh[:type]).zero?
+        end
 
         # Title matches? (Support regexp and string)
         if rule[:title].is_a?(Regexp)
@@ -594,7 +613,7 @@ module OctocatalogDiff
       # @return [Hash] Internal simplified hash object
       def catalog_resources(catalog_in, name = 'Passed catalog')
         return catalog_in.resources if catalog_in.is_a?(OctocatalogDiff::Catalog)
-        raise DifferError, "#{name} is not a valid catalog (input datatype: #{catalog_in.class})"
+        raise OctocatalogDiff::Errors::DifferError, "#{name} is not a valid catalog (input datatype: #{catalog_in.class})"
       end
 
       # Turn array of resources into a hash by serialized keys. For consistency with 'hashdiff'

data/lib/octocatalog-diff/catalog-diff/display.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require_relative '../api/v1/diff'
 require_relative 'differ'
 require_relative 'display/json'
+require_relative 'display/legacy_json'
 require_relative 'display/text'
 
 module OctocatalogDiff
@@ -21,8 +23,9 @@ module OctocatalogDiff
       # @param logger [Logger] Logger object
       # @return [String] Text output for provided diff
       def self.output(diff_in, options = {}, logger = nil)
-        diff = diff_in.is_a?(OctocatalogDiff::CatalogDiff::Differ) ? diff_in.diff : diff_in
-        raise ArgumentError, "text_output requires Array<Diff results>; passed in #{diff_in.class}" unless diff.is_a?(Array)
+        diff_x = diff_in.is_a?(OctocatalogDiff::CatalogDiff::Differ) ? diff_in.diff : diff_in
+        raise ArgumentError, "text_output requires Array<Diff results>; passed in #{diff_in.class}" unless diff_x.is_a?(Array)
+        diff = diff_x.map { |x| OctocatalogDiff::API::V1::Diff.factory(x) }
 
         # req_format means 'requested format' because 'format' has a built-in meaning to Ruby
         req_format = options.fetch(:format, :color_text)
@@ -41,6 +44,9 @@ module OctocatalogDiff
         when :json
           logger.debug 'Generating JSON output' if logger
           OctocatalogDiff::CatalogDiff::Display::Json.generate(diff, opts, logger)
+        when :legacy_json
+          logger.debug 'Generating Legacy JSON output' if logger
+          OctocatalogDiff::CatalogDiff::Display::LegacyJson.generate(diff, opts, logger)
         when :text
           logger.debug 'Generating non-colored text output' if logger
           OctocatalogDiff::CatalogDiff::Display::Text.generate(diff, opts.merge(color: false), logger)

data/lib/octocatalog-diff/catalog-diff/display/json.rb

@@ -7,7 +7,8 @@ require 'json'
 module OctocatalogDiff
   module CatalogDiff
     class Display
-      # Display the output from a diff in JSON format.
+      # Display the output from a diff in JSON format. This is the new format, used in octocatalog-diff
+      # 1.x, where each diff is represented by an hash with named keys.
       class Json < OctocatalogDiff::CatalogDiff::Display
         # Generate JSON representation of the 'diff' suitable for further analysis.
         # @param diff [Array<Diff results>] The diff which *must* be in this format
@@ -16,7 +17,7 @@ module OctocatalogDiff
         # @param _logger [Logger] Not used here
         def self.generate(diff, options = {}, _logger = nil)
           result = {
-            'diff' => diff
+            'diff' => diff.map(&:to_h_with_string_keys)
           }
           result['header'] = options[:header] unless options[:header].nil?
           result.to_json

data/lib/octocatalog-diff/catalog-diff/display/legacy_json.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../display'
+
+require 'json'
+
+module OctocatalogDiff
+  module CatalogDiff
+    class Display
+      # Display the output from a diff in JSON format. This is the legacy format, used in octocatalog-diff
+      # 0.x, where each diff is represented by an array.
+      class LegacyJson < OctocatalogDiff::CatalogDiff::Display
+        # Generate JSON representation of the 'diff' suitable for further analysis.
+        # @param diff [Array<Diff results>] The diff which *must* be in this format
+        # @param options [Hash] Options which are:
+        #           - :header => [String] Header to print; no header is printed if not specified
+        # @param _logger [Logger] Not used here
+        def self.generate(diff, options = {}, _logger = nil)
+          result = {
+            'diff' => diff.map(&:raw)
+          }
+          result['header'] = options[:header] unless options[:header].nil?
+          result.to_json
+        end
+      end
+    end
+  end
+end

data/lib/octocatalog-diff/catalog-diff/display/text.rb

@@ -257,13 +257,67 @@ module OctocatalogDiff
         # @param depth [Fixnum] Depth, for correct indentation
         # @return Array<String> Displayable result
         def self.diff_two_strings_with_diffy(string1, string2, depth)
-          # prevent 'No newline at end of file' for single line strings
-          string1 += "\n" unless string1 =~ /\n/
-          string2 += "\n" unless string2 =~ /\n/
+          # Single line strings?
+          if single_lines?(string1, string2)
+            string1, string2 = add_trailing_newlines(string1, string2)
+            diff = Diffy::Diff.new(string1, string2, context: 2, include_diff_info: false).to_s.split("\n")
+            return diff.map { |x| left_pad(2 * depth + 2, make_trailing_whitespace_visible(adjust_position_of_plus_minus(x))) }
+          end
+
+          # Multiple line strings
+          string1, string2 = add_trailing_newlines(string1, string2)
           diff = Diffy::Diff.new(string1, string2, context: 2, include_diff_info: true).to_s.split("\n")
           diff.shift # Remove first line of diff info (filename that makes no sense)
           diff.shift # Remove second line of diff info (filename that makes no sense)
-          diff.map { |x| left_pad(2 * depth + 2, x) }
+          diff.map { |x| left_pad(2 * depth + 2, make_trailing_whitespace_visible(x)) }
+        end
+
+        # Determine if two incoming strings are single lines. Returns true if both
+        # incoming strings are single lines, false otherwise.
+        # @param string_1 [String] First string
+        # @param string_2 [String] Second string
+        # @return [Boolean] Whether both incoming strings are single lines
+        def self.single_lines?(string_1, string_2)
+          string_1.strip !~ /\n/ && string_2.strip !~ /\n/
+        end
+
+        # Add "\n" to the end of both strings, only if both strings are lacking it.
+        # This prevents "\" for single string comparison.
+        # @param string_1 [String] First string
+        # @param string_2 [String] Second string
+        # @return [Array<String>] Adjusted string_1, string_2
+        def self.add_trailing_newlines(string_1, string_2)
+          return [string_1, string_2] unless string_1 !~ /\n\Z/ && string_2 !~ /\n\Z/
+          [string_1 + "\n", string_2 + "\n"]
+        end
+
+        # Adjust the space after of the `-` / `+` in the diff for single line diffs.
+        # Diffy prints diffs with no space between the `-` / `+` in the text, but for
+        # single lines it's easier to read with that space added.
+        # @param string_in [String] Input string, which is a line of a diff from diffy
+        # @return [String] Modified string
+        def self.adjust_position_of_plus_minus(string_in)
+          string_in.sub(/\A(\e\[\d+m)?([\-\+])/, '\1\2 ')
+        end
+
+        # Convert trailing whitespace to underscore for display purposes. Also convert special
+        # whitespace (\r, \n, \t, ...) to character representation.
+        # @param string_in [String] Input string, which might contain trailing whitespace
+        # @return [String] Modified string
+        def self.make_trailing_whitespace_visible(string_in)
+          return string_in unless string_in =~ /\A((?:.|\n)*?)(\s+)(\e\[0m)?\Z/
+          beginning = Regexp.last_match(1)
+          trailing_space = Regexp.last_match(2)
+          end_escape = Regexp.last_match(3)
+
+          # Trailing space adjustment for line endings
+          trailing_space.gsub! "\n", '\n'
+          trailing_space.gsub! "\r", '\r'
+          trailing_space.gsub! "\t", '\t'
+          trailing_space.gsub! "\f", '\f'
+          trailing_space.tr! ' ', '_'
+
+          [beginning, trailing_space, end_escape].join('')
         end
 
         # Get the diff of two hashes. Call the 'diffy' gem for this.
@@ -319,9 +373,9 @@ module OctocatalogDiff
             if nested && obj[:old].is_a?(Hash) && obj[:new].is_a?(Hash)
               # Nested hashes will be stringified and then use 'diffy'
               result.concat diff_two_hashes_with_diffy(depth: depth, hash1: obj[:old], hash2: obj[:new])
-            elsif obj[:old].is_a?(String) && obj[:new].is_a?(String) && (obj[:old] =~ /\n/ || obj[:new] =~ /\n/)
-              # Multi-line strings will be split and then use 'diffy' to mimic the
-              # output seen when using "diff" on the command line
+            elsif obj[:old].is_a?(String) && obj[:new].is_a?(String)
+              # Strings will use 'diffy' to mimic the output seen when using
+              # "diff" on the command line.
               result.concat diff_two_strings_with_diffy(obj[:old], obj[:new], depth)
             else
               # Stuff we don't recognize will be converted to a string and printed
@@ -395,8 +449,9 @@ module OctocatalogDiff
               else
                 # Adjust the display and return modified object
                 msg = "Adjust display for #{diff_obj[1].gsub(/\f/, '::')}: " \
-                      "#{diff_obj[2].inspect} -> #{x2}; "\
-                      "#{diff_obj[3].inspect} -> #{x3}"
+                      "old=#{x2.inspect} new=#{x3.inspect} "\
+                      "(extra debugging: #{diff_obj[2].inspect} -> #{x2}; "\
+                      "#{diff_obj[3].inspect} -> #{x3})"
                 logger.debug(msg) if logger
                 diff_obj[2] = x2
                 diff_obj[3] = x3