mux_tf 0.13.0 → 0.14.0

data/lib/mux_tf/plan_summary_handler.rb

@@ -5,26 +5,93 @@ module MuxTf
     extend TerraformHelpers
     include TerraformHelpers
     include PiotrbCliUtils::Util
+    include Coloring
 
-    def self.from_file(file)
-      data = data_from_file(file)
-      new data
-    end
+    class << self
+      def from_file(file)
+        data = data_from_file(file)
+        new data
+      end
 
-    def self.data_from_file(file)
-      if File.exist?("#{file}.json") && File.mtime("#{file}.json").to_f >= File.mtime(file).to_f
-        JSON.parse(File.read("#{file}.json"))
-      else
-        puts "Analyzing changes ..."
-        result = tf_show(file, json: true)
-        data = result.parsed_output
-        File.write("#{file}.json", JSON.dump(data))
-        data
+      def data_from_file(file)
+        if File.exist?("#{file}.json") && File.mtime("#{file}.json").to_f >= File.mtime(file).to_f
+          JSON.parse(File.read("#{file}.json"))
+        else
+          puts "Analyzing changes ..."
+          result = tf_show(file, json: true)
+          data = result.parsed_output
+          File.write("#{file}.json", JSON.dump(data))
+          data
+        end
+      end
+
+      def from_data(data)
+        new(data)
+      end
+
+      def color_for_action(action)
+        case action
+        when "create", "add"
+          :green
+        when "update", "change"
+          :yellow
+        when "delete", "remove"
+          :red
+        when "replace" # rubocop:disable Lint/DuplicateBranch
+          :red
+        when "replace (create before delete)" # rubocop:disable Lint/DuplicateBranch
+          :red
+        when "read"
+          :cyan
+        when "import" # rubocop:disable Lint/DuplicateBranch
+          :cyan
+        else
+          :reset
+        end
+      end
+
+      def symbol_for_action(action)
+        case action
+        when "create"
+          "+"
+        when "update"
+          "~"
+        when "delete"
+          "-"
+        when "replace"
+          "∓"
+        when "replace (create before delete)"
+          "±"
+        when "read"
+          ">"
+        else
+          action
+        end
+      end
+
+      def format_action(action)
+        color = color_for_action(action)
+        symbol = symbol_for_action(action)
+        pastel.decorate(symbol, color)
       end
-    end
 
-    def self.from_data(data)
-      new(data)
+      def self.format_address(address)
+        result = []
+        parts = ResourceTokenizer.tokenize(address)
+        parts.each_with_index do |(part_type, part_value), index|
+          case part_type
+          when :rt
+            result << "." if index.positive?
+            result << pastel.cyan(part_value)
+          when :rn
+            result << "."
+            result << part_value
+          when :ri
+            result << pastel.green(part_value)
+          end
+        end
+        result.join
+      end
     end
 
     def initialize(data) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -139,8 +206,8 @@ module MuxTf
         resource_summary[part[:action]] += 1
       end
       resource_pieces = resource_summary.map { |k, v|
-        color = color_for_action(k)
-        "#{Paint[v, :yellow]} to #{Paint[k, color]}"
+        color = self.class.color_for_action(k)
+        "#{pastel.yellow(v)} to #{pastel.decorate(k, color)}"
       }
 
       # outputs
@@ -150,15 +217,15 @@ module MuxTf
         output_summary[part[:action]] += 1
       end
       output_pieces = output_summary.map { |k, v|
-        color = color_for_action(k)
-        "#{Paint[v, :yellow]} to #{Paint[k, color]}"
+        color = self.class.color_for_action(k)
+        "#{pastel.yellow(v)} to #{pastel.decorate(k, color)}"
       }
 
       if resource_pieces.any? || output_pieces.any?
         [
           "Plan Summary:",
-          resource_pieces.any? ? resource_pieces.join(Paint[", ", :gray]) : nil,
-          output_pieces.any? ? "Outputs: #{output_pieces.join(Paint[', ', :gray])}" : nil
+          resource_pieces.any? ? resource_pieces.join(pastel.gray(", ")) : nil,
+          output_pieces.any? ? "Outputs: #{output_pieces.join(pastel.gray(', '))}" : nil
         ].compact.join(" ")
       else
         "Plan Summary: no changes"
@@ -168,7 +235,7 @@ module MuxTf
     def flat_summary
       result = []
       resource_parts.each do |part|
-        result << "[#{format_action(part[:action])}] #{format_address(part[:address])}"
+        result << "[#{self.class.format_action(part[:action])}] #{self.class.format_address(part[:address])}"
       end
       result
     end
@@ -176,11 +243,11 @@ module MuxTf
     def sensitive_summary(before_value, after_value)
       # before vs after
       if before_value && after_value
-        "(#{Paint['sensitive', :yellow]})"
+        "(#{pastel.yellow('sensitive')})"
       elsif before_value
-        "(#{Paint['-sensitive', :red]})"
+        "(#{pastel.red('-sensitive')})"
       elsif after_value
-        "(#{Paint['+sensitive', :cyan]})"
+        "(#{pastel.cyan('+sensitive')})"
       end
     end
 
@@ -188,8 +255,8 @@ module MuxTf
       result = []
       output_parts.each do |part|
         pieces = [
-          "[#{format_action(part[:action])}]",
-          format_address("output.#{part[:address]}"),
+          "[#{self.class.format_action(part[:action])}]",
+          self.class.format_address("output.#{part[:address]}"),
           part[:after_unknown] ? "(unknown)" : nil,
           sensitive_summary(*part[:sensitive])
         ].compact
@@ -198,7 +265,7 @@ module MuxTf
       result
     end
 
-    def nested_summary # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def nested_summary # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       result = []
       parts = resource_parts.deep_dup
       until parts.empty?
@@ -209,7 +276,7 @@ module MuxTf
                    else
                      ""
                    end
-          message = "[#{format_action(part[:action])}]#{indent} #{format_address(part[:address])}"
+          message = "[#{self.class.format_action(part[:action])}]#{indent} #{self.class.format_address(part[:address])}"
           message += " - (needs: #{part[:met_deps].join(', ')})" if part[:met_deps]
           result << message
           parts.each do |ipart|
@@ -230,7 +297,7 @@ module MuxTf
       prompt = TTY::Prompt.new
       result = prompt.multi_select("Update resources:", per_page: 99, echo: false) { |menu|
         resource_parts.each do |part|
-          label = "[#{format_action(part[:action])}] #{format_address(part[:address])}"
+          label = "[#{self.class.format_action(part[:action])}] #{self.class.format_address(part[:address])}"
           menu.choice label, part[:address]
         end
       }
@@ -258,7 +325,7 @@ module MuxTf
       when 2
         [:changes, meta]
       else
-        log Paint["terraform plan exited with an unknown exit code: #{exit_code}", :yellow]
+        log pastel.yellow("terraform plan exited with an unknown exit code: #{exit_code}")
         [:unknown, meta]
       end
     end
@@ -320,67 +387,5 @@ module MuxTf
         [resource, parent_address]
       end
     end
-
-    def color_for_action(action)
-      case action
-      when "create"
-        :green
-      when "update"
-        :yellow
-      when "delete"
-        :red
-      when "replace" # rubocop:disable Lint/DuplicateBranch
-        :red
-      when "replace (create before delete)" # rubocop:disable Lint/DuplicateBranch
-        :red
-      when "read"
-        :cyan
-      else
-        :reset
-      end
-    end
-
-    def symbol_for_action(action)
-      case action
-      when "create"
-        "+"
-      when "update"
-        "~"
-      when "delete"
-        "-"
-      when "replace"
-        "∓"
-      when "replace (create before delete)"
-        "±"
-      when "read"
-        ">"
-      else
-        action
-      end
-    end
-
-    def format_action(action)
-      color = color_for_action(action)
-      symbol = symbol_for_action(action)
-      Paint[symbol, color]
-    end
-
-    def format_address(address)
-      result = []
-      parts = ResourceTokenizer.tokenize(address)
-      parts.each_with_index do |(part_type, part_value), index|
-        case part_type
-        when :rt
-          result << "." if index.positive?
-          result << Paint[part_value, :cyan]
-        when :rn
-          result << "."
-          result << part_value
-        when :ri
-          result << Paint[part_value, :green]
-        end
-      end
-      result.join
-    end
   end
 end

data/lib/mux_tf/plan_utils.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+module MuxTf
+  class PlanUtils
+    extend TerraformHelpers
+    extend PiotrbCliUtils::Util
+    include Coloring
+
+    KNOWN_AFTER_APPLY = "(known after apply)"
+    SENSITIVE = "(sensitive value)"
+
+    class << self
+      def warning(message, binding_arg: binding)
+        stack = binding_arg.send(:caller)
+        stack_line = stack[0].match(/^(?<path>.+):(?<ln>\d+):in `(?<method>.+)'$/).named_captures
+        stack_line["path"].gsub!(MuxTf::ROOT, pastel.gray("{mux_tf}"))
+        msg = [
+          "#{pastel.orange('WARNING')}: #{message}",
+          "at #{pastel.cyan(stack_line['path'])}:#{pastel.white(stack_line['ln'])}:in `#{pastel.cyan(stack_line['method'])}'"
+        ]
+        puts msg.join(" - ")
+      end
+
+      def update_placeholders(dst, src, placeholder) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+        return unless src
+
+        case src
+        when Array
+          src.each_with_index do |v, index|
+            case v
+            when TrueClass
+              dst[index] = placeholder
+            when FalseClass
+              # do nothing
+            when Hash
+              dst[index] ||= {}
+              update_placeholders(dst[index], v, placeholder)
+            else
+              warning "Unknown array value (index: #{index}) for sensitive: #{v.inspect}"
+            end
+          end
+        when Hash
+          src.each do |key, value|
+            case value
+            when TrueClass
+              dst[key] = placeholder
+            when FalseClass
+              # do nothing
+            when Array
+              dst[key] ||= []
+              update_placeholders(dst[key], value, placeholder)
+            when Hash
+              dst[key] ||= {}
+              update_placeholders(dst[key], value, placeholder)
+            else
+              warning "Unknown value (key: #{key}) for sensitive: #{value.inspect}"
+            end
+          end
+        end
+      end
+
+      def tf_show_json_resource_diff(resource)
+        before = resource["change"]["before"] || {}
+        after = resource["change"]["after"] || {}
+
+        update_placeholders(after, resource["change"]["after_unknown"], KNOWN_AFTER_APPLY)
+
+        before = before.sort.to_h
+        after = after.sort.to_h
+
+        update_placeholders(before, resource["change"]["before_sensitive"], SENSITIVE)
+        update_placeholders(after, resource["change"]["after_sensitive"], SENSITIVE)
+
+        # hash_diff = HashDiff::Comparison.new(before, after)
+        # similarity: 0.0, numeric_tolerance: 1, array_path: true,
+        Hashdiff.diff(before, after, use_lcs: false)
+      end
+
+      def string_diff(value1, value2)
+        value1 = value1.split("\n")
+        value2 = value2.split("\n")
+
+        output = []
+        diffs = Diff::LCS.diff value1, value2
+        diffs.each do |diff|
+          hunk = Diff::LCS::Hunk.new(value1, value2, diff, 5, 0)
+          diff_lines = hunk.diff(:unified).split("\n")
+          # diff_lines.shift # remove the first line
+          output += diff_lines.map { |line| " #{line}" }
+        end
+        output
+      end
+
+      def valid_json?(value)
+        value.is_a?(String) && !!JSON.parse(value)
+      rescue JSON::ParserError
+        false
+      end
+
+      def valid_yaml?(value)
+        if value.is_a?(String)
+          parsed = YAML.safe_load(value)
+          parsed.is_a?(Hash) || parsed.is_a?(Array)
+        else
+          false
+        end
+      rescue Psych::SyntaxError => e
+        ap e
+        false
+      end
+
+      def colorize_symbol(symbol)
+        case symbol
+        when "+"
+          pastel.green(symbol)
+        when "~"
+          pastel.yellow(symbol)
+        else
+          warning "Unknown symbol: #{symbol.inspect}"
+          symbol
+        end
+      end
+
+      def wrap(text, prefix: "(", suffix: ")", newline: false, color: nil, indent: 0)
+        result = String.new
+        result << (color ? pastel.decorate(prefix, color) : prefix)
+        result << "\n" if newline
+        result << text.split("\n").map { |line|
+          "#{' ' * indent}#{line}"
+        }.join("\n")
+        result << "\n" if newline
+        result << (color ? pastel.decorate(suffix, color) : suffix)
+        result
+      end
+
+      def indent(text, indent: 2, first_line_indent: 0)
+        text.split("\n").map.with_index { |line, index|
+          if index.zero?
+            "#{' ' * first_line_indent}#{line}"
+          else
+            "#{' ' * indent}#{line}"
+          end
+        }.join("\n")
+      end
+
+      def in_display_representation(value) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize, Metrics/MethodLength
+        if valid_json?(value)
+          json_body = JSON.pretty_generate(JSON.parse(value))
+          wrap(json_body, prefix: "json(", suffix: ")", color: :gray)
+        elsif valid_yaml?(value)
+          yaml_body = YAML.dump(YAML.safe_load(value))
+          yaml_body.gsub!(/^---\n/, "")
+          wrap(yaml_body, prefix: "yaml(", suffix: ")", newline: true, color: :gray, indent: 2)
+        elsif [KNOWN_AFTER_APPLY, SENSITIVE].include?(value)
+          pastel.gray(value)
+        elsif value.is_a?(String) && value.include?("\n")
+          wrap(value, prefix: "<<- EOT", suffix: "EOT", newline: true, color: :gray)
+        # elsif value.is_a?(Array)
+        #   body = value.ai.rstrip
+        #   wrap(body, prefix: "", suffix: "", newline: false, color: :gray, indent: 2)
+        elsif value.is_a?(Array)
+          max_key = value.length.to_s.length
+          body = "["
+          value.each_with_index do |v, _index|
+            # body += "\n  #{in_display_representation(index).ljust(max_key)}: "
+            body += "\n"
+            body += indent(in_display_representation(v), indent: 2, first_line_indent: 2)
+            body += ","
+          end
+          body += "\n]"
+          body
+        elsif value.is_a?(Hash)
+          max_key = value.keys.map(&:length).max
+          body = "{"
+          value.each do |k, v|
+            body += "\n  #{in_display_representation(k).ljust(max_key)}: "
+            body += indent(in_display_representation(v), indent: 2, first_line_indent: 0)
+            body += ","
+          end
+          body += "\n}"
+          body
+        else
+          value.inspect
+        end
+      end
+
+      def format_value_diff(mode, value_arg)
+        case mode
+        when :both
+          vleft = in_display_representation(value_arg[0])
+          vright = in_display_representation(value_arg[1])
+          if [vleft, vright].any? { |v| v.is_a?(String) && v.include?("\n") }
+            if pastel.strip(vright) == KNOWN_AFTER_APPLY
+              "#{vleft} -> #{vright}".split("\n")
+            else
+              string_diff(pastel.strip(vleft), pastel.strip(vright))
+            end
+          else
+            "#{vleft} -> #{vright}".split("\n")
+          end
+        when :right
+          vright = in_display_representation(value_arg[1])
+          vright.split("\n")
+        when :left, :first
+          vleft = in_display_representation(value_arg[0])
+          vleft.split("\n")
+        end
+      end
+
+      def format_value(change)
+        symbol, _key, *value_arg = change
+
+        mode = :both
+        case symbol
+        when "+", "-"
+          mode = :first
+        when "~"
+          mode = :both
+        else
+          warning "Unknown symbol: #{symbol.inspect}"
+        end
+
+        format_value_diff(mode, value_arg)
+      end
+
+      # def format_value(value_arg, symbol)
+      #   case value_arg
+      #   when Array
+      #     mode = :both
+      #     case symbol
+      #     when "+"
+      #       mode = :right
+      #     when "~"
+      #       mode = :both
+      #     else
+      #       warning "Unknown symbol: #{symbol.inspect}"
+      #     end
+
+      #     format_value_diff(mode, value_arg)
+      #   when Hash
+      #     if value_arg.keys.all? { |k| k.is_a?(Integer) }
+      #       # assuming its a hash notation of array keys changes
+      #       value_arg.keys.sort.map { |k| "[#{k}] #{format_value(value_arg[k], symbol)[0]}" }
+      #     else
+      #       [value_arg.inspect]
+      #     end
+      #   else
+      #     [value_arg.inspect]
+      #   end
+      # end
+
+      def get_pretty_action_and_symbol(actions)
+        case actions
+        when ["update"]
+          pretty_action = "updated in-place"
+          symbol = "~"
+        when ["create"]
+          pretty_action = "created"
+          symbol = "+"
+        else
+          warning "Unknown action: #{actions.inspect}"
+          pretty_action = actions.inspect
+          symbol = "?"
+        end
+
+        [pretty_action, symbol]
+      end
+
+      # Example
+      #   # kubectl_manifest.crossplane-provider-controller-config["aws-ecr"] will be updated in-place
+      #   ~ resource "kubectl_manifest" "crossplane-provider-controller-config" {
+      #         id                      = "/apis/pkg.crossplane.io/v1alpha1/controllerconfigs/aws-ecr-config"
+      #         name                    = "aws-ecr-config"
+      #       ~ yaml_body               = (sensitive value)
+      #       ~ yaml_body_parsed        = <<-EOT
+      #             apiVersion: pkg.crossplane.io/v1alpha1
+      #             kind: ControllerConfig
+      #             metadata:
+      #               annotations:
+      #           -     eks.amazonaws.com/role-arn: <AWS_PROVIDER_ARN> <<- irsa
+      #           +     eks.amazonaws.com/role-arn: arn:aws:iam::852088082597:role/admin-crossplane-provider-aws-ecr
+      #               name: aws-ecr-config
+      #             spec:
+      #               podSecurityContext:
+      #                 fsGroup: 2000
+      #         EOT
+      #         # (12 unchanged attributes hidden)
+      #     }
+      def tf_show_json_resource(resource) # rubocop:disable Metrics/AbcSize
+        pretty_action, symbol = get_pretty_action_and_symbol(resource["change"]["actions"])
+
+        output = []
+
+        global_indent = " " * 2
+
+        output << ""
+        output << "#{global_indent}#{pastel.bold("# #{resource['address']}")} will be #{pretty_action}"
+        output << "#{global_indent}#{colorize_symbol(symbol)} resource \"#{resource['type']}\" \"#{resource['name']}\" {"
+        diff = tf_show_json_resource_diff(resource)
+        max_diff_key_length = diff.map { |change| change[1].length }.max
+        diff.each do |change|
+          change_symbol, key, *_values = change
+          prefix = format("#{global_indent}  #{colorize_symbol(change_symbol)} %s = ", key.ljust(max_diff_key_length))
+          blank_prefix = " " * pastel.strip(prefix).length
+          format_value(change).each_with_index do |line, index|
+            output << if index.zero?
+                        "#{prefix}#{line}"
+                      else
+                        "#{blank_prefix}#{line}"
+                      end
+          end
+        end
+        # max_diff_key_length = diff.keys.map(&:length).max
+        # diff.each do |key, value|
+        #   prefix = format("#{global_indent}  #{colorize_symbol(symbol)} %s = ", key.ljust(max_diff_key_length))
+        #   blank_prefix = " " * pastel.strip(prefix).length
+        #   format_value(value, symbol).each_with_index do |line, index|
+        #     output << if index.zero?
+        #                 "#{prefix}#{line}"
+        #               else
+        #                 "#{blank_prefix}#{line}"
+        #               end
+        #   end
+        # end
+        output << "#{global_indent}}"
+
+        output.join("\n")
+      end
+
+      def text_version_of_plan_show(plan_filename)
+        result = tf_show(plan_filename, capture: true, json: true)
+        data = result.parsed_output
+
+        # Plan: 0 to add, 1 to change, 0 to destroy.
+
+        output = []
+
+        output << "Terraform will perform the following actions:"
+
+        if data["resource_drift"]
+          output << ""
+          output << "Resource Drift:"
+          data["resource_drift"].each do |resource|
+            output << tf_show_json_resource(resource)
+          end
+        end
+
+        if data["resource_changes"]
+          output << ""
+          output << "Resource Changes:"
+          data["resource_changes"].each do |resource|
+            output << tf_show_json_resource(resource) if resource["change"]["actions"] != ["no-op"]
+          end
+        end
+
+        output.join("\n")
+      end
+    end
+  end
+end