mux_tf 0.15.0 → 0.17.0

data/lib/mux_tf/plan_summary_handler.rb

@@ -17,7 +17,7 @@ module MuxTf
         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 ..."
+          puts "Analyzing changes ... #{file}"
           result = tf_show(file, json: true)
           data = result.parsed_output
           File.write("#{file}.json", JSON.dump(data))
@@ -33,7 +33,7 @@ module MuxTf
         case action
         when "create", "add"
           :green
-        when "update", "change"
+        when "update", "change", "import-update"
           :yellow
         when "delete", "remove"
           :red
@@ -43,7 +43,7 @@ module MuxTf
           :red
         when "read"
           :cyan
-        when "import" # rubocop:disable Lint/DuplicateBranch
+        when "import", "forget" # rubocop:disable Lint/DuplicateBranch
           :cyan
         else
           :reset
@@ -64,6 +64,12 @@ module MuxTf
           "±"
         when "read"
           ">"
+        when "import"
+          "→"
+        when "import-update"
+          "↗︎"
+        when "forget"
+          "↺"
         else
           action
         end
@@ -94,7 +100,8 @@ module MuxTf
       end
     end
 
-    def initialize(data) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def initialize(data)
+      @data = data
       @parts = []
 
       data["output_changes"]&.each do |output_name, v|
@@ -138,6 +145,14 @@ module MuxTf
         case v["change"]["actions"]
         when ["no-op"]
           # do nothing
+          if v["change"]["importing"]
+            parts << {
+              type: "resource",
+              action: "import",
+              address: v["address"],
+              deps: find_deps(data, v["address"])
+            }
+          end
         when ["create"]
           parts << {
             type: "resource",
@@ -146,9 +161,10 @@ module MuxTf
             deps: find_deps(data, v["address"])
           }
         when ["update"]
+          # ap [v["change"]["actions"], v["change"]["importing"]]
           parts << {
             type: "resource",
-            action: "update",
+            action: v["change"]["importing"] ? "import-update" : "update",
             address: v["address"],
             deps: find_deps(data, v["address"])
           }
@@ -180,6 +196,13 @@ module MuxTf
             address: v["address"],
             deps: find_deps(data, v["address"])
           }
+        when ["forget"]
+          parts << {
+            type: "resource",
+            action: "forget",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
         else
           puts "[??] #{v['address']}"
           puts "UNKNOWN RESOURCE ACTIONS: #{v['change']['actions'].inspect}"
@@ -198,7 +221,7 @@ module MuxTf
       parts.select { |part| part[:type] == "output" }
     end
 
-    def summary # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def summary
       # resources
       resource_summary = {}
       resource_parts.each do |part|
@@ -233,11 +256,9 @@ module MuxTf
     end
 
     def flat_summary
-      result = []
-      resource_parts.each do |part|
-        result << "[#{self.class.format_action(part[:action])}] #{self.class.format_address(part[:address])}"
+      resource_parts.map do |part|
+        "[#{self.class.format_action(part[:action])}] #{self.class.format_address(part[:address])}"
       end
-      result
     end
 
     def sensitive_summary(before_value, after_value)
@@ -265,7 +286,20 @@ module MuxTf
       result
     end
 
-    def nested_summary # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def simple_summary(&printer)
+      printer = method(:puts) if printer.nil?
+
+      flat_summary.each do |line|
+        printer.call line
+      end
+      output_summary.each do |line|
+        printer.call line
+      end
+      printer.call ""
+      printer.call summary
+    end
+
+    def nested_summary
       result = []
       parts = resource_parts.deep_dup
       until parts.empty?
@@ -305,31 +339,18 @@ module MuxTf
       if result.empty?
         throw :abort, "nothing selected"
       else
-        log "Re-running apply with the selected resources ..."
-        MuxTf::Cli::Current.run_plan(targets: result)
+        result
       end
     end
 
+    def plan_text_output
+      PlanUtils.text_version_of_plan_show_from_data(@data)
+    end
+
     private
 
     attr_reader :parts
 
-    def create_plan(filename, targets: [])
-      log "Preparing Plan ...", depth: 1
-      exit_code, meta = PlanFormatter.pretty_plan(filename, targets: targets)
-      case exit_code
-      when 0
-        [:ok, meta]
-      when 1
-        [:error, meta]
-      when 2
-        [:changes, meta]
-      else
-        log pastel.yellow("terraform plan exited with an unknown exit code: #{exit_code}")
-        [:unknown, meta]
-      end
-    end
-
     def prune_unchanged_deps(_parts)
       valid_addresses = resource_parts.map { |part| part[:address] }
 
@@ -338,7 +359,7 @@ module MuxTf
       end
     end
 
-    def find_deps(data, address) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def find_deps(data, address)
       result = []
 
       m = address.match(/\[(.+)\]$/)
@@ -358,7 +379,7 @@ module MuxTf
       resource, parent_address = find_config(data["configuration"], "root_module", address, [])
       if resource
         deps = []
-        resource["expressions"]&.each do |_k, v|
+        resource["expressions"]&.each_value do |v|
           deps << v["references"] if v.is_a?(Hash) && v["references"]
         end
         result += deps.map { |s| (parent_address + [s]).join(".") }

data/lib/mux_tf/plan_utils.rb

@@ -12,16 +12,21 @@ module MuxTf
     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'])}'"
-        ]
+        stack_match = stack[0].match(/^(?<path>.+):(?<ln>\d+):in [`'](?<method>.+)'$/)
+        msg = []
+        if stack_match
+          stack_line = stack_match.named_captures
+          stack_line["path"].gsub!(MuxTf::ROOT, pastel.gray("{mux_tf}"))
+          msg << "#{pastel.orange('WARNING')}: #{message}"
+          msg << "at #{pastel.cyan(stack_line['path'])}:#{pastel.white(stack_line['ln'])}:in `#{pastel.cyan(stack_line['method'])}'"
+        else
+          p [stack_match, stack[0]]
+          msg << "#{pastel.orange('WARNING')}: #{message}"
+        end
         puts msg.join(" - ")
       end
 
-      def update_placeholders(dst, src, placeholder) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+      def update_placeholders(dst, src, placeholder)
         return unless src
 
         case src
@@ -104,8 +109,11 @@ module MuxTf
         else
           false
         end
-      rescue Psych::SyntaxError => e
-        ap e
+      rescue Psych::DisallowedClass => _e
+        # ap e
+        false
+      rescue Psych::SyntaxError => _e # rubocop:disable Lint/DuplicateBranch
+        # ap e
         false
       end
 
@@ -115,6 +123,16 @@ module MuxTf
           pastel.green(symbol)
         when "~"
           pastel.yellow(symbol)
+        when "-"
+          pastel.red(symbol)
+        when "?"
+          pastel.orange(symbol)
+        when "±"
+          pastel.bright_red(symbol)
+        when ">"
+          pastel.blue(symbol)
+        when " "
+          symbol
         else
           warning "Unknown symbol: #{symbol.inspect}"
           symbol
@@ -143,7 +161,7 @@ module MuxTf
         }.join("\n")
       end
 
-      def in_display_representation(value) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize, Metrics/MethodLength
+      def in_display_representation(value)
         if valid_json?(value)
           json_body = JSON.pretty_generate(JSON.parse(value))
           wrap(json_body, prefix: "json(", suffix: ")", color: :gray)
@@ -223,40 +241,26 @@ module MuxTf
         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 ["delete"]
+          pretty_action = "delete"
+          symbol = "-"
         when ["update"]
           pretty_action = "updated in-place"
           symbol = "~"
         when ["create"]
           pretty_action = "created"
           symbol = "+"
+        when %w[delete create]
+          pretty_action = "replaced (delete first)"
+          symbol = "±"
+        when ["read"]
+          pretty_action = "read"
+          symbol = ">"
+        when ["no-op"]
+          pretty_action = "no-op"
+          symbol = " "
         else
           warning "Unknown action: #{actions.inspect}"
           pretty_action = actions.inspect
@@ -286,7 +290,7 @@ module MuxTf
       #         EOT
       #         # (12 unchanged attributes hidden)
       #     }
-      def tf_show_json_resource(resource) # rubocop:disable Metrics/AbcSize
+      def tf_show_json_resource(resource)
         pretty_action, symbol = get_pretty_action_and_symbol(resource["change"]["actions"])
 
         output = []
@@ -295,44 +299,188 @@ module MuxTf
 
         output << ""
         output << "#{global_indent}#{pastel.bold("# #{resource['address']}")} will be #{pretty_action}"
+        output << "#{global_indent}  >> #{action_reason_to_text(resource['action_reason'])}" if resource["action_reason"]
         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
+
+        fields_which_caused_replacement = []
+
+        if resource["change"]["replace_paths"]
+          if resource["change"]["replace_paths"].length != 1
+            warning "Multiple replace paths found for resource #{resource['address']}: #{resource['change']['replace_paths'].inspect}"
+          elsif resource["change"]["replace_paths"][0].length != 1
+            warning "Multiple fields found to be replaced for resource #{resource['address']}: #{resource['change']['replace_paths'].inspect}"
+          else
+            fields_which_caused_replacement << resource["change"]["replace_paths"][0][0]
+          end
+        end
+
         diff.each do |change|
           change_symbol, key, *_values = change
           prefix = format("#{global_indent}  #{colorize_symbol(change_symbol)} %s = ", key.ljust(max_diff_key_length))
+          suffix = ""
+          suffix = " (forces replacement)" if fields_which_caused_replacement.include?(key)
           blank_prefix = " " * pastel.strip(prefix).length
           format_value(change).each_with_index do |line, index|
             output << if index.zero?
-                        "#{prefix}#{line}"
+                        "#{prefix}#{line}#{suffix}"
                       else
-                        "#{blank_prefix}#{line}"
+                        "#{blank_prefix}#{line}#{suffix}"
                       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
+      def format_output_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 get_x_type(key, change)
+        return :hash if change[key].is_a?(Hash) || change["#{key}_sensitive"].is_a?(Hash) || change["#{key}_unknown"].is_a?(Hash)
+        return :array if change[key].is_a?(Array) || change["#{key}_sensitive"].is_a?(Array) || change["#{key}_unknown"].is_a?(Array)
+
+        :scalar
+      end
+
+      def get_value_type(change)
+        case change["actions"]
+        when ["create"]
+          get_x_type("after", change)
+        when ["delete"]
+          get_x_type("before", change)
+        when ["update"]
+          bt = get_x_type("before", change)
+          at = get_x_type("after", change)
+          raise "Type mismatch before vs after: #{bt} != #{at}" if bt != at
+
+          at
+        when ["no-op"]
+          :none
+        else
+          raise "Unknown action: #{change['actions'].inspect}"
+        end
+      end
+
+      def prep_before_after(change)
+        before = change["before"]
+        after = change["after"]
+        before = KNOWN_AFTER_APPLY if change["before_unknown"]
+        before = SENSITIVE if change["before_sensitive"]
+        after = KNOWN_AFTER_APPLY if change["after_unknown"]
+        after = SENSITIVE if change["after_sensitive"]
+
+        [before, after]
+      end
+
+      def tf_show_json_output(output_key, output_change, max_outer_key_length)
+        _pretty_action, symbol = get_pretty_action_and_symbol(output_change["actions"])
+
+        output = []
+
+        global_indent = " " * 2
+
+        value_type = get_value_type(output_change)
+
+        start_prefix = format("#{global_indent}#{colorize_symbol(symbol)} %s = ", output_key.ljust(max_outer_key_length))
+        blank_start_prefix = " " * pastel.strip(start_prefix).length
+        outer_mode = :both
+        outer_mode = :right if ["+"].include?(symbol)
+        outer_mode = :left if ["-"].include?(symbol)
+        outer_mode = :right if [" "].include?(symbol)
+
+        case value_type
+        when :hash
+          output << "#{start_prefix}{"
+
+          fake_resource = {
+            "change" => output_change
+          }
+          diff = tf_show_json_resource_diff(fake_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))
+            suffix = ""
+            blank_prefix = " " * pastel.strip(prefix).length
+            format_value(change).each_with_index do |line, index|
+              output << if index.zero?
+                          "#{prefix}#{line}#{suffix}"
+                        else
+                          "#{blank_prefix}#{line}#{suffix}"
+                        end
+            end
+          end
+
+          output << "#{global_indent}  }"
+        when :array, :scalar, :none
+          before, after = prep_before_after(output_change)
+          format_value_diff(outer_mode, [before, after]).each_with_index do |line, index|
+            output << if index.zero?
+                        "#{start_prefix}#{line}"
+                      else
+                        "#{blank_start_prefix}#{line}"
+                      end
+          end
+        else
+          raise "Unknown value type: #{value_type.inspect}"
+        end
+
+        output.join("\n")
+      end
 
-        # Plan: 0 to add, 1 to change, 0 to destroy.
+      # See https://developer.hashicorp.com/terraform/internals/json-format
+      def action_reason_to_text(action_reason)
+        case action_reason
+        when "replace_because_tainted"
+          "because the object is tainted in the prior state"
+        when "replace_because_cannot_update"
+          "because the provider does not support updating the object, or the changed attributes"
+        when "replace_by_request"
+          "because the user requested the object to be replaced"
+        when "delete_because_no_resource_config"
+          "because the object is no longer in the configuration"
+        when "delete_because_no_module"
+          "because the module this object belongs to is no longer in the configuration"
+        when "delete_because_wrong_repetition"
+          "because of the repetition mode has changed"
+        when "delete_because_count_index"
+          "because the repetition count has changed"
+        when "delete_because_each_key"
+          "because the repetition key has changed"
+        when "read_because_config_unknown"
+          "because reading this will only be possible during apply"
+        when "read_because_dependency_pending"
+          "because reading this will only be possible after a dependency is available"
+        else
+          "because #{action_reason}"
+        end
+      end
 
+      def text_version_of_plan_show_from_data(data)
         output = []
 
         output << "Terraform will perform the following actions:"
@@ -349,7 +497,18 @@ module MuxTf
           output << ""
           output << "Resource Changes:"
           data["resource_changes"].each do |resource|
-            output << tf_show_json_resource(resource) if resource["change"]["actions"] != ["no-op"]
+            next if resource["change"]["actions"] == ["no-op"]
+
+            output << tf_show_json_resource(resource)
+          end
+        end
+
+        if data["output_changes"]
+          output << ""
+          output << "Changes to Outputs:"
+          max_outer_key_length = data["output_changes"].keys.map(&:length).max || 0
+          data["output_changes"].each do |key, output_change|
+            output << tf_show_json_output(key, output_change, max_outer_key_length)
           end
         end
 

data/lib/mux_tf/resource_tokenizer.rb

@@ -6,7 +6,7 @@ module MuxTf
       tokenize(resource).map(&:last)
     end
 
-    def self.tokenize(resource) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def self.tokenize(resource)
       result = []
       n = 0
       pn = 0