eco-helpers 2.5.3 → 2.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adb24d7f2036b028bdd81302479211ea745e82abdb6b3a69afa2253e3f8fe444
-  data.tar.gz: 4d149fa100a5a661e4b019aa601c0da3af051ba6e019c77e22b6599c312a4fcb
+  metadata.gz: 444bec4cd18402a38eff718340932ca7d72c9959b865805964b0ec9787d94636
+  data.tar.gz: 97291544f70b525781d81f168ffc86c1d960151e53535a540ac1b7824b9eaf28
 SHA512:
-  metadata.gz: 8583dc7689de13744421db380f3193072f754091a1db6434010568907ff2f4e39d5ed3146b045ab47632cdf0bc5bc8c7e3fe326be466e7b4926f8c8c41344b31
-  data.tar.gz: b34c886f7cde59854838a087fcb10442f14835a87bf3a264534a4a4641a3a1ca2b302352a920f37536cb0686a213ce7d2d06949c2c2bc89e31f3c8e7650ab32e
+  metadata.gz: 02360de987395d801aa1b1fb659dd4b6011c317a21058be33c3283b3a2856c69db519baf6eb85a022f7a2c7c4e826861b108c2cf09aefad3ca57b32d53b45c72
+  data.tar.gz: 402c880d701446c072f6534d4df35b2a104704dc79480e37e5033101df63a8b10baa25257911af1cc84994efe05744b15c608798dbc1637ad268811ca2d7d926

data/CHANGELOG.md

@@ -1,7 +1,23 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.5.3] - 2023-07-xx
+## [2.5.5] - 2023-07-xx
+
+### Added
+### Changed
+### Fixed
+
+## [2.5.4] - 2023-07-27
+
+### Added
+  - SFTP case helpers: `Eco::API::UseCases::GraphQL::Utils::Sftp`
+  - `Eco::Data::Locations::NodeDiff` and `Eco::Data::Locations::NodeDiff::NodeDiffs`
+    - Aim to identify changes in the locations structure
+
+### Changed
+  - Some internal tidy up in `Eco::API::UseCases::GraphQL`
+
+## [2.5.3] - 2023-07-19
 
 ### Added
   - _GraphQL base case_ for **locations structure update**.
@@ -52,7 +68,6 @@ All notable changes to this project will be documented in this file.
   - `Eco::API::Session::Config::Workflow#exit_handle`
     - Allows to define a callback on `SystemExit` (`exit` call).
 
-### Changed
 ### Fixed
   - `Eco::API::Session::Config::Workflow` on `SystemExit` preserve original exit `status` value (i.e. `0`, `1`)
     - It was changing an `exit 1` to be an `exit 0`

data/lib/eco/api/organization/tag_tree.rb

@@ -180,8 +180,8 @@ module Eco
 
         # Returns a plain list form of hash nodes.
         # @return [Array[Hash]] where `Hash` is a plain `node`
-        def as_nodes_json
-          all_nodes.map {|nd| nd.as_json(include_children: false)}
+        def as_nodes_json(&block)
+          all_nodes.map {|nd| nd.as_json(include_children: false, &block)}
         end
 
         # @return [Boolean] `true` if there are tags in the node, `false` otherwise.

data/lib/eco/api/usecases/graphql/helpers/base/case_env.rb

@@ -0,0 +1,15 @@
+module Eco::API::UseCases::GraphQL::Helpers::Base
+  # Basic stuff you would need in any use case
+  module CaseEnv
+    include Eco::Language::AuxiliarLogger
+    attr_reader :session, :options
+
+    def config
+      session.config
+    end
+
+    def simulate?
+      options.dig(:simulate)
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/base.rb

@@ -1,20 +1,12 @@
 module Eco::API::UseCases::GraphQL::Helpers
   module Base
-    include Eco::Language::AuxiliarLogger
-    attr_reader :session, :options
+    require_relative 'base/case_env'
+    include Eco::API::UseCases::GraphQL::Helpers::Base::CaseEnv
 
     def graphql
       @graphql ||= session.api(version: :graphql)
     end
 
-    def config
-      session.config
-    end
-
-    def simulate?
-      options.dig(:simulate)
-    end
-
     # Keep a copy of the requests/responses for future reference
     def backup(data, type:)
       dry_run   = simulate? ? "_dry_run" : ""
@@ -24,7 +16,7 @@ module Eco::API::UseCases::GraphQL::Helpers
     end
 
     def exit_error(msg)
-      logger.error(msg)
+      log(:error) { msg }
       exit(1)
     end
   end

data/lib/eco/api/usecases/graphql/helpers/location/command.rb

@@ -3,17 +3,25 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
     include Eco::Language::AuxiliarLogger
     include Eco::API::UseCases::GraphQL::Helpers::Location::Base
 
-    # Prevents each request from timing out
-    COMMANDS_PER_PAGE  = 45
-    # Whether to stop or continue on command fail
-    FORCE_CONTINUE     = false
+    DEFAULT_COMMANDS_PER_PAGE = 45
+    DEFAULT_FORCE_CONTINUE    = false
 
+    # Prevents each request from timing out
     def commands_per_page
-      self.class::COMMANDS_PER_PAGE
+      if self.class.const_defined?(:COMMANDS_PER_PAGE)
+        self.class::COMMANDS_PER_PAGE
+      else
+        DEFAULT_COMMANDS_PER_PAGE
+      end
     end
 
+    # Whether to stop or continue on command fail
     def force_continue?
-      self.class::FORCE_CONTINUE
+      if self.class.const_defined?(:FORCE_CONTINUE)
+        self.class::FORCE_CONTINUE
+      else
+        DEFAULT_FORCE_CONTINUE
+      end
     end
 
     # With given the commands, it generates the input of the endpoint mutation.

data/lib/eco/api/usecases/graphql/utils/sftp.rb

@@ -0,0 +1,74 @@
+module Eco::API::UseCases::GraphQL::Utils
+  module Sftp
+    include Eco::API::UseCases::GraphQL::Helpers::Base::CaseEnv
+
+
+    def remote_subfolder
+      nil
+    end
+
+    def remote_folder(subfolder = remote_subfolder)
+      "#{sftp_config.remote_folder}/#{subfolder || ''}"
+    end
+
+    def sftp_group_id
+      if self.class.const_defined?(:SFTP_GROUP)
+        self.class.const_get(:TARGET_STRUCTURE_ID)
+      elsif group_id = options.dig(:sftp, :group)
+        group_id
+      end
+    end
+
+    def upload(local_file, remote_folder: self.remote_folder, gid: sftp_group_id)
+      return false unless local_file && File.exists?(local_file)
+      dest_file = "#{remote_folder}/#{File.basename(local_file)}"
+      res       = sftp_session.upload!(local_file, dest_file)
+      attrs     = sftp_session.stat!(dest_file)
+      if gid && gid != attrs.gid
+        stat_res = sftp_session.setstat!(dest_file, {permissions: 0660, uid: attrs.uid, gid: gid})
+      end
+      logger.info("Uploaded '#{local_file}' (#{res})")
+    end
+
+    def ensure_remote_empty
+      files = with_remote_files
+      unless files.empty?
+        msg  = "There are still files in the remote folder that will be deleted: '#{remote_folder}':\n"
+        msg += "  • " + files.map do |file|
+          file.longname
+        end.join("\n  • ") + "\n"
+        session.prompt_user("Do you want to proceed to delete? (Y/n):", explanation: msg, default: "Y", timeout: 3) do |response|
+          if response.upcase.start_with?("Y")
+            files.each do |file|
+              remote_full_path = to_remote_path(file.name)
+              res = sftp_session.remove(remote_full_path)
+              logger.info("Deleted remote file: '#{remote_full_path}' (#{res})")
+            end
+          end
+        end
+      end
+    end
+
+    def with_remote_files
+      sftp.files(remote_folder).each do |remote_file|
+        yield(remote_file) if block_given?
+      end
+    end
+
+    def to_remote_path(file, subfolder: nil)
+      remote_folder(subfolder) + "/" + file
+    end
+
+    def sftp_config
+      session.config.sftp
+    end
+
+    def sftp_session
+      sftp.sftp_session
+    end
+
+    def sftp
+      session.sftp
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/utils.rb

@@ -0,0 +1,6 @@
+module Eco::API::UseCases::GraphQL
+  module Utils
+  end
+end
+
+require_relative 'utils/sftp'

data/lib/eco/api/usecases/graphql.rb

@@ -8,5 +8,6 @@ module Eco
 end
 
 require_relative 'graphql/helpers'
+require_relative 'graphql/utils'
 require_relative 'graphql/base'
 require_relative 'graphql/samples'

data/lib/eco/data/files/helpers.rb

@@ -75,11 +75,11 @@ module Eco
           Dir.exist?(path) || Dir.exist?(File.expand_path(path))
         end
 
-        def timestamp(timestamp_pattern = DEFAULT_TIMESTAMP_PATTERN)
-          Time.now.strftime(timestamp_pattern)
+        def timestamp(timestamp_pattern = DEFAULT_TIMESTAMP_PATTERN, date = Time.now)
+          date.strftime(timestamp_pattern)
         end
 
-        def timestamp_file(filename, timestamp_pattern = DEFAULT_TIMESTAMP_PATTERN)
+        def timestamp_file(filename, timestamp_pattern =DEFAULT_TIMESTAMP_PATTERN)
           file_pattern = Eco::Data::Files::FilePattern.new(filename)
           file_pattern.resolve(start: timestamp(timestamp_pattern) + '_')
         end

data/lib/eco/data/hashes/array_diff.rb

@@ -3,47 +3,16 @@ module Eco
     module Hashes
       class ArrayDiff
         extend Eco::Language::Models::ClassHelpers
-
-        class << self
-          def key(value = nil)
-            return @key unless value
-            @key = value.to_s
-          end
-
-          def key?
-            !!@key
-          end
-
-          def compare(*attrs)
-            compared_attrs.push(*attrs.map(&:to_s)).uniq!
-          end
-
-          def case_sensitive(value = nil)
-            @case_sensitive = false unless instance_variable_defined?(:@case_sensitive)
-            return @case_sensitive unless value
-            @case_sensitive = !!value
-          end
-
-          def case_sensitive?
-            !!@case_sensitive
-          end
-
-          def compared_attrs
-            @compared_attrs ||= []
-            @compared_attrs
-          end
-        end
+        # We can change the `DiffResult` class (items)
+        class_resolver :diff_result_class, "Eco::Data::Hash::DiffResult"
 
         include Eco::Language::AuxiliarLogger
 
         attr_reader :source1, :source2
         attr_reader :src_h1,  :src_h2
 
-        class_resolver :diff_result_class, "Eco::Data::Hash::DiffResult"
-
-        def initialize(source1, source2, logger: nil, **kargs)
+        def initialize(source1, source2, logger: nil)
           @logger  = logger if logger
-          @options = kargs
           @source1 = source1
           @source2 = source2
           @src_h1  = by_key(source1)
@@ -67,14 +36,11 @@ module Eco
           !diffs.empty?
         end
 
+        # All the items that contain the diff of a node.
+        # @return [Array<Eco::Data::Hash::DiffResult>]
         def source_results
           @source_results ||= paired_sources.each_with_object([]) do |(src1, src2), res|
-            args = {
-              key:            key,
-              compare:        compared_attrs,
-              case_sensitive: case_sensitive?
-            }
-            res << diff_result_class.new(src1, src2, **args)
+            res << diff_result_class.new(src1, src2)
           end
         end
 
@@ -91,35 +57,23 @@ module Eco
           all_keys.map {|key| [src_h1[key], src_h2[key]]}
         end
 
+        # @return [String] the `key` attribute of `diff_result_class`
         def key
-          @key ||= options_or(:key) do
-            self.class.key
-          end.tap do |k|
-            raise "missing main key attr to pair records. Given: #{k}" unless k.is_a?(String)
+          diff_result_class.key.tap do |k|
+            raise "#{diff_result_class}: missing main key attr to pair records. Given: #{k}" unless k.is_a?(String)
           end
         end
 
         def case_sensitive?
-          @case_sensitive ||= options_or(:case_sensitive) { self.class.case_sensitive? }
+          diff_result_class.case_sensitive?
         end
 
         def compared_attrs
-          @compared_attrs ||= options_or(:compared_attrs) do
-            self.class.compared_attrs
-          end.yield_self do |attrs|
-            raise "compared_attrs should be an array" unless attrs.is_a?(Array)
-            attrs.map(&:to_s)
-          end
+          diff_result_class.compared_attrs.map(&:to_s)
         end
 
         private
 
-        def options_or(opt)
-          opt = opt.to_sym
-          return @options[opt] if @options.key?(opt)
-          yield
-        end
-
         def symbolize_keys(hash)
           hash.each_with_object({}) do |(k, v), h|
             h[k.to_sym] = v

data/lib/eco/data/hashes/diff_meta.rb

@@ -0,0 +1,52 @@
+module Eco
+  module Data
+    module Hashes
+      module DiffMeta
+        class << self
+          def included(base)
+            super(base)
+            base.extend ClassMethods
+          end
+        end
+
+        module ClassMethods
+          # @param value [String, NilClass]
+          # @return [String] the attribute that is key of the node diff elements.
+          def key(value = nil)
+            return @key unless value
+            @key = value.to_s
+          end
+
+          # @return [Boolean] is there a `key` attribute defined?
+          def key?
+            !!@key
+          end
+
+          # @param attrs [Array<Symbol>, Array<String>]
+          # @return [Array<String>] the comparable attributes
+          def compare(*attrs)
+            compared_attrs.push(*attrs.map(&:to_s)).uniq!
+            compared_attrs
+          end
+
+          # Whether or not the diff calc of a node should be done case sensitive or insensitive.
+          def case_sensitive(value = nil)
+            @case_sensitive = false unless instance_variable_defined?(:@case_sensitive)
+            return @case_sensitive unless value
+            @case_sensitive = !!value
+          end
+
+          # @return [Boolean] are comparisons of values done case sensitive?
+          def case_sensitive?
+            !!@case_sensitive
+          end
+
+          # @return [Array<String>] the comparable attributes
+          def compared_attrs
+            @compared_attrs ||= []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/data/hashes/diff_result.rb

@@ -2,19 +2,32 @@ module Eco
   module Data
     module Hashes
       class DiffResult
-        attr_reader :key
+        extend Eco::Language::Models::ClassHelpers
+        include Eco::Data::Hashes::DiffMeta
+
+        inheritable_class_vars :key, :compared_attrs, :case_sensitive
+
         attr_reader :src1, :src2
 
-        # @param compare [Array<String>, sym]
-        #   - `:all` compares the matching attrs between both hashes only
-        def initialize(src1, src2, key:, compare: :all, case_sensitive: false)
-          @key     = key
-          @compare = compare
-          @case_sensitive = case_sensitive
+        def initialize(src1, src2)
           @src1 = src1
           @src2 = src2
         end
 
+        def key
+          self.class.key
+        end
+
+        def case_sensitive?
+          self.class.case_sensitive?
+        end
+
+        def dup(src1: nil, src2: nil)
+          src1 ||= self.src1
+          src2 ||= self.src2
+          self.class.new(src1.dup, src2.dup)
+        end
+
         def new?
           !src1 && !!src2
         end
@@ -27,35 +40,39 @@ module Eco
           !new? && !del? && diff?
         end
 
+        # @note `diff_attrs` may not include the `key` attribute
+        #   This is always included via `new?` (new key value) and `del?` (missing key value)
+        # @return [Boolean] was there any change?
         def diff?
           new? || del? || !diff_attrs.empty?
         end
 
-        # Is the key attr value changing?
+        # Is the `key` attr value changing?
         def key?
           !(new? || del?) && diff_attr?(key)
         end
 
+        # Is `attr` part of the attributes that change?
         def diff_attr?(attr)
           return true if new?
           return true if del?
           diff_attrs.include?(attr.to_s)
         end
 
+        # @return [Value] the current value of `attr` (in `src2`)
         def attr(attr)
           return nil unless src2
           src2[attr.to_s]
         end
 
+        # @return [Value] the previous value of `attr` (in `src1`)
         def attr_prev(attr)
           return nil unless src1
           src1[attr.to_s]
         end
 
-        def previous(attr)
-          src1 && src1[attr.to_s]
-        end
-
+        # @note the `key` attribute will always be added (even if there's no change)
+        # @return [Hash] hash with the differences as per `src2`
         def diff_hash
           target_attrs = [key] | compared_attrs
           return src2.slice(*target_attrs) if new?
@@ -63,12 +80,14 @@ module Eco
           src2.slice(key, *diff_attrs)
         end
 
+        # @return [Array<Symbol>] hash with the differences as per `src2`
         def diff_attrs
           @diff_attrs ||= comparable_attrs.each_with_object([]) do |attr, out|
             out << attr unless eq?(src1[attr], src2[attr])
           end
         end
 
+        # @return [Boolean] whether `val1` is equal to `val2`
         def eq?(val1, val2)
           return true  if val1 == val2
           return false if case_sensitive?
@@ -76,25 +95,18 @@ module Eco
           val1.upcase == val2.upcase
         end
 
-        def case_sensitive?
-          !!@case_sensitive
-        end
-
+        # @note when is `new?` or to be deleted (`del?`), it returns empty array.
+        # @return [Array<String>] the set of attributes that are comparable in this instance.
         def comparable_attrs
           return [] if new? || del?
           compared_attrs
         end
 
+        # @return [Array<String>] the set of attributes that are comparable in this class.
         def compared_attrs
-          return @compared_attrs if instance_variable_defined?(:@compared_attrs)
-          @compared_attrs = \
-            if @compare == :all
-              src1.keys & src2.keys
-            elsif @compare.is_a?(Array)
-              @compare.map(&:to_s)
-            else
-              raise "Expecting 'compare' to be sym (:all) or Array<String>. Given: #{@compare.class}"
-            end
+          comp_attrs = self.class.compared_attrs.map(&:to_s).uniq
+          return comp_attrs unless comp_attrs.empty?
+          (src1&.keys || []) & (src2&.keys || [])
         end
       end
     end

data/lib/eco/data/hashes.rb

@@ -5,5 +5,6 @@ module Eco
   end
 end
 
+require_relative 'hashes/diff_meta'
 require_relative 'hashes/diff_result'
 require_relative 'hashes/array_diff'

data/lib/eco/data/locations/node_diff/accessors.rb

@@ -0,0 +1,46 @@
+class Eco::Data::Locations::NodeDiff
+  module Accessors
+    class << self
+      def included(base)
+        super(base)
+        base.extend Eco::Language::Models::ClassHelpers
+        base.extend ClassMethods
+        base.inheritable_class_vars :exposed_attrs
+      end
+    end
+
+    module ClassMethods
+      # Creates the defined accessor attributes against `NodeDiff`
+      # It also creates a method with question mark that evaluates true if **any** the attr changed.
+      # @note the defined attributes are expected to be the keys within
+      #   the source Hashes that are being compared.
+      # @note accessing `src1` (prev) attributes, will have it's method as `prev_[attrName]`
+      def attr_expose(*attrs)
+        attrs.each do |attr|
+          meth  = attr.to_sym
+          methp = "prev_#{meth}".to_sym
+          methq = "diff_#{meth}?".to_sym
+
+          define_method meth do
+            attr(meth)
+          end
+
+          define_method methp do
+            attr_prev(meth)
+          end
+
+          exposed_attrs |= [meth]
+
+          define_method methq do
+            diff_attr?(meth)
+          end
+        end
+      end
+
+      # Keeps track on what attributes have been exposed.
+      def exposed_attrs
+        @exposed_attrs ||= []
+      end
+    end
+  end
+end

data/lib/eco/data/locations/node_diff/nodes_diff.rb

@@ -0,0 +1,90 @@
+class Eco::Data::Locations::NodeDiff
+  # Adjusts ArrayDiff for Nodes diffs in a location structure
+  class NodesDiff < Eco::Data::Hashes::ArrayDiff
+    extend Eco::Data::Locations::NodeDiff::Selectors
+
+    SELECTORS = %i[id name id_name insert unarchive update move archive]
+    selector *SELECTORS
+
+    class_resolver :diff_result_class, Eco::Data::Locations::NodeDiff
+    attr_reader :original_tree
+
+    def initialize(*args, original_tree:, **kargs, &block)
+      super(*args, **kargs, &block)
+      @original_tree = original_tree
+    end
+
+    def diffs
+      @diffs ||= super.select do |res|
+        res.unarchive? || res.id_name? || res.insert? || res.move? || res.archive?
+      end
+    end
+
+    def diffs_details
+      section = '#' * 10
+      msg  = ''
+      if insert?
+        msg << " #{section}  I N S E R T S  #{section}\n"
+        msg << insert.map {|d| d.diff_hash.pretty_inspect}.join('')
+      end
+
+      if update?
+        msg << "\n #{section}  U P D A T E S  #{section}\n"
+        update.each do |d|
+          flags  = ''
+          #flags << 'i' if d.id?
+          flags << 'n' if d.diff_name?
+          flags << 'm' if d.move?
+          flags << 'u' if d.unarchive?
+          msg << "<< #{flags} >> "
+          msg << d.diff_hash.pretty_inspect
+        end
+      end
+
+      if archive?
+        msg << "\n #{section}  A R C H I V E S  #{section}\n"
+        msg << archive.map {|d| d.diff_hash.pretty_inspect}.join('')
+      end
+
+      msg
+    end
+
+    def diffs_summary
+      return "There were no differences identified" if diffs.empty?
+      msg  = "Identified #{diffs.count} differences:\n"
+      msg << when_present(insert, '') do |count|
+        "  • #{count} nodes to insert\n"
+      end
+      msg << when_present(update, '') do |count|
+        "  • #{count} nodes to update\n"
+      end
+      # msg << when_present(id, '') do |count|
+      #   "    • #{count} nodes to change id\n"
+      # end
+      msg << when_present(name, '') do |count|
+        "    • #{count} nodes to change name\n"
+      end
+      msg << when_present(move, '') do |count|
+        "    • #{count} nodes to move\n"
+      end
+      msg << when_present(unarchive, '') do |count|
+        "    • #{count} nodes to unarchive\n"
+      end
+      msg << when_present(archive, '') do |count|
+        "  • #{count} nodes to archive\n"
+      end
+      msg
+    end
+
+    private
+
+    def when_present(list, default = nil)
+      count = list.count
+      if count > 0
+        yield(count)
+      else
+        default
+      end
+    end
+  end
+end

data/lib/eco/data/locations/node_diff/selectors.rb

@@ -0,0 +1,20 @@
+class Eco::Data::Locations::NodeDiff
+  module Selectors
+    # Creates selector methods on `diffs` (nodes that changed)
+    # It also creates a method with question mark that evaluates true if **any** diff matches.
+    # @note the selector method name with a question mark should exist in the `diff_result_class`
+    def selector(*attrs)
+      attrs.each do |attr|
+        meth  = attr.to_sym
+        methq = "#{meth}?".to_sym
+        define_method meth do
+          diffs.select(&methq)
+        end
+
+        define_method methq do
+          diffs.any(&methq)
+        end
+      end
+    end
+  end
+end

data/lib/eco/data/locations/node_diff.rb

@@ -0,0 +1,55 @@
+module Eco::Data::Locations
+  # Differences between node before and after
+  # @note this works with `Hash` object where basic keys are:
+  #   - `nodeId`
+  #   - `name`
+  #   - `parentId`
+  #   - `archived`
+  # @note other properties can be part of the `Hash` although
+  #   they may not influence the results.
+  class NodeDiff < Eco::Data::Hashes::DiffResult
+    require_relative 'node_diff/accessors'
+    require_relative 'node_diff/selectors'
+    require_relative 'node_diff/nodes_diff'
+
+    include Eco::Data::Locations::NodeDiff::Accessors
+
+    key     :nodeId
+    compare :parentId, :name, :archived
+    case_sensitive false
+
+    attr_expose :nodeId, :name, :parentId, :archived
+
+    alias_method :insert?, :new?
+
+    alias_method :diff_name_src?, :diff_name?
+    # Has the property `name` changed?
+    def diff_name?
+      diff_name_src? && update?
+    end
+    alias_method :name?, :diff_name?
+    alias_method :id? , :diff_name? # currently a change of name is a change of id (tag)
+    #alias_method :id? , :key?
+    #alias_method :nodeId? , :id?
+
+    # Has any of `id` or `name` properties changed?
+    def id_name?
+      id? || diff_name?
+    end
+
+    # Has the parent id changed?
+    def move?
+      update? && diff_parentId?
+    end
+
+    # Has the `archived` property changed and it was `true`?
+    def unarchive?
+      !archived && update? && diff_archived?
+    end
+
+    # Has the `archived` property changed and it was `false`?
+    def archive?
+      !prev_archived && (del? || archived)
+    end
+  end
+end

data/lib/eco/data/locations/node_level.rb

@@ -18,13 +18,10 @@ module Eco::Data::Locations
 
     attr_accessor :parentId
 
-    def nodeId
-      id
-    end
-
     def id
       tag.upcase
     end
+    alias_method :nodeId, :id
 
     def name
       tag

data/lib/eco/data/locations/node_plain.rb

@@ -17,6 +17,8 @@ module Eco::Data::Locations
     def id
       clean_id(super)
     end
+    # backwards compatibility
+    alias_method :tag, :id
 
     def name
       super || self.id
@@ -25,10 +27,5 @@ module Eco::Data::Locations
     def parentId
       self.parent_id
     end
-
-    # backwards compatibility
-    def tag
-      id
-    end
   end
 end

data/lib/eco/data/locations.rb

@@ -9,4 +9,5 @@ require_relative 'locations/convert'
 require_relative 'locations/node_base'
 require_relative 'locations/node_plain'
 require_relative 'locations/node_level'
+require_relative 'locations/node_diff'
 require_relative 'locations/dsl'

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.5.3"
+  VERSION = "2.5.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.5.3
+  version: 2.5.4
 platform: ruby
 authors:
 - Oscar Segura
@@ -592,6 +592,7 @@ files:
 - lib/eco/api/usecases/graphql/base.rb
 - lib/eco/api/usecases/graphql/helpers.rb
 - lib/eco/api/usecases/graphql/helpers/base.rb
+- lib/eco/api/usecases/graphql/helpers/base/case_env.rb
 - lib/eco/api/usecases/graphql/helpers/location.rb
 - lib/eco/api/usecases/graphql/helpers/location/base.rb
 - lib/eco/api/usecases/graphql/helpers/location/command.rb
@@ -603,6 +604,8 @@ files:
 - lib/eco/api/usecases/graphql/samples/location/command/dsl.rb
 - lib/eco/api/usecases/graphql/samples/location/command/results.rb
 - lib/eco/api/usecases/graphql/samples/location/dsl.rb
+- lib/eco/api/usecases/graphql/utils.rb
+- lib/eco/api/usecases/graphql/utils/sftp.rb
 - lib/eco/api/usecases/ooze_cases.rb
 - lib/eco/api/usecases/ooze_cases/export_register_case.rb
 - lib/eco/api/usecases/ooze_samples.rb
@@ -670,6 +673,7 @@ files:
 - lib/eco/data/fuzzy_match/string_helpers.rb
 - lib/eco/data/hashes.rb
 - lib/eco/data/hashes/array_diff.rb
+- lib/eco/data/hashes/diff_meta.rb
 - lib/eco/data/hashes/diff_result.rb
 - lib/eco/data/locations.rb
 - lib/eco/data/locations/convert.rb
@@ -681,6 +685,10 @@ files:
 - lib/eco/data/locations/node_base/serial.rb
 - lib/eco/data/locations/node_base/tag_validations.rb
 - lib/eco/data/locations/node_base/treeify.rb
+- lib/eco/data/locations/node_diff.rb
+- lib/eco/data/locations/node_diff/accessors.rb
+- lib/eco/data/locations/node_diff/nodes_diff.rb
+- lib/eco/data/locations/node_diff/selectors.rb
 - lib/eco/data/locations/node_level.rb
 - lib/eco/data/locations/node_level/builder.rb
 - lib/eco/data/locations/node_level/cleaner.rb