eco-helpers 2.6.0 → 2.6.1

data/lib/eco/cli_default/workflow.rb

@@ -1,189 +1,171 @@
-ASSETS.cli.config do |config|
+ASSETS.cli do |cli|
   ASSETS.config.workflow do |wf|
-    io                = nil
-    rescued           = false
-    cases_with_input  = nil
-    cases_with_output = nil
 
+    rescued = false
     # default rescue
-    wf.rescue do |exception, io|
-      begin
-        next io if rescued
-        rescued = true
-
-        io.session.logger.debug(exception.patch_full_message)
-        wf.run(:close, io: io)
-      rescue Exception => e
-        puts "Some problem in workflow.rescue: #{e}"
-      end
-      io
+    wf.rescue do |err, io|
+      next io if rescued
+      rescued = true
+      log(:debug) { err.patch_full_message }
+      wf.run(:close, io: io)
+    rescue StandardError => e
+      puts "Some problem in workflow.rescue: #{e}"
     end
 
-    wf.on(:options) do |wf_options, io|
-      config.usecases.cli_apply(io: io)
-      io = io.new(options: config.options_set.process(io: io))
+    wf.on(:options) do |_wf_opt, io|
+      cli.config.usecases.cli_apply(io: io)
+      io.new(options: cli.config.options_set.process(io: io))
     end
 
     wf.for(:load) do |wf_load|
-      wf_load.for(:input) do |wf_input|
-        wf_input.on(:get) do |wf_input_get, io|
-          cases_with_input =  config.usecases.active(io: io).select do |usecase, data|
+      wf_load.for(:input) do |wf_in|
+        wf_in.on(:get) do |_wf_ig, io|
+          cases_with_input = cli.config.usecases.active(io: io).select do |usecase, data|
             io.class.input_required?(usecase.type)
           end
 
-          input_is_required = !cases_with_input.empty? || io.options.dig(:input, :entries_from)
-          missing_input     = !io.input || io.input.empty?
-          next io unless missing_input && input_is_required
+          input_is_required = !cases_with_input.empty? || options.dig(:input, :entries_from)
+          missing_input     = !input || input.empty?
+          next unless missing_input && input_is_required
 
-          if io.options.dig(:input, :entries_from)
-            io = io.new(input: config.input.get(io: io))
+          if options.dig(:input, :entries_from)
+            io.new(input: cli.config.input.get(io: io))
           else
             opt_case = cases_with_input.values.first.option
-            io = io.new(input: config.input.get(io: io, option: opt_case))
+            io.new(input: cli.config.input.get(io: io, option: opt_case))
           end
-          io
         end
 
-        wf_input.on(:filter) do |wf_input_filter, io|
-          next io unless io.input && !io.input.empty?
-          io = io.new(input:  config.input_filters.process(io: io))
+        wf_in.on(:filter) do |_wf_if, io|
+          next unless input && !input.empty?
+          io.new(input:  cli.config.input_filters.process(io: io))
         end
       end
 
-      wf_load.for(:people) do |wf_people|
-        wf_people.on(:get) do |wf_people_get, io|
-          cases_with_people = config.usecases.active(io: io).select do |usecase, data|
+      wf_load.for(:people) do |wf_peo|
+        wf_peo.on(:get) do |_wf_pg, io|
+          cases_with_people = cli.config.usecases.active(io: io).select do |usecase, data|
             io.class.people_required?(usecase.type)
           end
-          next io if cases_with_people.empty? && !io.options.dig(:people, :get)
-          io = io.new(people:  config.people(io: io))
+          next if cases_with_people.empty? && !options.dig(:people, :get)
+          io.new(people: cli.config.people(io: io))
         end
 
-        wf_people.on(:filter) do |wf_people_filter, io|
-          next io unless io.people && !io.people.empty?
-          io = io.new(people:  config.people_filters.process(io: io))
+        wf_peo.on(:filter) do |_wf_pf, io|
+          next unless people && !people.empty?
+          io.new(people: cli.config.people_filters.process(io: io))
         end
       end
     end
 
-    wf.before(:usecases) do |wf_cases, io|
+    wf.before(:usecases) do |_wf_ca, io|
       # save partial entries -> should be native to session.workflow
-      get_people     = io.options.dig(:people, :get)
+      get_people     = options.dig(:people, :get)
       partial_update = get_people && get_people.dig(:type) == :partial
-      if !io.options[:dry_run] && partial_update
-        partial_file = io.session.config.people.partial_cache
-        io.session.file_manager.save_json(io.people, partial_file, :timestamp)
+      if !options[:dry_run] && partial_update
+        partial_file = session.config.people.partial_cache
+        session.file_manager.save_json(io.people, partial_file, :timestamp)
       end
-      io
     end
 
-    wf.on(:usecases) do |wf_cases, io|
-      unless config.usecases.process(io: io)
-        msg = "No update operation specified... quitting"
-        io.session.logger.info(msg)
-        exit(0)
+    wf.on(:usecases) do |_wf_ca, io|
+      unless cli.config.usecases.process(io: io)
+        log(:info) { "No update operation specified... quitting" }
+        exit 0
       end
-      io
     end
 
-    wf.before(:launch_jobs) do |wf_jobs, io|
+    wf.before(:launch_jobs) do
       SCR.stop_on_unknown!
-      io
     end
 
-    wf.on(:launch_jobs) do |wf_jobs, io|
-      io.session.jobs_launch(simulate: io.options[:dry_run])
-      io
+    wf.on(:launch_jobs) do
+      session.jobs_launch(simulate: options[:dry_run])
     end
 
     wf.before(:post_launch) do |wf_post, io|
-      if io.session.post_launch.empty?
+      next wf_post.skip! if session.post_launch.empty?
+
+      run_it  = !options[:dry_run] || options.dig(:post_launch, :run)
+      unless run_it
         wf_post.skip!
-      else
-        get_people     = io.options.dig(:people, :get)
-        partial_update = get_people && get_people.dig(:type) == :partial
-        run_it         = !io.options[:dry_run] || io.options.dig(:post_launch, :run)
-        refresh_data   = !io.options[:dry_run] && partial_update
-        if run_it
-          if refresh_data
-            # get target people afresh
-            people = io.session.micro.people_refresh(people: io.people, include_created: true)
-            io     = io.base.new(people: people)
-          else
-            msg = "Although there are post_launch cases, data will not be refreshed before their run"
-            if io.options[:dry_run]
-              msg += ", because we are in dry-run (simulate)."
-            elsif !partial_update
-              msg += ", because it is not a partial update (-get-partial option not present)."
-            end
-            io.session.logger.info(msg)
-          end
-        else
-          wf_post.skip!
-          msg = "Although there are post_launch cases, they will NOT be RUN"
+        log(:info) {
+          msg  = "Although there are post_launch cases, they will NOT be RUN"
+          msg += ", because we are in dry-run (simulate)." if options[:dry_run]
+          msg
+        }
+        next
+      end
+
+      get_people     = options.dig(:people, :get)
+      partial_update = get_people && get_people.dig(:type) == :partial
+      refresh_data   = !options[:dry_run] && partial_update
+
+      unless refresh_data
+        log(:info) {
+          msg = "Although there are post_launch cases, data will not be refreshed before their run"
           if io.options[:dry_run]
-            msg+= ", because we are in dry-run (simulate)."
+            msg += ", because we are in dry-run (simulate)."
+          elsif !partial_update
+            msg += ", because it is not a partial update (-get-partial option not present)."
           end
-          io.session.logger.info(msg)
-        end
+          msg
+        }
+        next
       end
-      io
+
+      # get target people afresh
+      peo_aux = session.micro.people_refresh(people: people, include_created: true)
+      io.base.new(people: peo_aux)
     end
 
     wf.for(:post_launch) do |wf_post|
-
-      wf_post.on(:usecases) do |wf_postcases, io|
-        io.session.post_launch.each do |use|
-          begin
-            io = use.launch(io: io).base
-          rescue Eco::API::UseCases::BaseIO::MissingParameter => e
-            if e.required == :people
-              io.session.logger.debug("Skipping use case '#{use.name}' -- no base people detected for the current run")
-            else
-              raise
-            end
-          end
+      wf_post.on(:usecases) do |_wf_pu, io|
+        session.post_launch.each do |use|
+          use.launch(io: io).base
+        rescue Eco::API::UseCases::BaseIO::MissingParameter => e
+          raise unless e.required == :people
+          log(:debug) {
+            "Skipping use case '#{use.name}' -- no base people detected for the current run"
+          }
         end
-        io
       end
 
-      wf_post.on(:launch_jobs) do |wf_postlaunch, io|
-        io.session.jobs_launch(simulate: io.options[:dry_run])
-        io
+      wf_post.on(:launch_jobs) do |_wf_pl, io|
+        session.jobs_launch(simulate: options[:dry_run])
       end
     end
 
-    wf.on(:report) do |wf_report, io|
-      io.tap do |_io|
-        if file = io.options.dig(:report, :people, :csv)
-          io.options.deep_merge!(export: {
-            options: {internal_names: true, nice_header: true, split_schemas: true},
-            file: {name: file, format: :csv}
-          })
-          aux_io = io.new(people: io.people.updated_or_created)
-          io.session.process_case("to-csv", io: aux_io, type: :export)
-        end
+    wf.on(:report) do |_wf_rep, io|
+      if file = options.dig(:report, :people, :csv)
+        options.deep_merge!(export: {
+          options: {internal_names: true, nice_header: true, split_schemas: true},
+          file:    {name: file, format: :csv}
+        })
+        aux_io = io.new(people: people.updated_or_created)
+        session.process_case("to-csv", io: aux_io, type: :export)
       end
     end
 
-    wf.on(:end) do |wf_end, io|
-      get_people     = io.options.dig(:people, :get)
+    wf.on(:end) do |_wf_end, io|
+      get_people     = options.dig(:people, :get)
       partial_update = get_people && get_people.dig(:type) == :partial
 
-      unless !io.options[:end_get] || io.options[:dry_run] || partial_update
-        people_update_cases = config.usecases.active(io: io).any? do |usecase, data|
-          [:transform, :sync].any? {|type| usecase.type == type}
+      unless !options[:end_get] || options[:dry_run] || partial_update
+        people_update_cases = cli.config.usecases.active(io: io).any? do |usecase, data|
+          [:transform, :sync].any? { |type| usecase.type == type }
         end
 
         if !people_update_cases
           # Prevent getting people when there were no use cases that used them
-          io.session.logger.info("Won't be recaching people, as there haven't been any targetted updates")
-        elsif !io.people
-          people = io.session.micro.people_cache
-          io     = io.new(people: people)
+          log(:info) {
+            "Won't be recaching people, as there haven't been any targetted updates"
+          }
+        elsif !people
+          people = session.micro.people_cache
+          io.new(people: people)
         end
       end
-      io
     end
   end
 end

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

@@ -1,33 +1,43 @@
 module Eco::Data::Locations::NodeBase
   module TagValidations
+    include Eco::Language::AuxiliarLogger
+
     ALLOWED_CHARACTERS = "A-Za-z0-9 &_'\/.-"
     VALID_TAG_REGEX    = /^[#{ALLOWED_CHARACTERS}]+$/
     INVALID_TAG_REGEX  = /[^#{ALLOWED_CHARACTERS}]+/
     VALID_TAG_CHARS    = /[#{ALLOWED_CHARACTERS}]+/
     DOUBLE_BLANKS      = /\s\s+/
 
-    def clean_id(str, notify: true)
+    def clean_id(str, notify: true, ref: '')
       blanks_x2 = has_double_blanks?(str)
       partial   = replace_not_allowed(str)
       remove_double_blanks(partial).tap do |result|
         next unless notify
-        next if invalid_warned?
+        next if invalid_warned?(str)
         if partial != str
           invalid_chars = identify_invalid_characters(str)
-          puts "• (Row: #{self.row_num}) Invalid characters _#{invalid_chars}_ (removed): '#{str}' (converted to '#{result}')"
+          log(:warn) {
+            "• #{ref}Invalid characters _#{invalid_chars}_ <<_removed_: '#{str}' :_converted_>> '#{result}'"
+          }
         elsif blanks_x2
-          puts "• (Row: #{self.row_num}) Double blanks (removed): '#{str}' (converted to '#{result}')"
+          log(:warn) {
+            "• #{ref}Double blanks removed: '#{str}' :_converted_>> '#{result}'"
+          }
         end
-        invalid_warned!
+        invalid_warned!(str)
       end
     end
 
-    def invalid_warned?
-      @invalid_warned ||= false
+    def invalid_warned?(str)
+      invalid_warned[str] ||= false
+    end
+
+    def invalid_warned!(str)
+      invalid_warned[str] = true
     end
 
-    def invalid_warned!
-      @invalid_warned = true
+    def invalid_warned
+      @invalid_warned ||= {}
     end
 
     def has_double_blanks?(str)

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

@@ -12,14 +12,31 @@ module Eco::Data::Locations::NodeBase
     # @yieldreturn [Hash] custom hash model when treeifying (allows to set more keys/properties).
     # @nodes [Array<NodeBase>] list of nodes
     # @return [Array<Hash>] a hierarchical tree of nested Hashes via `nodes` key.
-    def treeify(nodes, &block)
+    def treeify(nodes, skipped: [], unlinked_trees: [], &block)
       return [] if nodes.empty?
       block ||= nodes.first.class.serializer
-      get_children(nil, parents_hash(nodes), &block)
+      done_ids = {}
+      warns    = []
+      parents  = parents_hash(nodes)
+      get_children(nil, parents, done_ids: done_ids, skipped: skipped, warns: warns, &block).tap do |tree|
+        check_results(
+          tree,
+          nodes,
+          parents,
+          done_ids: done_ids,
+          skipped: skipped,
+          unlinked_trees: unlinked_trees,
+          warns: warns,
+          &block
+        )
+        log(:warn) { warns.join("\n") } unless warns.empty?
+      end
     end
 
     private
 
+    # @return [Hash] where `key`s are all the `parentId` of the nodes
+    #   and `value` and `Array` of those nodes that have that `parentId`
     def parents_hash(nodes)
       nodes.each_with_object({}) do |node, parents|
         (parents[node.parentId] ||= []).push(node)
@@ -32,12 +49,21 @@ module Eco::Data::Locations::NodeBase
     #   3. The above can translate into some
     # @yield [node]
     # @yieldreturn [Hash] custom hash model when treeifying
-    def get_children(node_id, parents, parent: nil, done_ids: {}, level: 0, &block)
+    def get_children(node_id, parents, parent: nil, level: 0, done_ids: {}, skipped: [], warns: [], &block)
       level_ids = []
       (parents[node_id] ||= []).each_with_object([]) do |child, results|
         # Skipping done id. Add proper warnings...
         # => rely on `done_ids` to identify if an `id` has already been done
-        next report_skipped_node(child, parent, done_ids, level, level_ids, parents) if done_ids[child.id]
+        next report_skipped_node(
+          child,
+          parent,
+          done_ids,
+          level,
+          level_ids,
+          parents,
+          skipped: skipped,
+          warns:   warns
+        ) if done_ids[child.id]
 
         # Fill in tracking data
         child.parent        = parent
@@ -52,8 +78,26 @@ module Eco::Data::Locations::NodeBase
         node_hash.merge(yield(child)) if block_given?
         # we must register the `id` before recursing down
         done_ids[child.id] = child
+
+        children = get_children(
+          child.id,
+          parents,
+          parent:   child,
+          done_ids: done_ids,
+          level:    level + 1,
+          skipped:  skipped,
+          warns:    warns,
+          &block
+        ).tap do |desc|
+          if (nil_count = desc.count(nil)) > 0
+            log(:debug) {
+              "get_children gave #{nil_count} nil values for nodes of #{child.id}"
+            }
+          end
+        end
+
         results << node_hash.merge({
-          "nodes" => get_children(child.id, parents, parent: child, done_ids: done_ids, level: level + 1, &block).compact
+          "nodes" => children.compact
         })
       end
     end
@@ -70,8 +114,138 @@ module Eco::Data::Locations::NodeBase
       "#{" " * level}"
     end
 
-    # Gives different warnings, depending the case
-    def report_skipped_node(node, parent, done_ids, level, level_ids, parents)
+    # Method to ensure the results are consistent
+    # @param skipped [Array<NodePlain>] those skipped because repeated
+    #   1. It will add children of them that were skipped. This won't clash with unlinked nodes
+    #     because otherwise would be part of `done_ids` anyway.
+    # @param unlinked_trees [Array<Hash>] by excluding those done and skipped,
+    #   it will treeify the unlinked nodes (the exclusion applies to `parants_hash`)
+    def check_results(tree, nodes, parents, done_ids: {}, skipped: [], unlinked_trees: [], warns: [], &block)
+      update_skipped(skipped, parents, done_ids: done_ids) unless skipped.empty?
+
+      if done_ids.count != nodes.count
+        tracked_nodes       = done_ids.values
+        untracked_nodes     = nodes - tracked_nodes - skipped
+        # skipped keys is inherent, as they were excluded because of id clash with done_ids
+        unlinked_parent_ids = (parents.keys - done_ids.keys).compact
+
+        msg = []
+
+        # The reason of missing nodes in the output tree is unknown!
+        if skipped.empty? && unlinked_parent_ids.empty?
+          msg << "BUG in this library (open issue with maintainers)."
+          msg << "There were no skipped nodes nor missin referred parents, and yet:"
+          msg << "  • the tree nodes count: #{done_ids.count} ..."
+          msg << "  • doesn't match the original nodes count: #{nodes.count}"
+          raise msg.join("\n")
+        end
+
+        unless unlinked_parent_ids.empty?
+          msg << "There are #{unlinked_parent_ids.count} referred parent_id's NOT linked to the root:"
+          msg << "  • total_nodes: #{nodes.count}"
+          msg << "  • tracked_nodes: #{tracked_nodes.count}"
+          msg << "  • untracked_nodes: #{untracked_nodes.count}"
+          msg << "  • unlinked_parents: #{unlinked_parent_ids.count}"
+          msg << "  • skipped (repeated) nodes: #{skipped.count}" unless skipped.empty?
+
+          unlinked_nodes   = nodes - skipped
+          unlinked_parents = parents.slice(*unlinked_parent_ids) # doesn'thave skipped ones
+
+          residual_skipped = []
+          unlinked_trees.concat \
+            get_unlinked_trees(
+              unlinked_nodes,
+              unlinked_parents,
+              done_ids: done_ids,
+              skipped:  residual_skipped,
+              warns:    warns,
+              &block
+            )
+
+          update_skipped(skipped, parents, with: residual_skipped, done_ids: done_ids) unless residual_skipped.empty?
+
+          tracked_nodes       = done_ids.values
+          untracked_nodes     = nodes - tracked_nodes - skipped
+          unlinked_parent_ids = (parents.keys - done_ids.keys).compact
+
+          msg << "After treeifying via the unlinked_parents:"
+          msg << "  • total_nodes: #{nodes.count}"
+          msg << "  • tracked_nodes: #{tracked_nodes.count}"
+          msg << "  • untracked_nodes: #{untracked_nodes.count}"
+          msg << "  • unlinked_parents: #{unlinked_parent_ids.count}"
+          msg << "  • skipped in this step: #{residual_skipped.count}"
+        end
+
+        msg << "  • total skipped (repeated) nodes: #{skipped.count} !!" unless skipped.empty?
+        warns << msg.join("\n")
+        nil
+      end
+    end
+
+    # Treeifies the unlinked nodes by scoping existing parent ids.
+    def get_unlinked_trees(nodes, parents, done_ids: {}, skipped: [], warns: [], &block)
+      node_ids           = nodes.map(&:id)
+      parent_ids         = parents.keys & node_ids
+      missing_parent_ids = parents.keys - parent_ids
+      missing_parents    = parents.slice(*missing_parent_ids)
+      warns << "  • missing_parents: #{missing_parents.count}"
+      nil_parent_nodes   = missing_parents.each_with_object([]) do |(id, nodes), mem|
+        nodes.each {|node| node.parent_id = nil}
+        mem.concat(nodes)
+      end
+      rest_parents = parents.slice(*parent_ids).merge({
+        nil => nil_parent_nodes
+      })
+      get_children(nil, rest_parents, done_ids: done_ids, skipped: skipped, warns: warns, &block)
+    end
+
+    # Same as `get_children` but not performing checks and with
+    # option to retrieve the source nodes (rather than parsing to `Hash`).
+    # @note serves the purpose to identify what linked children got inherently
+    #   skipped, because their parent was skipped.
+    def get_tree_nodes_raw(node_id, parents, src_plain: true, &block)
+      (parents[node_id] ||= []).each_with_object([]) do |child, results|
+        unless src_plain
+          node_hash = {
+            "id"        => child.id,
+            "name"      => child.name,
+            "parent_id" => node_id
+          }
+          node_hash.merge(yield(child)) if block_given?
+        end
+
+        descendants = get_tree_nodes_raw(child.id, parents, src_plain: src_plain, &block).tap do |desc|
+          if (nil_count = desc.count(nil)) > 0
+            puts "get_tree_nodes_raw gave #{nil_count} nil values for nodes of #{child.id}"
+          end
+        end
+
+        if src_plain
+          results.concat(descendants)
+        else
+          results << node_hash.merge({
+            "nodes" => descendants.compact
+          })
+        end
+      end
+    end
+
+    # It goes through the `with` skipped nodes, and adds them to the `skipped` ones
+    #   by including their not tracked/done/included children.
+    def update_skipped(skipped, parents, with: skipped, done_ids: {})
+      raw_skipped_children = with.each_with_object([]) do |node, mem|
+        mem << node
+        mem.concat get_tree_nodes_raw(node.id, parents)
+      end.uniq
+      skipped_children = raw_skipped_children - done_ids.values
+      skipped.concat(skipped_children).uniq!
+      skipped
+    end
+
+    # With given a skipped `node` (repeated `id`), it gives different warnings,
+    # provided that the context in which the double-up `id` happened is identified.
+    def report_skipped_node(node, parent, done_ids, level, level_ids, parents, skipped: [], warns: [])
+      skipped << node
       lev          = level + 1
       done_node    = done_ids[node.id]
       prev_parent  = node.parent
@@ -84,6 +258,9 @@ module Eco::Data::Locations::NodeBase
       row_str      = row_num ? "(Row: #{row_num}) " : ''
       node_str     = "#{row_str}Node '#{node.id}' #{level_msg(lev)} (#{parent_msg(parent)})"
 
+      msg  = []
+      msg << "#{indent(level)}Skipping #{node_str}."
+
       # Implementation integrity guard
       # => as we don't register in `done_ids` those that are skipped,
       #   when a `node` has already a tracked `parent` or `level`,
@@ -114,18 +291,15 @@ module Eco::Data::Locations::NodeBase
       cyclic    = multi_parent && done_node == node
       double_up = node_dup || lev_dup
 
-      msg  = []
-      msg << "#{indent(level)}WARNING: Skipping #{node_str}."
-
       if cyclic
-        str  = "#{indent(level)+1}Cyclic definition. By skipping the node, "
+        str  = "#{indent(level + 1)}Cyclic definition. By skipping the node, "
         str << "it will remain as #{parent_msg(done_node.parent)} (#{level_msg(prev_level)})."
         msg << str
       end
 
       if double_up
-        str  = "#{indent(level)+1}The node ID has been tracked as #{level_msg(done_node.tracked_level)}, "
-        str << "as #{parent_msg(node_dup.parent)} "
+        str  = "#{indent(level + 1)}Node ID was already tracked as #{level_msg(done_node.tracked_level)}, "
+        str << "as #{parent_msg(done_node.parent)} "
         str << "(same parent)."      if lev_dup
         str << "(different parent)." if multi_parent
         msg << str
@@ -133,18 +307,19 @@ module Eco::Data::Locations::NodeBase
 
       unless cyclic || double_up
         str  = "Integrity issue in Treeify. "
-        str  = "Skipping is only applicable to double_ups or cyclic nodes."
+        str << "Skipping is only applicable to double_ups or cyclic nodes."
         str << "\n • #{node_str}."
         raise str
       end
 
-      if children = parents[node.id]
-        str  = "#{indent(level)+1}Immediate children of skipped node (will probably be missing): "
-        str << children.map {|gc| "'#{gc.id}'"}.join(", ")
+      unless (children = parents[node.id] || []).empty?
+        str  = "#{indent(level + 1)}Immediate children of skipped node (will probably be missing): "
+        str << children.map {|ch| "'#{ch.id}'"}.join(", ")
         msg << str
       end
 
-      log(:warn) { msg.join('\n') }
+      warns << msg.join("\n")
+      nil
     end
   end
 end

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

@@ -28,7 +28,7 @@ module Eco::Data::Locations
     end
 
     def tag
-      clean_id(raw_tag)
+      clean_id(raw_tag, ref: "(Row: #{self.row_num}) ")
     end
 
     def raw_tag

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

@@ -20,7 +20,7 @@ class Eco::Data::Locations::NodePlain
     end
 
     # It builds each NodePlain from the input csv.
-    # @param `csv` [CSV::Table]
+    # @param `csv` [CSV::Table] with specific headers
     # @return [Array<NodePlain>]
     def nodes_from_csv(csv)
       raise ArgumentError, "Expecting CSV::Table. Given: #{csv.class}" unless csv.is_a?(::CSV::Table)

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

@@ -6,7 +6,7 @@ class Eco::Data::Locations::NodePlain
     def serializer
       @serializer ||= proc do |node|
         raise "Expecting NodePlain. Given: #{node.class}" unless node.is_a?(Eco::Data::Locations::NodePlain)
-        keys = Eco::Data::Locations::NodePlain::NODE_PLAIN_ATTRS
+        keys = Eco::Data::Locations::NodePlain::ALL_ATTRS
         node.to_h(*keys)
       end
     end