ruby-terraform 1.6.0.pre.6 → 1.7.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfb61cf4368224119dfec3e6c663cc468d2248f9d5b1dd9cf0fe075d8853147e
-  data.tar.gz: 244624afc4452f2e20a821d7b077927341b96b31766e2c5a5be2bf99fe92a992
+  metadata.gz: f456092f582718db648a5bdfab600d022ffd02b464da155088de1f1ca5247aa2
+  data.tar.gz: e79d368374b9f892ac2fec66d5262f6b9d0999542772e8542912b18791ac1656
 SHA512:
-  metadata.gz: cf0cbc4bd0ad5ab9fb8a3e6fccea2040b56bb3038432eef56068a97a445cc2b000232d9608699757731c3bb82ebad127b14c3c0bc6c572d4db0314538149e5a8
-  data.tar.gz: ecff0f62d8b1c97730b6ef6de2f51b48bb437e39463f9d16a742cc4ea4a62631af945ca27cd6142124f0dfee4f6791386aa0c05ad011ae8fa37172c2a95e1f5e
+  metadata.gz: 7e00c371ab4abea3f4d9448fc8a9fdd0dcdb7abcdd069aeb77f74ef1f16944dd2bc1f597cdb9ff5c6b2ede990f35c064adcb56dac50bcb9ac9cd74c0a1411703
+  data.tar.gz: 01f44d86b1c2ef64a2ea9511a14ece5903d34e554b6908cfe9c41dd724e2a3d7f934fca8f1168b9c94544dcf2b07fb20c3d94f1071dbc408ea8825819eb2398a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-terraform (1.6.0.pre.6)
+    ruby-terraform (1.7.0.pre.2)
       immutable-struct (~> 2.4)
       lino (~> 3.0)
 
@@ -129,8 +129,8 @@ GEM
       parser (>= 3.1.1.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
-    rubocop-rspec (2.11.1)
-      rubocop (~> 1.19)
+    rubocop-rspec (2.12.1)
+      rubocop (~> 1.31)
     ruby-progressbar (1.11.0)
     ruby2_keywords (0.0.5)
     ruby_gpg2 (0.8.0)
@@ -177,4 +177,4 @@ DEPENDENCIES
   yard
 
 BUNDLED WITH
-   2.3.16
+   2.3.17

data/lib/ruby_terraform/models/change.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+require_relative './objects'
+
+module RubyTerraform
+  module Models
+    class Change
+      include ValueEquality
+
+      def initialize(content)
+        @content = content
+      end
+
+      def actions
+        @content[:actions].map do |action|
+          {
+            'no-op' => :no_op,
+            'create' => :create,
+            'read' => :read,
+            'update' => :update,
+            'delete' => :delete
+          }[action]
+        end
+      end
+
+      def before
+        @content[:before]
+      end
+
+      def before_sensitive
+        @content[:before_sensitive]
+      end
+
+      def before_object
+        Objects.box(before, sensitive: before_sensitive)
+      end
+
+      def after
+        @content[:after]
+      end
+
+      def after_unknown
+        @content[:after_unknown]
+      end
+
+      def after_sensitive
+        @content[:after_sensitive]
+      end
+
+      def after_object
+        Objects.box(
+          after,
+          unknown: after_unknown,
+          sensitive: after_sensitive
+        )
+      end
+
+      def no_op?
+        actions == [:no_op]
+      end
+
+      def create?
+        actions == [:create]
+      end
+
+      def read?
+        actions == [:read]
+      end
+
+      def update?
+        actions == [:update]
+      end
+
+      def replace_delete_before_create?
+        actions == %i[delete create]
+      end
+
+      def replace_create_before_delete?
+        actions == %i[create delete]
+      end
+
+      def replace?
+        replace_delete_before_create? || replace_create_before_delete?
+      end
+
+      def delete?
+        actions == [:delete]
+      end
+
+      def inspect
+        @content.inspect
+      end
+
+      def to_h
+        @content
+      end
+
+      def state
+        [@content]
+      end
+    end
+  end
+end

data/lib/ruby_terraform/models/known_value.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+
+module RubyTerraform
+  module Models
+    class KnownValue
+      include ValueEquality
+
+      def initialize(value, sensitive: false)
+        @value = value
+        @sensitive = sensitive
+      end
+
+      attr_reader :value
+
+      def known?
+        true
+      end
+
+      def sensitive?
+        @sensitive
+      end
+
+      def state
+        [@value, @sensitive]
+      end
+
+      def inspect
+        sensitive = sensitive? ? 'sensitive' : 'non-sensitive'
+        "#{@value.inspect} (known, #{sensitive})"
+      end
+    end
+  end
+end

data/lib/ruby_terraform/models/list.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+
+module RubyTerraform
+  module Models
+    class List
+      extend Forwardable
+
+      include Enumerable
+      include ValueEquality
+
+      def_delegators(
+        :@value,
+        :to_a, :to_h, :to_ary,
+        :[], :[]=, :at, :fetch, :first, :last,
+        :concat, :union, :difference, :intersection, :intersect?,
+        :<<, :push, :append, :pop, :shift, :unshift, :insert,
+        :each, :each_index, :reverse_each, :length, :size, :empty?,
+        :find_index, :index, :rindex, :join,
+        :reverse, :reverse!, :rotate, :rotate!, :sort, :sort!, :sort_by!,
+        :collect, :collect!, :map, :map!, :select, :select!, :filter, :filter!,
+        :keep_if, :values_at, :delete, :delete_at, :delete_if,
+        :reject, :reject!, :zip, :transpose, :replace, :clear, :fill, :include?,
+        :<=>, :slice, :slice!, :assoc, :rassoc, :+, :*, :-, :&, :|, :max, :min,
+        :minmax, :uniq, :uniq!, :compact, :compact!, :flatten, :flatten!,
+        :count, :cycle,
+        :permutation, :combination,
+        :repeated_permutation, :repeated_combination,
+        :product, :take, :take_while, :drop, :drop_while,
+        :bsearch, :bsearch_index, :any?, :all?, :none?, :one?, :dig, :sum,
+        :deconstruct, :append, :prepend, :shuffle!, :shuffle, :sample, :pack
+      )
+
+      def initialize(value, sensitive: false)
+        @value = value
+        @sensitive = sensitive
+      end
+
+      attr_reader :value
+
+      def sensitive?
+        @sensitive
+      end
+
+      def state
+        [@value, @sensitive]
+      end
+
+      def inspect
+        sensitive = sensitive? ? 'sensitive' : 'non-sensitive'
+        "#{value.inspect} (#{sensitive})"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/ruby_terraform/models/map.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+
+module RubyTerraform
+  module Models
+    class Map
+      extend Forwardable
+
+      include Enumerable
+      include ValueEquality
+
+      def_delegators(
+        :@value,
+        :rehash, :to_hash, :to_h, :to_a, :to_proc,
+        :[], :fetch, :[]=, :store, :default, :default=,
+        :default_proc, :default_proc=, :key, :size, :length, :empty?,
+        :each_value, :each_key, :each_pair, :each,
+        :transform_keys, :transform_keys!,
+        :transform_values, :transform_values!,
+        :keys, :values, :values_at, :fetch_values,
+        :shift, :delete, :delete_if, :keep_if,
+        :select, :select!, :filter, :filter!, :reject, :reject!,
+        :slice, :except, :clear, :invert, :update, :replace,
+        :merge!, :merge, :assoc, :rassoc, :flatten, :compact, :compact!,
+        :include?, :member?, :has_key?, :has_value?, :key?, :value?,
+        :compare_by_identity, :compare_by_identity?, :any?, :dig,
+        :<=, :<, :>=, :>, :deconstruct_keys
+      )
+
+      def initialize(value, sensitive: false)
+        @value = value
+        @sensitive = sensitive
+      end
+
+      attr_reader :value
+
+      def sensitive?
+        @sensitive
+      end
+
+      def state
+        [@value, @sensitive]
+      end
+
+      def inspect
+        sensitive = sensitive? ? 'sensitive' : 'non-sensitive'
+        "#{value.inspect} (#{sensitive})"
+      end
+
+      alias to_s inspect
+    end
+  end
+end

data/lib/ruby_terraform/models/objects.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative './values'
+
+module RubyTerraform
+  module Models
+    # rubocop:disable Metrics/ModuleLength
+    module Objects
+      class << self
+        # rubocop:disable Style/RedundantAssignment
+        def box(object, unknown: nil, sensitive: nil)
+          initial = boxed_empty_by_value(object)
+          unknown ||= native_empty_by_value(object)
+          sensitive ||= native_empty_by_value(object)
+
+          return Values.unknown(sensitive: sensitive) if unknown == true
+
+          boxed_unknown =
+            box_unknown(unknown, sensitive: sensitive, initial: initial)
+          boxed_object =
+            box_known(object, sensitive: sensitive, initial: boxed_unknown)
+
+          boxed_object
+        end
+
+        # rubocop:enable Style/RedundantAssignment
+
+        def paths(object, current = [], accumulator = [])
+          normalised = normalise(object)
+          if normalised.is_a?(Enumerable)
+            normalised.inject(accumulator) do |a, e|
+              paths(e[0], current + [e[1]], a)
+            end
+          else
+            accumulator + [current]
+          end
+        end
+
+        def known_values(paths, object: {}, sensitive: {})
+          paths.map do |path|
+            resolved = try_dig(object, path)
+            resolved_sensitive = try_dig(sensitive, path) == true
+
+            Values.known(resolved, sensitive: resolved_sensitive)
+          end
+        end
+
+        def unknown_values(paths, unknown: {}, sensitive: {})
+          paths.map do |path|
+            resolved = try_dig(unknown, path)
+            resolved_sensitive = try_dig(sensitive, path) == true
+
+            resolved ? Values.unknown(sensitive: resolved_sensitive) : nil
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def box_unknown(unknown, sensitive: {}, initial: Values.empty_map)
+          unknown_paths = paths(unknown)
+          if root_path(unknown_paths)
+            return Values.unknown(sensitive: sensitive)
+          end
+
+          unknown_values = unknown_values(
+            unknown_paths, unknown: unknown, sensitive: sensitive
+          )
+
+          object(
+            unknown_paths, unknown_values,
+            sensitive: sensitive, initial: initial
+          )
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # rubocop:disable Metrics/MethodLength
+        def box_known(object, sensitive: {}, initial: Values.empty_map)
+          object_paths = paths(object)
+          if root_path(object_paths)
+            return Values.known(object, sensitive: sensitive)
+          end
+
+          object_values = known_values(
+            object_paths, object: object, sensitive: sensitive
+          )
+
+          object(
+            object_paths, object_values,
+            sensitive: sensitive, initial: initial
+          )
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def object(paths, values, sensitive: {}, initial: Values.empty_map)
+          paths
+            .zip(values)
+            .each_with_object(initial) do |path_value, object|
+            path, value = path_value
+            update_in(object, path, value, sensitive: sensitive)
+          end
+        end
+
+        def update_in(object, path, value, sensitive: {})
+          path.inject([[], path.drop(1)]) do |context, step|
+            seen, remaining = context
+            pointer = [seen, step, remaining]
+
+            update_object_for_step(object, pointer, value, sensitive: sensitive)
+            update_context_for_step(pointer)
+          end
+          object
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def update_object_for_step(object, pointer, value, sensitive: {})
+          seen, step, remaining = pointer
+
+          parent = try_dig(object, seen, default: object)
+          upcoming = remaining.first
+
+          resolved_sensitive = try_dig(sensitive, seen + [step]) == true
+          resolved =
+            if remaining.empty?
+              value
+            else
+              boxed_empty_by_key(upcoming, sensitive: resolved_sensitive)
+            end
+
+          parent[step] ||= resolved
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def update_context_for_step(pointer)
+          seen, step, remaining = pointer
+          [seen + [step], remaining.drop(1)]
+        end
+
+        def try_dig(object, path, default: nil)
+          return default if path.empty?
+
+          result = object.dig(*path)
+          result.nil? ? default : result
+        rescue NoMethodError, TypeError
+          default
+        end
+
+        def boxed_empty_by_key(key, sensitive: false)
+          if key.is_a?(Numeric)
+            Values.empty_list(sensitive: sensitive)
+          else
+            Values.empty_map(sensitive: sensitive)
+          end
+        end
+
+        def boxed_empty_by_value(value, sensitive: false)
+          case value
+          when Array then Values.empty_list(sensitive: sensitive)
+          when Hash then Values.empty_map(sensitive: sensitive)
+          end
+        end
+
+        def native_empty_by_value(value)
+          case value
+          when Array then []
+          when Hash then {}
+          else false
+          end
+        end
+
+        def normalise(object)
+          case object
+          when Array then object.each_with_index.to_a
+          when Hash then object.to_a.map { |e| [e[1], e[0]] }
+          else object
+          end
+        end
+
+        def root_path(paths)
+          paths.count == 1 && paths[0].empty?
+        end
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

data/lib/ruby_terraform/models/plan.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'resource_change'
+
+module RubyTerraform
+  module Models
+    class Plan
+      def initialize(content)
+        @content = content
+      end
+
+      def format_version
+        @content[:format_version]
+      end
+
+      def terraform_version
+        @content[:terraform_version]
+      end
+
+      def variables
+        @content[:variables]
+      end
+
+      def variable_values
+        variables.transform_values { |value| value[:value] }
+      end
+
+      def resource_changes
+        @content[:resource_changes].map do |resource_change|
+          ResourceChange.new(resource_change)
+        end
+      end
+
+      def resource_changes_matching(definition)
+        resource_changes.filter do |resource_change|
+          definition.all? do |method, value|
+            resource_change.send(method) == value
+          end
+        end
+      end
+
+      def inspect
+        @content.inspect
+      end
+
+      def to_h
+        @content
+      end
+    end
+  end
+end

data/lib/ruby_terraform/models/resource_change.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+require_relative 'change'
+
+module RubyTerraform
+  module Models
+    class ResourceChange
+      include ValueEquality
+      def initialize(content)
+        @content = content
+      end
+
+      def address
+        @content[:address]
+      end
+
+      def module_address
+        @content[:module_address]
+      end
+
+      def mode
+        @content[:mode]
+      end
+
+      def type
+        @content[:type]
+      end
+
+      def name
+        @content[:name]
+      end
+
+      def index
+        @content[:index]
+      end
+
+      def provider_name
+        @content[:provider_name]
+      end
+
+      def change
+        Change.new(@content[:change])
+      end
+
+      def no_op?
+        change.no_op?
+      end
+
+      def create?
+        change.create?
+      end
+
+      def read?
+        change.read?
+      end
+
+      def update?
+        change.update?
+      end
+
+      def replace_delete_before_create?
+        change.replace_delete_before_create?
+      end
+
+      def replace_create_before_delete?
+        change.replace_create_before_delete?
+      end
+
+      def replace?
+        change.replace?
+      end
+
+      def delete?
+        change.delete?
+      end
+
+      def inspect
+        @content.inspect
+      end
+
+      def to_h
+        @content
+      end
+
+      def state
+        [@content]
+      end
+    end
+  end
+end

data/lib/ruby_terraform/models/unknown_value.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+
+module RubyTerraform
+  module Models
+    class UnknownValue
+      include ValueEquality
+
+      def initialize(sensitive: false)
+        @sensitive = sensitive
+      end
+
+      def known?
+        false
+      end
+
+      def sensitive?
+        @sensitive
+      end
+
+      def state
+        [@sensitive]
+      end
+
+      def inspect
+        sensitive = sensitive? ? 'sensitive' : 'non-sensitive'
+        "? (unknown, #{sensitive})"
+      end
+    end
+  end
+end

data/lib/ruby_terraform/models/values.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative './list'
+require_relative './map'
+require_relative './known_value'
+require_relative './unknown_value'
+
+module RubyTerraform
+  module Models
+    module Values
+      class << self
+        def known(value, sensitive: false)
+          KnownValue.new(value, sensitive: sensitive)
+        end
+
+        def unknown(sensitive: false)
+          UnknownValue.new(sensitive: sensitive)
+        end
+
+        def list(value, sensitive: false)
+          List.new(value, sensitive: sensitive)
+        end
+
+        def empty_list(sensitive: false)
+          list([], sensitive: sensitive)
+        end
+
+        def map(value, sensitive: false)
+          Map.new(value, sensitive: sensitive)
+        end
+
+        def empty_map(sensitive: false)
+          map({}, sensitive: sensitive)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_terraform/models.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'models/plan'
+require_relative 'models/objects'
+require_relative 'models/values'

data/lib/ruby_terraform/value_equality.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyTerraform
+  module ValueEquality
+    def ==(other)
+      other.class == self.class && other.state == state
+    end
+
+    alias eql? ==
+
+    def hash
+      [self.class, state].hash
+    end
+  end
+end

data/lib/ruby_terraform/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyTerraform
-  VERSION = '1.6.0.pre.6'
+  VERSION = '1.7.0.pre.2'
 end

data/lib/ruby_terraform.rb

@@ -4,6 +4,7 @@ require 'ruby_terraform/version'
 require 'ruby_terraform/errors'
 require 'ruby_terraform/options'
 require 'ruby_terraform/commands'
+require 'ruby_terraform/models'
 require 'logger'
 
 module RubyTerraform

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-terraform
 version: !ruby/object:Gem::Version
-  version: 1.6.0.pre.6
+  version: 1.7.0.pre.2
 platform: ruby
 authors:
 - InfraBlocks Maintainers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-29 00:00:00.000000000 Z
+date: 2022-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: immutable-struct
@@ -317,6 +317,16 @@ files:
 - lib/ruby_terraform/commands/workspace_show.rb
 - lib/ruby_terraform/errors.rb
 - lib/ruby_terraform/errors/execution_error.rb
+- lib/ruby_terraform/models.rb
+- lib/ruby_terraform/models/change.rb
+- lib/ruby_terraform/models/known_value.rb
+- lib/ruby_terraform/models/list.rb
+- lib/ruby_terraform/models/map.rb
+- lib/ruby_terraform/models/objects.rb
+- lib/ruby_terraform/models/plan.rb
+- lib/ruby_terraform/models/resource_change.rb
+- lib/ruby_terraform/models/unknown_value.rb
+- lib/ruby_terraform/models/values.rb
 - lib/ruby_terraform/options.rb
 - lib/ruby_terraform/options/definition.rb
 - lib/ruby_terraform/options/definitions.rb
@@ -333,6 +343,7 @@ files:
 - lib/ruby_terraform/options/values/key_value.rb
 - lib/ruby_terraform/options/values/string.rb
 - lib/ruby_terraform/output.rb
+- lib/ruby_terraform/value_equality.rb
 - lib/ruby_terraform/version.rb
 - ruby_terraform.gemspec
 homepage: https://github.com/infrablocks/ruby_terraform