ruby-terraform 1.7.0.pre.7 → 1.7.0.pre.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40166cca660dc61e95b7b9983f757c4e3c148005226006167adebea38c5922bb
-  data.tar.gz: 8140497c2e9c0a7acb5bce2967157a47b796bb2e0c716b70477cfac936a55fbd
+  metadata.gz: 29d107877da7868db24f108a46175dcc3f72b92baa17453cfd588784ecadbbe5
+  data.tar.gz: 4c3f6114288c1428313eb48c08a48d48ef1c824dbdcaf3c1f770c45a694687bd
 SHA512:
-  metadata.gz: a6d0e5d37e4a84ed32d97e12af6af490cbfd9d08323cc811e58dcdd7595f6aed067c9f7348a2da1ce591e7c00556c305df3e4492a8644006be864b54f1d8f475
-  data.tar.gz: ff0ba6c53a93af497e79ec00a75f25baa2667ed86009a475d976ecf15b949c8eded5fde7a4e69b5ae1b7f0c6126df979d945a6b7165cfe479498c2f584171668
+  metadata.gz: ef8aa4827093bdd287a3473ba0d61ce2812152812e3f60b8836b4aff306992ca77d5c619da0f591bf5f05c5f8b5a77181bb535e0f10a80adc924cbf8251264b9
+  data.tar.gz: 72f79d40b6d54ec9d5ad5998e953633b856778e1d3d565fddcac05ae8a7b0dd299de73a575624342c394f4e3bc39ac16bb2c492ae7717f3ced03bf9962dade25

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-terraform (1.7.0.pre.7)
+    ruby-terraform (1.7.0.pre.8)
       immutable-struct (~> 2.4)
       lino (~> 3.0)
 
@@ -115,17 +115,17 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
-    rubocop (1.31.2)
+    rubocop (1.32.0)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.18.0, < 2.0)
+      rubocop-ast (>= 1.19.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.18.0)
+    rubocop-ast (1.19.1)
       parser (>= 3.1.1.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)

data/lib/ruby_terraform/models/objects.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative './values'
+require_relative './path_set'
 
 module RubyTerraform
   module Models
@@ -8,6 +9,7 @@ module RubyTerraform
     module Objects
       class << self
         # rubocop:disable Style/RedundantAssignment
+        # rubocop:disable Metrics/MethodLength
         def box(object, unknown: nil, sensitive: nil)
           initial = boxed_empty_by_value(object)
           object = symbolise(object)
@@ -16,135 +18,112 @@ module RubyTerraform
 
           return Values.unknown(sensitive: sensitive) if unknown == true
 
+          unless object.is_a?(Hash) || object.is_a?(Array)
+            return Values.known(object, sensitive: sensitive)
+          end
+
           boxed_unknown =
             box_unknown(unknown, sensitive: sensitive, initial: initial)
+
           boxed_object =
             box_known(object, sensitive: sensitive, initial: boxed_unknown)
 
           boxed_object
         end
-
+        # rubocop:enable Metrics/MethodLength
         # 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
+        def paths(object)
+          PathSet.extract_from(object)
         end
 
-        def known_values(paths, object: {}, sensitive: {})
-          paths.map do |path|
-            resolved = try_dig(object, path)
-            resolved_sensitive = try_dig(sensitive, path) == true
+        def known_values(path_set, object: {}, sensitive: {})
+          path_set.paths.map do |path|
+            resolved = path.read(object)
+            resolved_sensitive = path.read(sensitive) == 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
+        def unknown_values(path_set, unknown: {}, sensitive: {})
+          path_set.paths.map do |path|
+            resolved = path.read(unknown)
+            resolved_sensitive = path.read(sensitive) == true
 
             resolved ? Values.unknown(sensitive: resolved_sensitive) : nil
           end
         end
 
+        def object(path_set, values,
+                   sensitive: {},
+                   initial: Values.empty_map,
+                   filler: Values.omitted)
+          gaps = path_set.gaps
+          extra_values = gaps.paths.collect { |p| [p, filler] }
+
+          path_values = path_set.paths.zip(values) + extra_values
+          path_values = sort_by_path(path_values)
+
+          update_all(initial, path_values, sensitive)
+        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
-
+          path_set = paths(unknown)
           unknown_values = unknown_values(
-            unknown_paths, unknown: unknown, sensitive: sensitive
+            path_set, unknown: unknown, sensitive: sensitive
           )
-
           object(
-            unknown_paths, unknown_values,
-            sensitive: sensitive, initial: initial
+            path_set, 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
-
+          path_set = paths(object)
           object_values = known_values(
-            object_paths, object: object, sensitive: sensitive
+            path_set, object: object, sensitive: sensitive
           )
-
           object(
-            object_paths, object_values,
-            sensitive: sensitive, initial: initial
+            path_set, 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|
+        def update_all(object, path_values, sensitive = {})
+          path_values.each_with_object(object) do |path_value, obj|
             path, value = path_value
-            update_in(object, path, value, sensitive: sensitive)
+            update_in(obj, 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)
+          path.traverse(object) do |obj, step|
+            update_object_for_step(
+              obj, step, value, sensitive: sensitive
+            )
           end
-          object
         end
 
         # rubocop:disable Metrics/MethodLength
-        def update_object_for_step(object, pointer, value, sensitive: {})
-          seen, step, remaining = pointer
+        def update_object_for_step(object, step, value, sensitive: {})
+          parent = step.seen.read(object, default: object)
+          upcoming = step.remaining.first
 
-          parent = try_dig(object, seen, default: object)
-          upcoming = remaining.first
-
-          resolved_sensitive = try_dig(sensitive, seen + [step]) == true
+          found_sensitive = step.seen.append(step.element).read(sensitive)
+          resolved_sensitive = found_sensitive == true
           resolved =
-            if remaining.empty?
+            if step.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
+          parent[step.element] ||= resolved
 
-        def try_dig(object, path, default: nil)
-          return default if path.empty?
-
-          result = object.dig(*path)
-          result.nil? ? default : result
-        rescue NoMethodError, TypeError
-          default
+          object
         end
+        # rubocop:enable Metrics/MethodLength
 
         def boxed_empty_by_key(key, sensitive: false)
           if key.is_a?(Numeric)
@@ -169,22 +148,12 @@ module RubyTerraform
           end
         end
 
-        def normalise(object)
-          case object
-          when Array then object.each_with_index.to_a
-          when Hash
-            object.to_a.map do |e|
-              [e[1], e[0].to_sym]
-            end
-          else object
-          end
-        end
-
         def symbolise(object)
           case object
           when Hash
             object.to_h { |key, value| [key.to_sym, symbolise(value)] }
-          else object
+          else
+            object
           end
         end
 
@@ -192,8 +161,8 @@ module RubyTerraform
           object ? symbolise(object) : native_empty_by_value(target)
         end
 
-        def root_path(paths)
-          paths.count == 1 && paths[0].empty?
+        def sort_by_path(path_values)
+          path_values.sort { |a, b| a[0] <=> b[0] }
         end
       end
     end

data/lib/ruby_terraform/models/path.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+
+module RubyTerraform
+  module Models
+    # rubocop:disable Metrics/ClassLength
+    class Path
+      class << self
+        def empty
+          new([])
+        end
+      end
+
+      extend Forwardable
+
+      include Comparable
+      include ValueEquality
+
+      def_delegators(:@elements, :first, :last, :length, :empty?)
+
+      attr_reader(:elements)
+
+      def initialize(elements)
+        @elements = elements.compact
+      end
+
+      def references_any_lists?
+        elements.any? { |e| e.is_a?(Numeric) }
+      end
+
+      def references_any_maps?
+        elements.any? { |e| e.is_a?(Symbol) }
+      end
+
+      def same_parent_collection?(other)
+        return true if self == other
+
+        left, right = diff(other)
+        left.length == 1 && right.length == 1
+      end
+
+      def list_indices
+        elements.each_with_index.inject([]) do |acc, element_index|
+          element, index = element_index
+          element.is_a?(Numeric) ? acc + [[index, element]] : acc
+        end
+      end
+
+      def to_location(index)
+        return self.class.new([]) if index.negative?
+
+        self.class.new(elements[0..index])
+      end
+
+      def before_location(index)
+        return self.class.new([]) if index.negative?
+
+        self.class.new(elements[0...index])
+      end
+
+      def append(element)
+        self.class.new(elements + [element])
+      end
+
+      def drop(count = 1)
+        self.class.new(elements.drop(count))
+      end
+
+      def diff(other)
+        left, right = match_lengths(elements, other.elements)
+        pairwise = left.zip(right)
+        difference = pairwise.drop_while { |e| e[0] == e[1] }
+        difference = difference.empty? ? [[], []] : difference.transpose
+        difference.map { |e| self.class.new(e) }
+      end
+
+      def traverse(initial, &block)
+        initial_context = initial_traversal_context(initial)
+        final_context = elements.inject(initial_context) do |context, element|
+          state = block.call(context[:state], context[:step])
+          next_traversal_context(state, context[:step], element)
+        end
+
+        final_context[:state]
+      end
+
+      def read(object, default: nil)
+        return default if empty?
+
+        result = object.dig(*elements)
+        result.nil? ? default : result
+      rescue NoMethodError, TypeError
+        default
+      end
+
+      def <=>(other)
+        return 0 if self == other
+
+        left, right = diff(other)
+        return -1 if left.empty?
+        return 1 if right.empty?
+
+        compare_numbers_before_symbols(left.first, right.first)
+      end
+
+      def state
+        [elements]
+      end
+
+      private
+
+      class TraversalStep
+        attr_reader(:seen, :element, :remaining)
+
+        def initialize(seen, element, remaining)
+          @seen = seen
+          @element = element
+          @remaining = remaining
+        end
+      end
+
+      def initial_traversal_context(state)
+        {
+          state: state,
+          step: TraversalStep.new(self.class.empty, first, drop(1))
+        }
+      end
+
+      def next_traversal_context(state, position, step)
+        {
+          state: state,
+          step: TraversalStep.new(position.seen.append(step),
+                                  position.remaining.first,
+                                  position.remaining.drop(1))
+        }
+      end
+
+      def compare_numbers_before_symbols(left, right)
+        return -1 if left.is_a?(Numeric) && right.is_a?(Symbol)
+        return 1 if left.is_a?(Symbol) && right.is_a?(Numeric)
+
+        left <=> right
+      end
+
+      def match_lengths(left, right)
+        max_length = [left.count, right.count].max
+        [
+          pad_to_length(left, max_length),
+          pad_to_length(right, max_length)
+        ]
+      end
+
+      def pad_to_length(array, target_length)
+        array.clone.fill(nil, array.count, target_length - array.count)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ruby_terraform/models/path_set.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative '../value_equality'
+
+module RubyTerraform
+  module Models
+    class PathSet
+      class << self
+        def empty
+          new([])
+        end
+
+        def extract_from(object)
+          empty.add_paths_from(object)
+        end
+      end
+
+      extend Forwardable
+
+      include ValueEquality
+
+      def_delegators(:@paths, :empty?)
+
+      attr_reader(:paths)
+
+      def initialize(paths)
+        @paths = paths
+      end
+
+      def add_paths_from(object)
+        self.class.new(paths + extract_paths_from(object))
+      end
+
+      def gaps
+        initial_context = { last: Path.new([]), complete: [] }
+        result = paths.sort.inject(initial_context) do |acc, path|
+          current_path = path
+          last_path = acc[:last]
+          missing_paths = determine_missing_paths(last_path, current_path)
+          updated_paths = acc[:complete] + missing_paths
+
+          { last: current_path, complete: updated_paths }
+        end
+
+        self.class.new(result[:complete])
+      end
+
+      def state
+        [paths]
+      end
+
+      private
+
+      def extract_paths_from(
+        object,
+        current = Path.new([]),
+        accumulator = []
+      )
+        normalised = normalise(object)
+        if normalised.is_a?(Enumerable)
+          normalised.inject(accumulator) do |a, e|
+            extract_paths_from(e[0], current.append(e[1]), a)
+          end
+        else
+          accumulator + [current]
+        end
+      end
+
+      def normalise(object)
+        case object
+        when Array then object.each_with_index.to_a
+        when Hash
+          object.to_a.map do |e|
+            [e[1], e[0].to_sym]
+          end
+        else
+          object
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def determine_missing_paths(last_path, current_path)
+        last_indices = resolve_last_indices(last_path, current_path)
+        current_indices = current_path.list_indices
+
+        current_indices.inject([]) do |acc, current_index|
+          current_location, current_element = current_index
+          last_index =
+            last_indices.find { |index| index[0] == current_location }
+          last_element = last_index[1]
+
+          next(acc) unless current_element.positive?
+
+          start_element = last_element.nil? ? 0 : last_element + 1
+          next(acc) if start_element == current_element
+
+          acc + create_missing_paths(
+            start_element, current_element, current_path, current_location
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength
+      def resolve_last_indices(last_path, current_path)
+        last_indices = last_path.list_indices
+        current_indices = current_path.list_indices
+
+        current_indices.collect do |current_entry|
+          location, current_element = current_entry
+          last_entry = last_indices.find { |index| index[0] == location }
+          last_element = last_entry&.slice(1)
+          reset_entry = [location, nil]
+
+          next(reset_entry) unless last_element
+          next(reset_entry) if current_element < last_element
+
+          current_sub_path = current_path.to_location(location)
+          last_sub_path = last_path.to_location(location)
+
+          unless current_sub_path.same_parent_collection?(last_sub_path)
+            next(reset_entry)
+          end
+
+          last_entry
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def create_missing_paths(from, to, path, location)
+        (from...to).collect do |element|
+          path.before_location(location).append(element)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_terraform/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyTerraform
-  VERSION = '1.7.0.pre.7'
+  VERSION = '1.7.0.pre.8'
 end

data/lib/ruby_terraform.rb

@@ -601,7 +601,7 @@ module RubyTerraform
     # actions.
     #
     # You can optionally save the plan to a file, which you can then pass to
-    # the {#apply} command to perform exactly the actions described in the plan.
+    # the {#read} command to perform exactly the actions described in the plan.
     #
     # @param parameters The parameters used to invoke the command
     # @option parameters [String] :plan The path to a directory containing

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-terraform
 version: !ruby/object:Gem::Version
-  version: 1.7.0.pre.7
+  version: 1.7.0.pre.8
 platform: ruby
 authors:
 - InfraBlocks Maintainers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-07-21 00:00:00.000000000 Z
+date: 2022-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: immutable-struct
@@ -324,6 +324,8 @@ files:
 - lib/ruby_terraform/models/map.rb
 - lib/ruby_terraform/models/objects.rb
 - lib/ruby_terraform/models/omitted_value.rb
+- lib/ruby_terraform/models/path.rb
+- lib/ruby_terraform/models/path_set.rb
 - lib/ruby_terraform/models/plan.rb
 - lib/ruby_terraform/models/resource_change.rb
 - lib/ruby_terraform/models/unknown_value.rb