mux_tf 0.8.4 → 0.9.0

data/lib/mux_tf/plan_summary_handler.rb

@@ -6,8 +6,6 @@ module MuxTf
     include TerraformHelpers
     include PiotrbCliUtils::Util
 
-    PLAN_FILENAME = "foo.tfplan"
-
     def self.from_file(file)
       data = data_from_file(file)
       new data
@@ -20,7 +18,7 @@ module MuxTf
         puts "Analyzing changes ..."
         result = tf_show(file, json: true)
         data = result.parsed_output
-        File.open("#{file}.json", "w") { |fh| fh.write(JSON.dump(data)) }
+        File.write("#{file}.json", JSON.dump(data))
         data
       end
     end
@@ -29,93 +27,89 @@ module MuxTf
       new(data)
     end
 
-    def initialize(data)
+    def initialize(data) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       @parts = []
 
-      if data["output_changes"]
-        data["output_changes"].each do |output_name, v|
-          case v["actions"]
-          when ["no-op"]
-            # do nothing
-          when ["create"]
-            parts << {
-              type: "output",
-              action: "create",
-              after_unknown: v["after_unknown"],
-              sensitive: [v["before_sensitive"], v["after_sensitive"]],
-              address: output_name
-            }
-          when ["update"]
-            parts << {
-              type: "output",
-              action: "update",
-              after_unknown: v["after_unknown"],
-              sensitive: [v["before_sensitive"], v["after_sensitive"]],
-              address: output_name
-            }
-          when ["delete"]
-            parts << {
-              type: "output",
-              action: "delete",
-              after_unknown: v["after_unknown"],
-              sensitive: [v["before_sensitive"], v["after_sensitive"]],
-              address: output_name
-            }
-          else
-            puts "[??] #{output_name}"
-            puts "UNKNOWN ACTIONS: #{v["actions"].inspect}"
-            puts "TODO: update plan_summary to support this!"
-          end
+      data["output_changes"]&.each do |output_name, v|
+        case v["actions"]
+        when ["no-op"]
+          # do nothing
+        when ["create"]
+          parts << {
+            type: "output",
+            action: "create",
+            after_unknown: v["after_unknown"],
+            sensitive: [v["before_sensitive"], v["after_sensitive"]],
+            address: output_name
+          }
+        when ["update"]
+          parts << {
+            type: "output",
+            action: "update",
+            after_unknown: v["after_unknown"],
+            sensitive: [v["before_sensitive"], v["after_sensitive"]],
+            address: output_name
+          }
+        when ["delete"]
+          parts << {
+            type: "output",
+            action: "delete",
+            after_unknown: v["after_unknown"],
+            sensitive: [v["before_sensitive"], v["after_sensitive"]],
+            address: output_name
+          }
+        else
+          puts "[??] #{output_name}"
+          puts "UNKNOWN ACTIONS: #{v['actions'].inspect}"
+          puts "TODO: update plan_summary to support this!"
         end
       end
 
-      if data["resource_changes"]
-        data["resource_changes"].each do |v|
-          next unless v["change"]
-
-          case v["change"]["actions"]
-          when ["no-op"]
-            # do nothing
-          when ["create"]
-            parts << {
-              type: "resource",
-              action: "create",
-              address: v["address"],
-              deps: find_deps(data, v["address"])
-            }
-          when ["update"]
-            parts << {
-              type: "resource",
-              action: "update",
-              address: v["address"],
-              deps: find_deps(data, v["address"])
-            }
-          when ["delete"]
-            parts << {
-              type: "resource",
-              action: "delete",
-              address: v["address"],
-              deps: find_deps(data, v["address"])
-            }
-          when %w[delete create]
-            parts << {
-              type: "resource",
-              action: "replace",
-              address: v["address"],
-              deps: find_deps(data, v["address"])
-            }
-          when ["read"]
-            parts << {
-              type: "resource",
-              action: "read",
-              address: v["address"],
-              deps: find_deps(data, v["address"])
-            }
-          else
-            puts "[??] #{v["address"]}"
-            puts "UNKNOWN ACTIONS: #{v["change"]["actions"].inspect}"
-            puts "TODO: update plan_summary to support this!"
-          end
+      data["resource_changes"]&.each do |v|
+        next unless v["change"]
+
+        case v["change"]["actions"]
+        when ["no-op"]
+          # do nothing
+        when ["create"]
+          parts << {
+            type: "resource",
+            action: "create",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        when ["update"]
+          parts << {
+            type: "resource",
+            action: "update",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        when ["delete"]
+          parts << {
+            type: "resource",
+            action: "delete",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        when %w[delete create]
+          parts << {
+            type: "resource",
+            action: "replace",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        when ["read"]
+          parts << {
+            type: "resource",
+            action: "read",
+            address: v["address"],
+            deps: find_deps(data, v["address"])
+          }
+        else
+          puts "[??] #{v['address']}"
+          puts "UNKNOWN ACTIONS: #{v['change']['actions'].inspect}"
+          puts "TODO: update plan_summary to support this!"
         end
       end
 
@@ -130,7 +124,7 @@ module MuxTf
       parts.select { |part| part[:type] == "output" }
     end
 
-    def summary
+    def summary # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       # resources
       resource_summary = {}
       resource_parts.each do |part|
@@ -157,7 +151,7 @@ module MuxTf
         [
           "Plan Summary:",
           resource_pieces.any? ? resource_pieces.join(Paint[", ", :gray]) : nil,
-          output_pieces.any? ? "Outputs: #{output_pieces.join(Paint[", ", :gray])}" : nil
+          output_pieces.any? ? "Outputs: #{output_pieces.join(Paint[', ', :gray])}" : nil
         ].compact.join(" ")
       else
         "Plan Summary: no changes"
@@ -172,14 +166,14 @@ module MuxTf
       result
     end
 
-    def sensitive_summary(bv, av)
+    def sensitive_summary(before_value, after_value)
       # before vs after
-      if bv && av
-        "(#{Paint["sensitive", :yellow]})"
-      elsif bv
-        "(#{Paint["-sensitive", :red]})"
-      elsif av
-        "(#{Paint["+sensitive", :cyan]})"
+      if before_value && after_value
+        "(#{Paint['sensitive', :yellow]})"
+      elsif before_value
+        "(#{Paint['-sensitive', :red]})"
+      elsif after_value
+        "(#{Paint['+sensitive', :cyan]})"
       end
     end
 
@@ -197,19 +191,19 @@ module MuxTf
       result
     end
 
-    def nested_summary
+    def nested_summary # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       result = []
       parts = resource_parts.deep_dup
       until parts.empty?
         part = parts.shift
         if part[:deps] == []
           indent = if part[:met_deps] && !part[:met_deps].empty?
-            "  "
-          else
-            ""
-          end
+                     "  "
+                   else
+                     ""
+                   end
           message = "[#{format_action(part[:action])}]#{indent} #{format_address(part[:address])}"
-          message += " - (needs: #{part[:met_deps].join(", ")})" if part[:met_deps]
+          message += " - (needs: #{part[:met_deps].join(', ')})" if part[:met_deps]
           result << message
           parts.each do |ipart|
             d = ipart[:deps].delete(part[:address])
@@ -234,11 +228,11 @@ module MuxTf
         end
       }
 
-      if !result.empty?
+      if result.empty?
+        throw :abort, "nothing selected"
+      else
         log "Re-running apply with the selected resources ..."
         run_plan(targets: result)
-      else
-        throw :abort, "nothing selected"
       end
     end
 
@@ -263,7 +257,8 @@ module MuxTf
     end
 
     def run_plan(targets: [])
-      plan_status, @plan_meta = create_plan(PLAN_FILENAME, targets: targets)
+      plan_filename = MuxTf::Cli::Current.plan_filename
+      plan_status, @plan_meta = create_plan(plan_filename, targets: targets)
 
       case plan_status
       when :ok
@@ -272,7 +267,7 @@ module MuxTf
         log "something went wrong", depth: 1
       when :changes
         log "Printing Plan Summary ...", depth: 1
-        pretty_plan_summary(PLAN_FILENAME)
+        pretty_plan_summary(plan_filename)
       when :unknown
         # nothing
       end
@@ -291,7 +286,7 @@ module MuxTf
       log plan.summary, depth: 2
     end
 
-    def prune_unchanged_deps(parts)
+    def prune_unchanged_deps(_parts)
       valid_addresses = resource_parts.map { |part| part[:address] }
 
       resource_parts.each do |part|
@@ -299,7 +294,7 @@ module MuxTf
       end
     end
 
-    def find_deps(data, address)
+    def find_deps(data, address) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       result = []
 
       m = address.match(/\[(.+)\]$/)
@@ -309,8 +304,8 @@ module MuxTf
       end
 
       if data.dig("prior_state", "values", "root_module", "resources")
-        resource = data["prior_state"]["values"]["root_module"]["resources"].find { |resource|
-          address == resource["address"] && index == resource["index"]
+        resource = data["prior_state"]["values"]["root_module"]["resources"].find { |inner_resource|
+          address == inner_resource["address"] && index == inner_resource["index"]
         }
       end
 
@@ -330,19 +325,19 @@ module MuxTf
 
     def find_config(module_root, module_name, address, parent_address)
       module_info = if parent_address.empty?
-        module_root[module_name]
-      elsif module_root && module_root[module_name]
-        module_root[module_name]["module"]
-      else
-        {}
-      end
-
-      if m = address.match(/^module\.([^.]+)\./)
+                      module_root[module_name]
+                    elsif module_root && module_root[module_name]
+                      module_root[module_name]["module"]
+                    else
+                      {}
+                    end
+
+      if (m = address.match(/^module\.([^.]+)\./))
         find_config(module_info["module_calls"], m[1], m.post_match, parent_address + ["module.#{m[1]}"])
       else
         if module_info["resources"]
-          resource = module_info["resources"].find { |resource|
-            address == resource["address"]
+          resource = module_info["resources"].find { |inner_resource|
+            address == inner_resource["address"]
           }
         end
         [resource, parent_address]
@@ -357,7 +352,7 @@ module MuxTf
         :yellow
       when "delete"
         :red
-      when "replace"
+      when "replace" # rubocop:disable Lint/DuplicateBranch
         :red
       when "read"
         :cyan
@@ -395,7 +390,7 @@ module MuxTf
       parts.each_with_index do |(part_type, part_value), index|
         case part_type
         when :rt
-          result << "." if index > 0
+          result << "." if index.positive?
           result << Paint[part_value, :cyan]
         when :rn
           result << "."

data/lib/mux_tf/resource_tokenizer.rb

@@ -1,62 +1,66 @@
-class ResourceTokenizer
-  def self.split(resource)
-    tokenize(resource).map(&:last)
-  end
+# frozen_string_literal: true
 
-  def self.tokenize(resource)
-    result = []
-    n = 0
-    pn = 0
-    state = :rt
-    until n >= resource.length
-      case state
-      when :rt
-        # looking for .
-        if resource[n] == "."
-          # reached the dot ..
-          result << [:rt, resource[pn...n]]
-          pn = n + 1
-          state = :rn
-        end
-      when :rn
-        # looking for [ or .
-        if resource[n] == "."
-          # reached the dot ..
-          result << [:rn, resource[pn...n]]
-          pn = n + 1
-          state = :rt
-        end
-        if resource[n] == "["
-          # reached the open bracket
-          result << [:rn, resource[pn...n]]
-          pn = n
-          state = :ri
-        end
-        if n == resource.length - 1
-          # last character .. close the current group
-          # the last thing should only ever be an index or a name
-          result << [:rn, resource[pn..n]]
-          pn = n
-          state = :done
-        end
-      when :ri
-        # looking for ]
-        if resource[n] == "]"
-          # reached the close bracket
-          result << [:ri, resource[pn..n]]
-          pn = n + 1
-          state = :rt
-          if resource[n + 1] == "."
-            pn = n + 2
-            n += 1
+module MuxTf
+  class ResourceTokenizer
+    def self.split(resource)
+      tokenize(resource).map(&:last)
+    end
+
+    def self.tokenize(resource) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      result = []
+      n = 0
+      pn = 0
+      state = :rt
+      until n >= resource.length
+        case state
+        when :rt
+          # looking for .
+          if resource[n] == "."
+            # reached the dot ..
+            result << [:rt, resource[pn...n]]
+            pn = n + 1
+            state = :rn
+          end
+        when :rn
+          # looking for [ or .
+          if resource[n] == "."
+            # reached the dot ..
+            result << [:rn, resource[pn...n]]
+            pn = n + 1
+            state = :rt
+          end
+          if resource[n] == "["
+            # reached the open bracket
+            result << [:rn, resource[pn...n]]
+            pn = n
+            state = :ri
+          end
+          if n == resource.length - 1
+            # last character .. close the current group
+            # the last thing should only ever be an index or a name
+            result << [:rn, resource[pn..n]]
+            pn = n
+            state = :done
+          end
+        when :ri
+          # looking for ]
+          if resource[n] == "]"
+            # reached the close bracket
+            result << [:ri, resource[pn..n]]
+            pn = n + 1
+            state = :rt
+            if resource[n + 1] == "."
+              pn = n + 2
+              n += 1
+            end
           end
+        else
+          warn "unhandled state: #{state.inspect}"
         end
-      else
-        warn "unhandled state: #{state.inspect}"
+        # p resource[n]
+        n += 1
       end
-      # p resource[n]
-      n += 1
+      result
     end
-    result
   end
 end

data/lib/mux_tf/terraform_helpers.rb

@@ -4,6 +4,8 @@ module MuxTf
   module TerraformHelpers
     include PiotrbCliUtils::ShellHelpers
 
+    ResultStruct = Struct.new("TerraformResponse", :status, :success?, :output, :parsed_output, keyword_init: true)
+
     def tf_force_unlock(id:)
       run_terraform(tf_prepare_command(["force-unlock", "-force", id], need_auth: true))
     end
@@ -88,32 +90,32 @@ module MuxTf
     # return_status: false, echo_command: true, quiet: false, indent: 0
     def run_terraform(args, **_options)
       status = run_shell(args, return_status: true, echo_command: true, quiet: false)
-      OpenStruct.new({
-        status: status,
-        success?: status == 0
-      })
+      ResultStruct.new({
+                         status: status,
+                         success?: status.zero?
+                       })
     end
 
     def stream_terraform(args, &block)
       status = run_with_each_line(args, &block)
       # status is a Process::Status
-      OpenStruct.new({
-        status: status.exitstatus,
-        success?: status.exitstatus == 0
-      })
+      ResultStruct.new({
+                         status: status.exitstatus,
+                         success?: status.exitstatus.zero?
+                       })
     end
 
     # error: true, echo_command: true, indent: 0, raise_on_error: false, detailed_result: false
     def capture_terraform(args, json: nil)
       result = capture_shell(args, error: true, echo_command: false, raise_on_error: false, detailed_result: true)
       parsed_output = JSON.parse(result.output) if json
-      OpenStruct.new({
-        status: result.status,
-        success?: result.status == 0,
-        output: result.output,
-        parsed_output: parsed_output
-      })
-    rescue JSON::ParserError => e
+      ResultStruct.new({
+                         status: result.status,
+                         success?: result.status.zero?,
+                         output: result.output,
+                         parsed_output: parsed_output
+                       })
+    rescue JSON::ParserError
       fail_with "Execution Failed! - #{result.inspect}"
     end
   end

data/lib/mux_tf/tmux.rb

@@ -16,7 +16,7 @@ module MuxTf
       def find_pane(name)
         panes = `tmux list-panes -F "\#{pane_id},\#{pane_title}"`.strip.split("\n").map { |row|
           x = row.split(",")
-          return {id: x[0], name: x[1]}
+          { id: x[0], name: x[1] }
         }
         panes.find { |pane| pane[:name] == name }
       end
@@ -24,7 +24,7 @@ module MuxTf
       def list_windows
         `tmux list-windows -F "\#{window_id},\#{window_index},\#{window_name}"`.strip.split("\n").map do |row|
           x = row.split(",")
-          {id: x[0], index: x[1], name: x[2]}
+          { id: x[0], index: x[1], name: x[2] }
         end
       end
 
@@ -49,7 +49,7 @@ module MuxTf
       end
 
       def attach(name, cc: false)
-        tmux %(#{cc && "-CC" || ""} attach -t #{name.inspect}), raise_on_error: false
+        tmux %(#{(cc && '-CC') || ''} attach -t #{name.inspect}), raise_on_error: false
       end
 
       def kill_pane(pane_id)
@@ -93,9 +93,7 @@ module MuxTf
           # puts " => tmux #{cmd}"
           system("#{tmux_bin} #{cmd}")
           unless $CHILD_STATUS.success?
-            if raise_on_error
-              fail_with("`tmux #{cmd}' failed with code: #{$CHILD_STATUS.exitstatus}")
-            end
+            fail_with("`tmux #{cmd}' failed with code: #{$CHILD_STATUS.exitstatus}") if raise_on_error
 
             return false
           end

data/lib/mux_tf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MuxTf
-  VERSION = "0.8.4"
+  VERSION = "0.9.0"
 end

data/lib/mux_tf/version_check.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module MuxTf
   module VersionCheck
-    def has_updates?
+    def has_updates? # rubocop:disable Naming/PredicateName
       current_gem_version < latest_gem_version
     end
 
@@ -23,6 +25,6 @@ module MuxTf
       @cache ||= YamlCache.new(File.expand_path("~/.mux_tf.yaml"), default_ttl: 1.hour)
     end
 
-    extend self
+    module_function :has_updates?, :latest_gem_version, :current_gem_version, :cache
   end
 end