rake_terraform 1.11.0 → 1.16.0.pre.1

data/lib/rake_terraform.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logger'
 require 'rake_dependencies'
 require 'ruby_terraform'
@@ -6,137 +8,54 @@ require 'rake_terraform/tasks'
 require 'rake_terraform/task_sets'
 
 module RakeTerraform
-  include RubyTerraform
-
   def self.define_command_tasks(opts = {}, &block)
     RakeTerraform::TaskSets::All.define(opts, &block)
   end
 
   def self.define_installation_tasks(opts = {})
-    logger = opts[:logger] ||
-        Logger.new(STDERR, level: Logger.const_get(ENV['TF_LOG'] || 'WARN'))
-
-    namespace = opts[:namespace] || :terraform
-    version = opts[:version] || '0.10.3'
-    path = opts[:path] || File.join(Dir.pwd, 'vendor', 'terraform')
-    providers = opts[:providers] || []
-
-    command_task_set_opts = {
-        namespace: namespace,
-        dependency: 'terraform',
-        version: version,
-        path: path,
-        type: :zip,
-
-        os_ids: {mac: 'darwin', linux: 'linux'},
-
-        uri_template:
-            'https://releases.hashicorp.com/terraform/<%= @version %>/' +
-                'terraform_<%= @version %>_<%= @os_id %>_amd64<%= @ext %>',
-        file_name_template:
-            'terraform_<%= @version %>_<%= @os_id %>_amd64<%= @ext %>',
-
-        needs_fetch: lambda { |params|
-          terraform_binary = File.join(
-              params.path, params.binary_directory, 'terraform')
-          version_string = StringIO.new
+    command_task_set = define_command_installation_tasks(opts)
+    provider_task_sets = define_providers_installation_tasks(opts)
 
-          logger.info("Terraform binary should be at: #{terraform_binary}")
+    configure_ruby_terraform(command_task_set.binary)
+    wire_provider_ensure_tasks(opts)
 
-          if File.exist?(terraform_binary)
-            command_line = Lino::CommandLineBuilder
-                .for_command(terraform_binary)
-                .with_flag('-version')
-                .build
-
-            logger.info(
-                'Fetching terraform version information using command: ' +
-                    "#{command_line}")
-
-            command_line.execute(stdout: version_string)
-
-            logger.info(
-                "Terraform version information is: \n#{version_string.string}")
-
-            version_line = version_string.string.lines.first
-            version_is_correct = version_line =~ /#{version}/
-
-            logger.debug(
-                "Version: '#{version}' is in version line: " +
-                    "'#{version_line}'?: #{version_is_correct}")
-
-            return !version_is_correct
-          end
+    [command_task_set.delegate, provider_task_sets.map(&:delegate)]
+  end
 
-          return true
-        }
-    }
+  class << self
+    private
 
-    RubyTerraform.configure do |c|
-      c.binary = File.join(path, 'bin', 'terraform')
+    def define_command_installation_tasks(opts = {})
+      RakeTerraform::TaskSets::Terraform.define(opts)
     end
 
-    command_task_set = RakeDependencies::TaskSets::All
-        .define(command_task_set_opts)
-
-    provider_task_sets = providers.map do |provider|
-      dependency = "terraform-provider-#{provider[:name]}"
-      provider_task_set_opts = {
-          namespace: provider[:name],
-          dependency: dependency,
-          version: provider[:version],
-          path: provider[:path] || File.join('vendor', dependency),
-          type: :tar_gz,
-
-          os_ids: {mac: 'darwin', linux: 'linux'},
-
-          uri_template:
-              "https://github.com/#{provider[:repository]}/releases/" +
-                  "download/<%= @version %>/" +
-                  "#{dependency}_v<%= @version %>_<%= @os_id %>" +
-                  "_amd64<%= @ext %>",
-          file_name_template:
-              "#{dependency}_v<%= @version %>_<%= @os_id %>_amd64<%= @ext %>",
-
-          source_binary_name_template: dependency,
-          target_binary_name_template: "#{dependency}_v<%= @version %>",
-
-          installation_directory: "#{ENV['HOME']}/.terraform.d/plugins",
-
-          needs_fetch: lambda { |params|
-            provider_binary = File.join(
-                params.path,
-                params.binary_directory,
-                "#{dependency}_v#{params.version}")
-
-            logger.info(
-                "Terraform provider binary for: #{provider.name} " +
-                    "should be at: #{provider_binary}")
-
-            binary_exists = File.exists?(provider_binary)
-
-            logger.debug("Provider file exists?: #{binary_exists}")
-
-            !binary_exists
-          }
-      }
+    def define_provider_installation_tasks(opts = {})
+      RakeTerraform::TaskSets::Provider.define(opts)
+    end
 
-      provider_task_set = RakeDependencies::TaskSets::All.new(
-          provider_task_set_opts)
+    def define_providers_installation_tasks(opts = {})
+      namespace = opts[:namespace] || :terraform
+      providers = opts[:providers] || []
 
-      Rake.application.in_namespace namespace do
-        Rake.application.in_namespace :providers do
-          provider_task_set.define_on(Rake.application)
-        end
+      providers.map do |provider_opts|
+        define_provider_installation_tasks(
+          { parent_namespace: namespace }.merge(provider_opts)
+        )
       end
+    end
 
-      provider_task_set
+    def configure_ruby_terraform(binary)
+      RubyTerraform.configure { |c| c.binary = binary }
     end
 
-    Rake::Task["#{namespace}:ensure"]
-        .enhance(providers.map { |provider|
-          "#{namespace}:providers:#{provider[:name]}:ensure" })
+    def wire_provider_ensure_tasks(opts)
+      namespace = opts[:namespace] || :terraform
+      providers = opts[:providers] || []
 
-    return command_task_set, provider_task_sets
+      Rake::Task["#{namespace}:ensure"]
+        .enhance(providers.map do |provider_opts|
+          "#{namespace}:providers:#{provider_opts[:name]}:ensure"
+        end)
+    end
   end
 end

data/lib/rake_terraform/task_sets.rb

@@ -1 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'task_sets/all'
+require_relative 'task_sets/terraform'
+require_relative 'task_sets/provider'

data/lib/rake_terraform/task_sets/all.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rake_factory'
 
 require_relative '../tasks'
@@ -5,9 +7,9 @@ require_relative '../tasks'
 module RakeTerraform
   module TaskSets
     class All < RakeFactory::TaskSet
-      parameter :configuration_name, :required => true
-      parameter :source_directory, :required => true
-      parameter :work_directory, :required => true
+      parameter :configuration_name, required: true
+      parameter :source_directory, required: true
+      parameter :work_directory, required: true
 
       parameter :backend_config
 
@@ -15,73 +17,79 @@ module RakeTerraform
       parameter :var_file
       parameter :state_file
 
-      parameter :debug, :default => false
+      parameter :debug, default: false
 
-      parameter :no_color, :default => false
-      parameter :no_backup, :default => false
-      parameter :no_print_output, :default => false
+      parameter :no_color, default: false
+      parameter :no_backup, default: false
+      parameter :no_print_output, default: false
 
       parameter :backup_file
       parameter :plan_file
 
       parameter :argument_names
 
-      parameter :ensure_task_name, :default => :'terraform:ensure'
+      parameter :ensure_task_name, default: :'terraform:ensure'
 
-      parameter :validate_task_name, :default => :validate
+      parameter :validate_task_name, default: :validate
       parameter :validate_argument_names
 
-      parameter :plan_task_name, :default => :plan
+      parameter :plan_task_name, default: :plan
       parameter :plan_argument_names
 
-      parameter :provision_task_name, :default => :provision
+      parameter :provision_task_name, default: :provision
       parameter :provision_argument_names
 
-      parameter :destroy_task_name, :default => :destroy
+      parameter :destroy_task_name, default: :destroy
       parameter :destroy_argument_names
 
-      parameter :output_task_name, :default => :output
+      parameter :output_task_name, default: :output
       parameter :output_argument_names
 
-      task Tasks::Validate,
-          name: RakeFactory::DynamicValue.new { |ts|
-            ts.validate_task_name
-          },
-          argument_names: RakeFactory::DynamicValue.new { |ts|
+      task Tasks::Validate, {
+        name: RakeFactory::DynamicValue.new do |ts|
+          ts.validate_task_name
+        end,
+        argument_names:
+          RakeFactory::DynamicValue.new do |ts|
             ts.validate_argument_names || ts.argument_names || []
-          }
+          end
+      }
       task Tasks::Plan, {
-          name: RakeFactory::DynamicValue.new { |ts|
-            ts.plan_task_name
-          },
-          argument_names: RakeFactory::DynamicValue.new { |ts|
+        name: RakeFactory::DynamicValue.new do |ts|
+          ts.plan_task_name
+        end,
+        argument_names:
+          RakeFactory::DynamicValue.new do |ts|
             ts.plan_argument_names || ts.argument_names || []
-          }
+          end
       }
       task Tasks::Provision, {
-          name: RakeFactory::DynamicValue.new { |ts|
-            ts.provision_task_name
-          },
-          argument_names: RakeFactory::DynamicValue.new { |ts|
+        name: RakeFactory::DynamicValue.new do |ts|
+          ts.provision_task_name
+        end,
+        argument_names:
+          RakeFactory::DynamicValue.new do |ts|
             ts.provision_argument_names || ts.argument_names || []
-          }
+          end
       }
       task Tasks::Destroy, {
-          name: RakeFactory::DynamicValue.new { |ts|
-            ts.destroy_task_name
-          },
-          argument_names: RakeFactory::DynamicValue.new { |ts|
+        name: RakeFactory::DynamicValue.new do |ts|
+          ts.destroy_task_name
+        end,
+        argument_names:
+          RakeFactory::DynamicValue.new do |ts|
             ts.destroy_argument_names || ts.argument_names || []
-          }
+          end
       }
       task Tasks::Output, {
-          name: RakeFactory::DynamicValue.new { |ts|
-            ts.output_task_name
-          },
-          argument_names: RakeFactory::DynamicValue.new { |ts|
+        name: RakeFactory::DynamicValue.new do |ts|
+          ts.output_task_name
+        end,
+        argument_names:
+          RakeFactory::DynamicValue.new do |ts|
             ts.output_argument_names || ts.argument_names || []
-          }
+          end
       }
     end
   end
-end
+end

data/lib/rake_terraform/task_sets/provider.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'rake'
+
+module RakeTerraform
+  module TaskSets
+    # rubocop:disable Metrics/ClassLength
+
+    class Provider
+      def self.define(*args, &configuration_block)
+        new(*args, &configuration_block).define_on(Rake.application)
+      end
+
+      attr_reader :delegate
+
+      def initialize(*args, &configuration_block)
+        @opts = args[0]
+        @delegate = RakeDependencies::TaskSets::All.new(
+          task_set_opts, &configuration_block
+        )
+      end
+
+      def define_on(application)
+        Rake.application.in_namespace parent_namespace do
+          Rake.application.in_namespace :providers do
+            @delegate.define_on(application)
+          end
+        end
+        self
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+
+      def task_set_opts
+        {
+          namespace: namespace,
+          dependency: dependency,
+          version: version,
+          path: path,
+          type: type,
+
+          os_ids: os_ids,
+
+          uri_template: uri_template,
+          file_name_template: file_name_template,
+
+          source_binary_name_template: source_binary_name_template,
+          target_binary_name_template: target_binary_name_template,
+
+          installation_directory: installation_directory,
+
+          needs_fetch: needs_fetch
+        }
+      end
+
+      # rubocop:enable Metrics/MethodLength
+
+      def logger
+        @logger ||=
+          @opts[:logger] ||
+          Logger.new($stderr,
+                     level: Logger.const_get(ENV['TF_LOG'] || 'WARN'))
+      end
+
+      def name
+        @name ||= @opts[:name]
+      end
+
+      def repository
+        @repository ||= @opts[:repository]
+      end
+
+      def parent_namespace
+        @parent_namespace ||= @opts[:parent_namespace] || :terraform
+      end
+
+      def namespace
+        @namespace ||= @opts[:namespace] || name
+      end
+
+      def dependency
+        @dependency ||= "terraform-provider-#{name}"
+      end
+
+      def version
+        @version ||= @opts[:version]
+      end
+
+      def path
+        @path ||= @opts[:path] || File.join('vendor', dependency)
+      end
+
+      def binary_directory
+        @binary_directory ||= 'bin'
+      end
+
+      def binary_name
+        @binary_name ||= "#{dependency}_v#{version}"
+      end
+
+      def binary
+        @binary ||= File.join(path, binary_directory, binary_name)
+      end
+
+      def type
+        @type ||= :tar_gz
+      end
+
+      def os_ids
+        @os_ids ||= { mac: 'darwin', linux: 'linux' }
+      end
+
+      def uri_template
+        @uri_template ||=
+          "https://github.com/#{repository}/releases/" \
+              'download/<%= @version %>/' \
+              "#{dependency}_v<%= @version %>_<%= @os_id %>" \
+              '_amd64<%= @ext %>'
+      end
+
+      def file_name_template
+        @file_name_template ||=
+          "#{dependency}_v<%= @version %>_<%= @os_id %>_amd64<%= @ext %>"
+      end
+
+      def source_binary_name_template
+        @source_binary_name_template ||= dependency
+      end
+
+      def target_binary_name_template
+        @target_binary_name_template ||= "#{dependency}_v<%= @version %>"
+      end
+
+      def installation_directory
+        @installation_directory ||= "#{ENV['HOME']}/.terraform.d/plugins"
+      end
+
+      def needs_fetch
+        @needs_fetch ||= ->(_) { return !exist?(binary) }
+      end
+
+      def exist?(binary)
+        log_binary_location(binary)
+
+        result = File.exist?(binary)
+
+        log_check_outcome(result)
+
+        result
+      end
+
+      def log_binary_location(binary)
+        logger.info(
+          "Terraform provider binary for: #{name} " \
+                             "should be at: #{binary}"
+        )
+      end
+
+      def log_check_outcome(result)
+        logger.debug("Provider file exists?: #{result}")
+      end
+    end
+
+    # rubocop:enable Metrics/ClassLength
+  end
+end