eco-helpers 2.6.4 → 2.7.1

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

@@ -0,0 +1,131 @@
+module Eco
+  module Data
+    module Hashes
+      class DiffResult
+        module Meta
+          class << self
+            def included(base)
+              super(base)
+              base.extend Eco::Language::Models::ClassHelpers
+              base.extend ClassMethods
+              base.inheritable_class_vars :key, :compared_attrs, :case_sensitive
+            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, when_present: false)
+              if when_present
+                compared_attrs_when_present.push(*attrs.map(&:to_s)).uniq!
+                compared_attrs_when_present
+              else
+                compared_attrs.push(*attrs.map(&:to_s)).uniq!
+                compared_attrs
+              end
+            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
+
+            # Same as `compared_attrs` but they only get compared when present
+            # in both data sources
+            # @note if present in one source but not in another,
+            #   that attribute will NOT generate a diff.
+            def compared_attrs_when_present
+              @compared_attrs_when_present ||= []
+            end
+
+            def all_compared_attrs
+              compared_attrs | compared_attrs_when_present
+            end
+
+            def compared_attr_when_present?(attr)
+              compared_attrs_when_present.include?(attr)
+            end
+          end
+
+          def key
+            self.class.key.dup
+          end
+
+          def case_sensitive?
+            self.class.case_sensitive?
+          end
+
+          def all_compared_attrs
+            self.class.all_compared_attrs.dup.compact.map(&:to_s)
+          end
+
+          private
+
+          # @return [Boolean] whether `val1` is equal to `val2`
+          def eq?(val_1, val_2)
+            return eq_ary?(val_1, val_2) if [val_1, val_2].any? {|v| v.is_a?(Array)}
+            return true  if val_1 == val_2
+            return false if case_sensitive?
+            return false unless val_2 && val_1
+            val_1.upcase == val_2.upcase
+          end
+
+          # Compares two arrays
+          # @note
+          #   1. Order does NOT matter
+          #   2. Repeated elements are treated as one
+          def eq_ary?(val_1, val_2)
+            return false unless [val_1, val_2].all? {|v| v.is_a?(Array)}
+            return true  if val_1 == val_2
+            v_1    = case_sensitive?? val_1 : val_1.map {|v| v&.upcase}
+            v_2    = case_sensitive?? val_2 : val_2.map {|v| v&.upcase}
+            joined = (v_1 | v_2)
+            (joined & v_1) == (joined & v_2)
+          end
+
+          # Hash access
+          # @note DSL to be able to modify behaviour
+          #   (i.e. indifferent access for camel and snake case keys)
+          def get_attr(src, key)
+            return nil unless src
+            src[key.to_s]
+          end
+
+          def slice_attrs(src, *keys)
+            return nil unless src
+            src.slice(*keys)
+          end
+
+          def key_present?(src, key)
+            return false unless src
+            src.key?(key)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,53 +1,68 @@
+require_relative 'diff_result/meta'
+
 module Eco
   module Data
     module Hashes
       class DiffResult
-        extend Eco::Language::Models::ClassHelpers
-        include Eco::Data::Hashes::DiffMeta
-
-        inheritable_class_vars :key, :compared_attrs, :case_sensitive
+        include Eco::Data::Hashes::DiffResult::Meta
 
-        attr_reader :src1, :src2
+        attr_reader :src_1, :src_2
 
-        def initialize(src1, src2)
-          @src1 = src1
-          @src2 = src2
+        def initialize(src_1, src_2)
+          @src_1 = src_1
+          @src_2 = src_2
         end
 
-        def key
-          self.class.key
+        # @return [Value] the current value of `attr` (in `src_2`)
+        def attr(attr)
+          get_attr(src_2, attr)
         end
 
-        def case_sensitive?
-          self.class.case_sensitive?
+        # @return [Value] the previous value of `attr` (in `src_1`)
+        def attr_prev(attr)
+          get_attr(src_1, attr)
         end
 
-        def dup(src1: nil, src2: nil)
-          src1 ||= self.src1
-          src2 ||= self.src2
-          self.class.new(src1.dup, src2.dup)
+        # Deduplication to prevent mutability when manipulation is required.
+        def dup(src_1: nil, src_2: nil)
+          src_1 ||= self.src_1
+          src_2 ||= self.src_2
+          self.class.new(src_1.dup, src_2.dup)
         end
 
         def new?
-          !src1 && !!src2
+          src_2 && !src_1
         end
 
         def del?
-          !!src1 && !src2
+          src_1 && !src_2
         end
 
         def update?
           !new? && !del? && diff?
         end
 
+        # Uniq access point to identify attrs that have changed.
+        # @note when is `new?` or to be deleted (`del?`), there's nothing to compare.
+        # @return [Array<Symbol>] hash with the list of attrs that are different
+        #   between `src_1` and `src_2`.
+        def diff_attrs
+          return (@diff_attrs = []) if new? || del?
+          @diff_attrs ||= all_compared_attrs.each_with_object([]) do |kattr, out|
+            next unless comparable_attr?(kattr)
+            out << kattr unless eq?(attr_prev(kattr), attr(kattr))
+          end
+        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?
+          new? || del? || diff_attrs.any?
         end
 
-        # Is the `key` attr value changing?
+        # Is the `key` attr value updated?
+        # @note that `new?` and `del?` won't be considered as key's change
         def key?
           !(new? || del?) && diff_attr?(key)
         end
@@ -59,54 +74,47 @@ module Eco
           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
-
         # @note the `key` attribute will always be added (even if there's no change)
-        # @return [Hash] hash with the differences as per `src2`
+        # @return [Hash] hash with the differences as per `src_2`
         def diff_hash
-          target_attrs = [key] | compared_attrs
-          return src2.slice(*target_attrs) if new?
-          return src1.slice(key)           if del?
-          src2.slice(key, *diff_attrs)
+          target_attrs = [key] | all_compared_attrs
+          return slice_attrs(src_2, *target_attrs) if new?
+          return slice_attrs(src_1, key)           if del?
+          slice_attrs(src_2, 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])
+        # Uniq access point to scope if an `attr` is in the scope of the diff compare.
+        # Set of attributes that are general target to identify differences
+        # between both sources.
+        # @note When the class `all_compared_attrs` has not been deefined,
+        #   it uses `all_source_keys`
+        # @return [Array<String>] the set of attributes that are comparable in this class.
+        def all_compared_attrs
+          super().map(&:to_s).uniq.tap do |attrs|
+            return all_source_keys unless attrs.any?
           end
         end
 
-        # @return [Boolean] whether `val1` is equal to `val2`
-        def eq?(val1, val2)
-          return true  if val1 == val2
-          return false if case_sensitive?
-          return false if !val2 || !val1
-          val1.upcase == val2.upcase
+        # All the keys that the data comes with
+        def all_source_keys
+          (src_1&.keys || []) & (src_2&.keys || [])
         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
+        private
+
+        # Refinement over `all_compared_attrs`, provided that those that must
+        # be comparable only **when present** in both, are filtered out when
+        # that is not the case.
+        def comparable_attr?(attr)
+          attr = attr.to_s
+          return false unless all_compared_attrs.include?(attr)
+          return true  unless self.class.compared_attr_when_present?(attr)
+          key_present_in_both?(attr)
         end
 
-        # @return [Array<String>] the set of attributes that are comparable in this class.
-        def compared_attrs
-          comp_attrs = self.class.compared_attrs.map(&:to_s).uniq
-          return comp_attrs unless comp_attrs.empty?
-          (src1&.keys || []) & (src2&.keys || [])
+        # Is the key `attr` present in both sources?
+        def key_present_in_both?(attr)
+          key_present?(src_1, attr) && key_present?(src_2, attr)
         end
       end
     end

data/lib/eco/data/hashes/sanke_camel_indifferent_access.rb

@@ -0,0 +1,278 @@
+module Eco
+  module Data
+    module Hashes
+      module SnakeCamelIndifferentAccess
+        include Eco::Data::Strings::SnakeCase
+        include Eco::Data::Strings::CamelCase
+
+        private
+
+        # options are: `:snake_case` and `:camel_case`
+        def hash_isca_preferred
+          @hash_isca_preferred ||= :snake_case
+        end
+
+        # Sets `value` for `key`. The end result is that get on `key` gives `value`,
+        # no matter the original case form of `key`. This might entail to resolve
+        # the `key` if its in its multiple case forms.
+        # @note if an internal merge resolve of the `key` happens, it's done in the
+        #   preferred case form.
+        # @note if once resolved the internal merge, only the preferred case form of
+        #   the key remains, that key form will be used to do the `set` operation,
+        #   no matter the original case form of the `key` argument.
+        # @param keep_case [Boolean] whether only the preferred case form of key
+        #   should be used or rather try to keep its case.
+        def hash_isca_set(hash, key, value, prefer: nil, keep_case: false, residual: {})
+          # (pp hash) if key == 'barCamel'
+          hash_isca_resolve_key!(hash, key, prefer: prefer, residual: residual)
+          # (pp hash) if key == 'barCamel'
+
+          target_key = hash_isca_to_correct_key(key, keep_case: keep_case, prefer: prefer)
+
+          # puts "potential_target_key: '#{key}' => '#{target_key}'" if key == 'barCamel'
+
+          if keep_case
+            # Spot the existing target key
+            ext_keys   = hash_isca_existing_correct_keys(hash, key, prefer: prefer)
+            target_key = ext_keys.first unless ext_keys.empty? || ext_keys.include?(target_key)
+          end
+
+          puts "final target_key: '#{key}' => '#{target_key}'" if key == 'barCamel'
+
+          hash[target_key] = value
+          hash_isca_resolve_key!(hash, key, prefer: prefer, residual: residual)
+
+          pp hash if key == 'barCamel'
+          puts "*" * 20 if key == 'barCamel'
+
+          value
+        end
+
+        # Retrieves the value of key `key`
+        # @note
+        #   1. when both forms of the key exist, it uses the preferred case form !!
+        #   2. when the key exists only in its form it uses it
+        #   3. when only the other form of the key is present it uses it
+        def hash_isca_get(value, key, prefer: nil)
+          hash = value.to_h
+          keys = hash_isca_double_key(key, prefer: prefer)
+          keys = keys.find_all {|k| hash.key?(k)}
+          return nil unless keys.any?
+          hash[keys.first]
+        end
+
+        # Slice generates a hash with `keys`, regardless the original case form
+        # of those keys in the source hash (value).
+        # @note values are retrieved as per `hash_isca_get` rules.
+        def hash_isca_slice(value, *keys, prefer: nil)
+          hash   = value.to_h
+          values = keys.map do |key|
+            hash_isca_get(hash, key, prefer: prefer)
+          end
+          keys.zip(values).to_h
+        end
+
+        # Delegates to `hash_isca_get`
+        def hash_isca_values_at(value, *keys, prefer: nil)
+          hash = value.to_h
+          keys.map do |key|
+            hash_isca_get(hash, key, prefer: prefer)
+          end
+        end
+
+        # The values of the uniq keys, where among keys with multiple case form
+        # the preferred form case is used to retrieve the value.
+        # @note residual named arg was not added just to keep consistent its hash type.
+        def hash_isca_values(value, prefer: nil)
+          hash = value.to_h
+          hash.values_at(*hash_isca_uniq_keys(hash, prefer: prefer))
+        end
+
+        # Enumerator
+        def hash_isca_each(value, prefer: nil, residual: {}, &block)
+          return to_enum(:hash_isca_each, value, prefer: prefer, residual: residual) unless block_given?
+          hash = value.to_h
+          keys = hash_isca_uniq_keys(hash, prefer: prefer)
+          residual.merge!(hash.slice(*(hash.keys - keys)))
+          hash.slice(*keys).each(&block)
+        end
+
+        # @note due to simplicity and consistency, for matching merging keys
+        #   it resolves internal key conflicts on both (source and other).
+        #   This internal resolve is ONLY applied to common keys (between source and other).
+        def hash_isca_merge!(hash_1, value_2, prefer: nil, residual: {})
+          hash_1.tap do
+            hash_2 = hash_isca_internal_merge_resolve!(value_2.to_h.dup, residual: (res_2 = {}))
+            hash_isca_each(hash_2, prefer: prefer, residual: residual) do |key, value|
+              hash_isca_set(hash_1, key, value, prefer: prefer, keep_case: true, residual: residual)
+            end
+            residual.merge!(res_2)
+          end
+        end
+
+        def hash_isca_merge(value_1, value_2, prefer: nil, residual: {})
+          hash_isca_merge!(value_1.to_h.dup, value_2, prefer: prefer, residual: residual)
+        end
+
+        # Keys may not necessarily come in its camel or snake case version.
+        # This method ensures they are.
+        # @note modus operandi:
+        #   1. will preserve all the keys that were in a correct case form.
+        #   2. where it can't preserve, the preferred form will be used instead.
+        #   3. where merge conflicts exist, the value associatd with the key that
+        #     was originally in the correc case form will prevail.
+        def hash_isca_correct_keys!(hash, prefer: nil, residual: {})
+          hash.dup.each do |key, _val|
+            ckey = hash_isca_to_correct_key(key, keep_case: true, prefer: prefer)
+            next                             if ckey == key
+            residual[key] = hash.delete(key) if hash.key?(ckey)
+          end
+          hash
+        end
+
+        # Same as `hash_isca_correct_keys!` but only for one single key.
+        def hash_isca_correct_key!(hash, key, prefer: nil, residual: {})
+          tkey = hash_isca_to_correct_key(key, keep_case: true, prefer: prefer)
+
+          hash.dup.each do |k_c, _val|
+            ckey = hash_isca_to_correct_key(k_c, keep_case: true, prefer: prefer)
+            next                             unless ckey == tkey
+            next                             if ckey == k_c
+            residual[k_c] = hash.delete(k_c) if hash.key?(ckey)
+          end
+          hash
+        end
+
+        # internal merge
+        def hash_isca_internal_merge_resolve!(hash, prefer: nil, residual: {})
+          hash_isca_correct_keys!(hash, prefer: prefer, residual: residual)
+          keep_keys = hash_isca_uniq_keys(hash, prefer: prefer)
+          hash.dup.each do |key, _v|
+            residual[key] = hash.delete(key) unless keep_keys.include?(key)
+          end
+          hash
+        end
+
+        # internal merge
+        def hash_isca_internal_merge_resolve(value, prefer: nil, residual: {})
+          hash_isca_internal_merge_resolve!(value.to_h.dup, prefer: prefer, residual: residual)
+        end
+
+        # it resolves a single key
+        def hash_isca_resolve_key!(hash, key, prefer: nil, residual: {})
+          hash_isca_correct_key!(hash, key, prefer: prefer, residual: residual)
+          return hash if hash_isca_uniq_key?(hash, key)
+          _pkey, rkey = hash_isca_double_key(key, prefer: prefer)
+          residual[rkey] = hash.delete(rkey)
+          hash
+        end
+
+        # all keys to camel case
+        def hash_isca_camelize_keys(value)
+          hash_isca_with_preferred_keys(value, prefer: :camel_case)
+        end
+
+        def hash_isca_camelize_keys!(hash)
+          hash_isca_with_preferred_keys!(hash, prefer: :camel_case)
+        end
+
+        # all keys to snake case
+        def hash_isca_snakeize_keys(value)
+          hash_isca_with_preferred_keys(value, prefer: :snake_case)
+        end
+
+        def hash_isca_snakeize_keys!(hash)
+          hash_isca_with_preferred_keys!(hash, prefer: :snake_case)
+        end
+
+        # Conerts keys to the `prefer` case form
+        # @note it first resolves with the default/general `hash_isca_preferred`,
+        #   as all operations have been done up to now this way.
+        def hash_isca_with_preferred_keys!(hash, prefer: nil, residual: {})
+          hash_isca_internal_merge_resolve!(hash, residual: residual)
+          hash.dup.each do |k, _v|
+            key = hash_isca_to_preferred_key(k, prefer: prefer)
+            hash[key] = hash.delete(k)
+          end
+          hash
+        end
+
+        def hash_isca_with_preferred_keys(value, prefer: nil)
+          hash_isca_with_preferred_keys!(value.to_h.dup, prefer: prefer)
+        end
+
+        # @return [Array<String>] the resolved keys
+        def hash_isca_uniq_keys(value, prefer: nil)
+          hash     = value.to_h
+          all_keys = hash.keys
+          dup_keys = all_keys.each_with_object({}) do |key, res|
+            keys = hash_isca_double_key(key, prefer: prefer)
+            next unless keys.all? {|k| hash.key?(k)}
+            next if     res.key?(keys.first)
+            res[keys.first] = keys.last
+          end
+          all_keys - dup_keys.values
+        end
+
+        # @note if among the raw existing keys there were multiple keys for a given
+        #   correct case version of `key`, they would be considered as one.
+        # @return [Boolean] `true` if the key is only in one form or not present.
+        #   `false` if the key is in **multiple** forms
+        def hash_isca_uniq_key?(value, key)
+          hash_isca_existing_correct_keys(value, key).length <= 1
+        end
+
+        # For a given `key` it finds out what keys exist in its correct case form.
+        # @return [Array<String>] the existing correct keys.
+        def hash_isca_existing_correct_keys(value, key, prefer: nil)
+          hash = value.to_h
+          hash_isca_double_key(key, prefer: prefer).find_all do |k|
+            hash.key?(k)
+          end
+        end
+
+        def hash_isca_key?(value, key)
+          hash = value.to_h
+          hash_isca_double_key(key).any? {|k| hash.key?(k)}
+        end
+
+        def hash_isca_same_key?(k_1, k_2)
+          hash_isca_double_key(k_1) == hash_isca_double_key(k_2)
+        end
+
+        # @return [String] the preferred case form of the key
+        def hash_isca_to_preferred_key(key, prefer: nil)
+          hash_isca_double_key(key, prefer: prefer).first
+        end
+
+        # Spot the correct key. Ensures keys are in camel or snake case.
+        # @param keep_case [Boolean] whether only the preferred case form of key
+        #   should be used or rather try to keep its case.
+        # @return [String] the target key
+        def hash_isca_to_correct_key(key, keep_case: true, prefer: nil)
+          pkey, okey = hash_isca_double_key(key, prefer: prefer)
+          return pkey unless keep_case
+          return pkey unless [pkey, okey].include?(key)
+          key
+        end
+
+        # @return [Boolean] whether `key` is already in snake or camel case form
+        def hash_isca_correct_key?(key)
+          hash_isca_double_key(key).any? {|k| k == key}
+        end
+
+        def hash_isca_double_key(key, prefer: nil)
+          return [key, key] unless key.is_a?(String)
+          return [snake_case(key), camel_case(key)] if hash_isca_prefer(prefer) == :snake_case
+          [camel_case(key), snake_case(key)]
+        end
+
+        def hash_isca_prefer(prefer = nil)
+          return hash_isca_preferred || :snake_case if prefer.nil?
+          return :camel_case unless prefer == :snake_case
+          :snake_case
+        end
+      end
+    end
+  end
+end

data/lib/eco/data/hashes.rb

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

data/lib/eco/data/locations/convert.rb

@@ -76,7 +76,7 @@ module Eco::Data::Locations
     end
 
     # It logs a message from `yield` and appends a `pretty_inspect` on object.
-    # @note it only works where `object` is `Enumberable`
+    # @note it only works where `object` is `Enumerable`
     def log_pretty_inspect(object, lev = :info)
       return unless object.is_a?(Enumerable)
       return if object.empty?

data/lib/eco/data/locations/node_base/csv_convert.rb

@@ -6,17 +6,21 @@ module Eco::Data::Locations::NodeBase
       Eco::API::Organization::TagTree
     end
 
-    # @yield [Node] optional custom serializer
+    # @yield [node, json] optional custom serializer
+    # @yieldparam node [Node] the node that is being serialized
+    # @yieldparam json [Hash] the default serialization
     # @yieldreturn [Hash] the serialized Node
     # @param value [CSV::Table, Eco::API::Organization::TagTree]
     # @return [Array<Hash>] a plain list of hash nodes
     def hash_list(value, &block)
-      return hash_list(org_tree(value)) if value.is_a?(::CSV::Table)
-      return value.as_nodes_json        if value.is_a?(tree_class)
+      return hash_list(org_tree(value), &block) if value.is_a?(::CSV::Table)
+      return value.as_nodes_json(&block)        if value.is_a?(tree_class)
       raise ArgumentError, "Expecting Eco::API::Organization::TagTree or CSV::Table. Given: #{value.class}"
     end
 
-    # @yield [Node] optional custom serializer
+    # @yield [node, json] optional custom serializer
+    # @yieldparam node [Node] the node that is being serialized
+    # @yieldparam json [Hash] the default serialization
     # @yieldreturn [Hash] the serialized Node
     # @param value [CSV::Table, Eco::API::Organization::TagTree]
     # @return [Array<Hash>] a hierarchical tree of hash nodes,
@@ -27,7 +31,9 @@ module Eco::Data::Locations::NodeBase
       raise ArgumentError, "Expecting Eco::API::Organization::TagTree or CSV::Table. Given: #{value.class}"
     end
 
-    # @yield [Node] optional custom serializer
+    # @yield [node, json] optional custom serializer
+    # @yieldparam node [Node] the node that is being serialized
+    # @yieldparam json [Hash] the default serialization
     # @yieldreturn [Hash] the serialized Node
     # @param value [CSV::Table, Eco::API::Organization::TagTree]
     # @return [Eco::API::Organization::TagTree]
@@ -37,21 +43,25 @@ module Eco::Data::Locations::NodeBase
       raise ArgumentError, "Expecting Eco::API::Organization::TagTree or CSV::Table. Given: #{value.class}"
     end
 
-    # @yield [Node] optional custom serializer
+    # @yield [node, json] optional custom serializer
+    # @yieldparam node [Node] the node that is being serialized
+    # @yieldparam json [Hash] the default serialization
     # @yieldreturn [Hash] the serialized Node
     # @return [CSV::Table] a table with L1 to Ln columns ready for dump to csv
-    def csv_tree(value, encoding: 'utf-8', attrs: [:id], &block)
+    def csv_tree(value, encoding: 'utf-8', attrs: [:id], &block) # rubocop:disable Lint/UnusedMethodArgument
       Eco::CSV::Table.new(hash_tree_to_tree_csv(hash_tree(value, &block), attrs: attrs))
     end
 
     # @note it just converts to an organizational tagtree and uses a helper method.
-    # @yield [Node] optional custom serializer
+    # @yield [node, json] optional custom serializer
+    # @yieldparam node [Node] the node that is being serialized
+    # @yieldparam json [Hash] the default serialization
     # @yieldreturn [Hash] the serialized Node
     # @param value [CSV::Table, Eco::API::Organization::TagTree]
     # @return [CSV::Table] a table with a list of nodes and their parents
     def csv_list(value, &block)
       value = org_tree(value, &block) unless value.is_a?(tree_class)
-      Eco::CSV::Table.new(hash_list(value))
+      Eco::CSV::Table.new(hash_list(value, &block))
     end
   end
 end