ruby-terraform 0.64.0 → 0.65.0.pre.5

data/lib/ruby_terraform/command_line/builder.rb

@@ -0,0 +1,55 @@
+require 'lino'
+
+module RubyTerraform
+  module CommandLine
+    class Builder
+      def initialize(binary:, sub_commands:, options:, arguments:)
+        @builder = instantiate_builder(binary)
+        @sub_commands = array_of(sub_commands)
+        @options = array_of(options)
+        @arguments = array_of(arguments)
+      end
+
+      def build
+        configure_builder
+        builder.build
+      end
+
+      private
+
+      attr_reader :builder, :sub_commands, :options, :arguments
+
+      def configure_builder
+        add_subcommands_and_options
+        add_arguments
+      end
+
+      def add_subcommands_and_options
+        sub_commands[0...-1].each do |command|
+          @builder = builder.with_subcommand(command)
+        end
+        @builder = builder.with_subcommand(sub_commands.last) do |sub|
+          options.inject(sub) do |sub_command, option|
+            option.add_to_subcommand(sub_command)
+          end
+        end
+      end
+
+      def add_arguments
+        @builder = builder.with_arguments(arguments)
+      end
+
+      def instantiate_builder(binary)
+        Lino::CommandLineBuilder
+          .for_command(binary)
+          .with_option_separator('=')
+      end
+
+      def array_of(value)
+        return value if value.respond_to?(:each)
+
+        value.nil? ? [] : [value]
+      end
+    end
+  end
+end

data/lib/ruby_terraform/command_line/option/base.rb

@@ -0,0 +1,24 @@
+module RubyTerraform
+  module CommandLine
+    module Option
+      class Base
+        def initialize(switch, value)
+          @switch = switch
+          coerce_value(value)
+        end
+
+        def add_to_subcommand(_sub)
+          raise 'not implemented'
+        end
+
+        private
+
+        attr_reader :switch, :value
+
+        def coerce_value(value)
+          @value = value
+        end
+      end
+    end
+  end
+end

data/lib/ruby_terraform/command_line/option/boolean.rb

@@ -0,0 +1,16 @@
+require_relative 'boolean_value'
+require_relative 'base'
+
+module RubyTerraform
+  module CommandLine
+    module Option
+      class Boolean < Base
+        include BooleanValue
+
+        def add_to_subcommand(sub)
+          sub.with_option(switch, value)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_terraform/command_line/option/boolean_value.rb

@@ -0,0 +1,29 @@
+module RubyTerraform
+  module CommandLine
+    module Option
+      module BooleanValue
+        def coerce_value(value)
+          @value = boolean_val(value)
+        end
+
+        private
+
+        def boolean_val(value)
+          return nil if value.nil?
+          return value if a_boolean?(value)
+          return true if true_as_string?(value)
+
+          false
+        end
+
+        def a_boolean?(value)
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        end
+
+        def true_as_string?(value)
+          value.respond_to?(:downcase) && value.downcase == 'true'
+        end
+      end
+    end
+  end
+end

data/lib/ruby_terraform/command_line/option/flag.rb

@@ -0,0 +1,16 @@
+require_relative 'boolean_value'
+require_relative 'base'
+
+module RubyTerraform
+  module CommandLine
+    module Option
+      class Flag < Base
+        include BooleanValue
+
+        def add_to_subcommand(sub)
+          value ? sub.with_flag(switch) : sub
+        end
+      end
+    end
+  end
+end

data/lib/ruby_terraform/command_line/option/standard.rb

@@ -0,0 +1,40 @@
+require 'json'
+require_relative 'base'
+
+module RubyTerraform
+  module CommandLine
+    module Option
+      class Standard < Base
+        def add_to_subcommand(sub)
+          if value.respond_to?(:keys)
+            add_hash_to_subcommand(sub)
+          elsif value.respond_to?(:each)
+            add_array_to_subcommand(sub)
+          else
+            sub.with_option(switch, value)
+          end
+        end
+
+        private
+
+        def add_hash_to_subcommand(sub)
+          sub.with_repeated_option(
+            switch,
+            value.map do |hash_key, hash_value|
+              "'#{hash_key}=#{as_string(hash_value)}'"
+            end,
+            separator: ' '
+          )
+        end
+
+        def add_array_to_subcommand(sub)
+          sub.with_repeated_option(switch, value)
+        end
+
+        def as_string(value)
+          value.is_a?(String) ? value : JSON.generate(value)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_terraform/command_line/option/switch.rb

@@ -0,0 +1,43 @@
+module RubyTerraform
+  module CommandLine
+    module Option
+      class Switch
+        def initialize(switch)
+          @switch_without_prefix = switch[0] == '-' ? switch[1..] : switch
+        end
+
+        def to_s
+          "-#{switch_without_prefix}"
+        end
+
+        def as_key
+          snake_case.to_sym
+        end
+
+        def as_plural_key
+          "#{snake_case}s".to_sym
+        end
+
+        def ==(other)
+          to_s == other
+        end
+
+        def eql?(other)
+          to_s == other
+        end
+
+        def hash
+          to_s.hash
+        end
+
+        private
+
+        attr_reader :switch_without_prefix
+
+        def snake_case
+          switch_without_prefix.gsub('-', '_')
+        end
+      end
+    end
+  end
+end

data/lib/ruby_terraform/command_line/options_factory.rb

@@ -0,0 +1,79 @@
+require_relative 'option/standard'
+require_relative 'option/flag'
+require_relative 'option/boolean'
+require_relative 'option/switch'
+
+module RubyTerraform
+  module CommandLine
+    class OptionsFactory
+      PLURAL_SWITCHES = Set.new(
+        %w[-var -target -var-file]
+      ).freeze
+      BOOLEAN_SWITCHES = Set.new(
+        %w[-auto-approve -backend -get -get-plugins -input -list -lock
+           -refresh -upgrade -verify-plugins -write]
+      ).freeze
+      FLAG_SWITCHES = Set.new(
+        %w[-allow-missing -allow-missing-config -check -compact-warnings
+           -destroy -detailed-exitcode -diff -draw-cycles -force -force-copy
+           -ignore-remote-version -json -no-color -raw -reconfigure -recursive
+           -update]
+      ).freeze
+      OVERRIDE_SWITCHES = {
+        config: :directory,
+        out: :plan
+      }.freeze
+
+      def self.from(values, switches)
+        new(values, switches).from
+      end
+
+      private_class_method :new
+
+      def initialize(values, switches)
+        @switches = switches.map { |switch| Option::Switch.new(switch) }
+        @values = values
+      end
+
+      def from
+        switches.each_with_object([]) do |switch, options|
+          options.append(*options_from_switch(switch))
+        end
+      end
+
+      private
+
+      attr_reader :switches, :values
+
+      def options_from_switch(switch)
+        return plural_options(switch) if PLURAL_SWITCHES.include?(switch)
+        return boolean_option(switch) if BOOLEAN_SWITCHES.include?(switch)
+        return flag_option(switch) if FLAG_SWITCHES.include?(switch)
+        return override_option(switch) if OVERRIDE_SWITCHES.key?(switch.as_key)
+
+        standard_option(switch, switch.as_key)
+      end
+
+      def boolean_option(switch)
+        [Option::Boolean.new(switch.to_s, values[switch.as_key])]
+      end
+
+      def flag_option(switch)
+        [Option::Flag.new(switch.to_s, values[switch.as_key])]
+      end
+
+      def standard_option(switch, hash_key)
+        [Option::Standard.new(switch.to_s, values[hash_key])]
+      end
+
+      def override_option(switch)
+        standard_option(switch, OVERRIDE_SWITCHES[switch.as_key])
+      end
+
+      def plural_options(switch)
+        standard_option(switch.to_s, switch.as_key) +
+          standard_option(switch.to_s, switch.as_plural_key)
+      end
+    end
+  end
+end

data/lib/ruby_terraform/commands/apply.rb

@@ -1,49 +1,27 @@
-require 'json'
-require 'lino'
 require_relative 'base'
 
 module RubyTerraform
   module Commands
     class Apply < Base
-      def configure_command(builder, opts)
-        directory = opts[:directory]
-        plan = opts[:plan]
-        vars = opts[:vars] || {}
-        var_file = opts[:var_file]
-        var_files = opts[:var_files] || []
-        target = opts[:target]
-        targets = opts[:targets] || []
-        state = opts[:state]
-        input = opts[:input]
-        auto_approve = opts[:auto_approve]
-        no_backup = opts[:no_backup]
-        backup = no_backup ? '-' : opts[:backup]
-        no_color = opts[:no_color]
+      def sub_commands(_values)
+        'apply'
+      end
+
+      def switches
+        %w[-backup -lock -lock-timeout -input -auto-approve -no-color -state
+           -target -var -var-file]
+      end
+
+      def arguments(values)
+        values[:plan] || values[:directory]
+      end
+
+      def option_default_values(_opts)
+        { vars: {}, var_files: [], targets: [] }
+      end
 
-        builder
-            .with_subcommand('apply') do |sub|
-              vars.each do |key, value|
-                var_value = value.is_a?(String) ? value : JSON.generate(value)
-                sub = sub.with_option(
-                    '-var', "'#{key}=#{var_value}'", separator: ' ')
-              end
-              sub = sub.with_option('-var-file', var_file) if var_file
-              var_files.each do |file|
-                sub = sub.with_option('-var-file', file)
-              end
-              sub = sub.with_option('-target', target) if target
-              targets.each do |file|
-                sub = sub.with_option('-target', file)
-              end
-              sub = sub.with_option('-state', state) if state
-              sub = sub.with_option('-input', input) if input
-              sub = sub.with_option('-auto-approve', auto_approve) unless
-                  auto_approve.nil?
-              sub = sub.with_option('-backup', backup) if backup
-              sub = sub.with_flag('-no-color') if no_color
-              sub
-            end
-            .with_argument(plan || directory)
+      def option_override_values(opts)
+        { backup: opts[:no_backup] ? '-' : opts[:backup] }
       end
     end
   end

data/lib/ruby_terraform/commands/base.rb

@@ -1,30 +1,24 @@
-require 'lino'
 require_relative '../errors'
+require_relative '../command_line/builder'
+require_relative '../command_line/options_factory'
 
 module RubyTerraform
   module Commands
     class Base
       def initialize(
-          binary: nil, logger: nil, stdin: nil, stdout: nil, stderr: nil)
+        binary: nil, logger: nil, stdin: nil, stdout: nil, stderr: nil
+      )
         @binary = binary || RubyTerraform.configuration.binary
         @logger = logger || RubyTerraform.configuration.logger
         @stdin = stdin || RubyTerraform.configuration.stdin
         @stdout = stdout || RubyTerraform.configuration.stdout
         @stderr = stderr || RubyTerraform.configuration.stderr
+        initialize_command
       end
 
       def execute(opts = {})
-        builder = instantiate_builder
-
         do_before(opts)
-        command = configure_command(builder, opts).build
-        logger.debug("Running '#{command.to_s}'.")
-
-        command.execute(
-            stdin: stdin,
-            stdout: stdout,
-            stderr: stderr
-        )
+        build_and_execute_command(opts)
         do_after(opts)
       rescue Open4::SpawnError
         message = "Failed while running '#{command_name}'."
@@ -36,23 +30,65 @@ module RubyTerraform
 
       attr_reader :binary, :logger, :stdin, :stdout, :stderr
 
+      def build_and_execute_command(opts)
+        command = build_command(opts)
+        logger.debug("Running '#{command}'.")
+        command.execute(
+          stdin: stdin,
+          stdout: stdout,
+          stderr: stderr
+        )
+      end
+
       def command_name
-        self.class.to_s.split("::")[-1].downcase
+        self.class.to_s.split('::')[-1].downcase
+      end
+
+      def do_before(_opts); end
+
+      def do_after(_opts); end
+
+      private
+
+      def initialize_command; end
+
+      def build_command(opts)
+        values = apply_option_defaults_and_overrides(opts)
+        RubyTerraform::CommandLine::Builder.new(
+          binary: @binary,
+          sub_commands: sub_commands(values),
+          options: options(values),
+          arguments: arguments(values)
+        ).build
+      end
+
+      def apply_option_defaults_and_overrides(opts)
+        option_default_values(opts).merge(opts)
+                                   .merge(option_override_values(opts))
+      end
+
+      def option_default_values(_values)
+        {}
+      end
+
+      def option_override_values(_values)
+        {}
       end
 
-      def instantiate_builder
-        Lino::CommandLineBuilder
-            .for_command(binary)
-            .with_option_separator('=')
+      def sub_commands(_values)
+        []
       end
 
-      def do_before(opts)
+      def options(values)
+        RubyTerraform::CommandLine::OptionsFactory.from(values, switches)
       end
 
-      def configure_command(builder, opts)
+      def switches
+        []
       end
 
-      def do_after(opts)
+      def arguments(_values)
+        []
       end
     end
   end