eco-helpers 2.5.10 → 2.6.1

data/lib/eco/api/common/people/person_entry_attribute_mapper.rb

@@ -4,6 +4,7 @@ module Eco
       module People
         # @attr_reader direct_attrs [Array<String>] only those internal attributes present in the person entry that do **not** have an internal/external name mapping.
         class PersonEntryAttributeMapper
+          DEBUG = false
           @@cached_warnings = {}
 
           attr_reader :aliased_attrs, :direct_attrs
@@ -182,22 +183,59 @@ module Eco
 
           private
 
+          # Whether the maps include this `attr` as mapped to itself
+          def self_mapped_attr?(attr)
+            return false if !@attr_map
+            @attr_map.self_mapped?(attr)
+          end
+
+          # Whether the maps include this `attr` as mapped from to some other or itself
+          def external_attr?(attr)
+            return false if !@attr_map
+            @attr_map.external?(attr)
+          end
+
           # when parsing:
           def init_attr_trackers
             # (def) all internal attributes we can expect
             def_all_attrs     = @person_parser.all_model_attrs
             # (def) internal attrs with no aliasing nor parser definition (expected to be direct)
             def_unlinked      = @person_parser.undefined_model_attrs.select { |attr| !to_external(attr) }
-            # (def) those with parser or alias:
-            def_linked        = def_all_attrs - def_unlinked
+
+            debug(
+              def_unlinked,
+              "(def_unlinked) expected to be direct (not parser defined nor aliased)"
+            )
+
             # (data) data attributes (actual attributes of the entry)
             data_attrs        = attributes(@external_entry)
+            # (data) attributes of the data that COULD come directly as internal attribute names
+            # => WARNING: this includes ext direct attrs that may be aliased to other int attrs
+            data_direct_attrs_raw   = data_attrs & def_all_attrs
+            # (data) direct (int) ext data attrs mapped
+            data_direct_mapped      = data_direct_attrs_raw.select { |attr| external_attr?(attr) }
+            # (data) direct (int) ext data attrs mapped to themselves
+            data_direct_self_mapped = data_direct_attrs_raw.select { |attr| self_mapped_attr?(attr) }
+            # (data) direct (int) ext data attrs mapped only to another attr
+            data_direct_renamed     = data_direct_mapped - data_direct_self_mapped
             # (data) attributes of the data that come directly as internal attribute names
-            data_direct_attrs = data_attrs & def_all_attrs
+            data_direct_attrs       = data_direct_attrs_raw - data_direct_renamed
+
+            debug(
+              data_direct_attrs,
+              "(data_direct_attrs) attributes of the data that come directly as internal attribute names (data_direct_attrs_raw - data_direct_renamed)"
+            )
+
+            # (def) configured as alised (int <-> ext attrs) + accept/include int attrs as ext attrs
+            def_int_aliased_raw = def_all_attrs.select  { |attr| to_external(attr) }
+            # (def) aliasable int attrs of the input data (excludes int attrs direct as ext attrs that got renamed)
+            def_int_aliased     = def_int_aliased_raw - data_direct_renamed
+            # (def) ext attrs of the data's aliasable int attrs (def_int_aliased)
+            def_ext_alias       = def_int_aliased.map   { |attr| to_external(attr) }
+            # (def) those ext attrs that map to multiple int attrs
+            def_ext_multi_alias = def_ext_alias.detect  { |attr| def_ext_alias.count(attr) > 1 }
+            # (def) those ext attrs that are direct, mapt to themselves and some other
 
-            # (def) configured  as alised (internal <-> external attributes)
-            def_int_aliased   = def_all_attrs.select  { |attr| to_external(attr) }
-            def_ext_alias     = def_int_aliased.map   { |attr| to_external(attr) }
 
             # (data) virtual attrs (external alias of non native internal attr in data):
             data_vi_ext_alias = data_attrs.select do |attr|
@@ -210,27 +248,78 @@ module Eco
               @attr_map.to_internal(attr)
             end.compact
 
-            # (data) attrs that could come aliased in the current data
+            # (data) int attrs that come aliased in the current data
             # => modify aliased based on those that came directly as internal attrs in the entry
-            data_def_int_aliased = def_int_aliased - data_direct_attrs
+            data_def_int_aliased = (def_int_aliased - data_direct_attrs) | data_direct_self_mapped
             data_def_ext_alias   = data_def_int_aliased.map { |attr| to_external(attr) }
-            # (data) actual attrs of the data that come aliased
+            # (data) ext attrs of the data that come aliased
             data_ext_alias       = data_def_ext_alias & data_attrs
+            # (data) all internal attributes that come aliased, with given the entry
+            aliased_attrs        = data_def_int_aliased | data_vi_int_aliased
+
+            # render in the order that defines the model
+            @aliased_attrs       = (def_all_attrs & aliased_attrs) | (aliased_attrs - def_all_attrs)
+
+            debug(
+              data_vi_int_aliased,
+              "(data_vi_int_aliased) virtual internal attrs (internal names of those virtual attrs)"
+            )
+
+            debug(
+              def_int_aliased,
+              "(def_int_aliased) aliasable int attrs of the input data (excludes int attrs direct as ext attrs that got renamed)"
+            )
+
+            debug(
+              def_ext_alias,
+              "(def_ext_alias) ext attrs of the data's aliasable int attrs (def_int_aliased)"
+            )
+
+            debug(
+              data_def_int_aliased,
+              "(data_def_int_aliased) int attrs that come aliased in the current data ((def_int_aliased - data_direct_attrs) | data_direct_self_mapped)"
+            )
+
+            debug(
+              data_ext_alias,
+              "(data_ext_alias) ext attrs of the data that come aliased (data_def_ext_alias & data_attrs)"
+            )
+
+            debug(
+              aliased_attrs,
+              "(aliased_attrs) all internal attributes that come aliased, with given the entry (data_def_int_aliased | data_vi_int_aliased)"
+            )
 
-            # (data) all internal attributes that could come aliased, with given the entry
-            @aliased_attrs       = data_def_int_aliased + data_vi_int_aliased
             # (data) all those ext attrs present that will require aliasing
             #data_ext_alias_all   = data_def_ext_alias   + data_vi_ext_alias
-            data_ext_alias_all   = data_ext_alias       + data_vi_ext_alias
+            data_ext_alias_all   = data_ext_alias | data_vi_ext_alias
+
+            debug(
+              data_ext_alias_all,
+              "(data_ext_alias_all) all those ext attrs present that will require aliasing (data_ext_alias | data_vi_ext_alias)"
+            )
 
             # those that are direct external to internal:
             data_ext_direct      = data_attrs - data_ext_alias_all
-
             # (data) attributes that do not require aliasing
             # to avoid collisions between internal names:
-            #@direct_attrs        = data_ext_direct - def_linked
-            @direct_attrs        = data_ext_direct
-            @internal_attrs      = @aliased_attrs | @direct_attrs
+            direct_attrs         = data_ext_direct
+            # render in the order that defines the model
+            @direct_attrs        = (def_all_attrs & direct_attrs) | (direct_attrs - def_all_attrs)
+
+            # (data) attributes that are being aliased
+            internal_attrs       = @aliased_attrs | @direct_attrs
+            # render in the order that defines the model
+            @internal_attrs      = (def_all_attrs & internal_attrs) | (internal_attrs - def_all_attrs)
+
+            debug(
+              @direct_attrs,
+              "(@direct_attrs) attributes that do not require aliasing (data_attrs - data_ext_alias_all)"
+            )
+            debug(
+              @internal_attrs,
+              "(@internal_attrs) aliased_attrs | @direct_attrs"
+            )
           end
 
           def attributes(value)
@@ -265,6 +354,12 @@ module Eco
             logger.fatal(msg)
             raise msg
           end
+
+          def debug(var, msg)
+            return unless DEBUG
+            puts "\n  • #{msg}:"
+            pp var
+          end
         end
       end
     end

data/lib/eco/api/common/session/base_session.rb

@@ -35,6 +35,10 @@ module Eco
             enviro.api(version: version)
           end
 
+          def api?(version: nil)
+            enviro.api?(version: version)
+          end
+
           def file_manager
             enviro.file_manager
           end

data/lib/eco/api/common/session/environment.rb

@@ -53,6 +53,10 @@ module Eco
           def api(version: nil)
             config.api(logger, version: version)
           end
+
+          def api?(version:)
+            config.apis.active_api.version_available?(version)
+          end
         end
       end
     end

data/lib/eco/api/common/session/mailer.rb

@@ -33,7 +33,9 @@ module Eco
                 }
               }
             ).tap do |response|
-              logger.debug("Sent email to #{to} (MessageId: #{response.message_id})")
+              msg = "Sent email (MessageId: #{response.message_id}) to #{fetch_destination(to: to, cc: cc, bcc: bcc)}"
+              puts msg
+              logger.debug(msg)
             end
           end
 

data/lib/eco/api/common/session/sftp.rb

@@ -24,7 +24,7 @@ module Eco
             rescue Exception => e
               msg = "Could not open SFTP session. Possible misconfiguration: #{e}"
               logger.error(msg)
-              raise msg
+              raise
             end
             @sftp_session
           end

data/lib/eco/api/common/version_patches/exception.rb

@@ -1,9 +1,9 @@
 class ::Exception
-  def patch_full_message
+  def patch_full_message(trace_count: -1)
     begin
       msg = []
       tracing   = backtrace ? backtrace : []
-      tracing   = (self.class == SystemStackError) ? tracing[1..30] : tracing[1..-1]
+      tracing   = (self.class == SystemStackError) ? tracing[1..30] : tracing[1..trace_count]
       tracing ||= []
       msg << "\n#{tracing.first} \n#{message} (#{self.class.to_s})"
       tracing.each_with_index {|bt, i| msg << "#{" "*8}#{i+1}: from #{bt}"}

data/lib/eco/api/common/version_patches/ruby3/object.rb

@@ -0,0 +1,18 @@
+class Object
+  # From ruby3
+  # `NameError` prints the internals of the object as well as subobjects
+  # which is really unnecessary
+  # @example
+  #     class Foo; attr_writer :bar; end
+  #     foo = Foo.new
+  #     foo2 = Foo.new
+  #     foo.bar = foo2
+  #     h = {a: 1, b: 2, c: foo}
+  #     foo2.bar = h
+  #     h.foo
+  #     #=> undefined method `foo' for {:a=>1, :b=>2, :c=>#<Foo:0x000002343276b520 @bar=#<Foo:0x0000023437e91ca0 @bar={...}>>}:Hash (NoMethodError)
+  # What's the use of such a detail when it's just a missing method at the top of it?
+  def inspect
+    to_s
+  end
+end

data/lib/eco/api/common/version_patches/ruby3.rb

@@ -0,0 +1 @@
+require_relative 'ruby3/object'

data/lib/eco/api/common/version_patches.rb

@@ -7,6 +7,9 @@ module Eco
   end
 end
 
+if Gem::Version.create('3.0.0') <=  Gem::Version.create(RUBY_VERSION)
+  require_relative 'version_patches/ruby3'
+end
 require_relative 'version_patches/object'
 require_relative 'version_patches/exception'
 require_relative 'version_patches/hash'

data/lib/eco/api/custom/config.rb

@@ -0,0 +1,10 @@
+# Helper class to create a custom `Config`
+# @example Example of usage:
+#  class Custom::Config::BatchPolicies < Eco::API::Custom::Config
+#    batch_policies do
+#      create.max = 5
+#      update.max = 20
+#    end
+#  end
+class Eco::API::Custom::Config < Eco::API::Common::Loaders::Config
+end

data/lib/eco/api/custom/mailer.rb

@@ -0,0 +1,9 @@
+# Helper class to create a custom `Config`
+# @example Example of usage:
+#  class Custom::Workflow::Mailer < Eco::API::Custom::Mailer
+#    ORG = "Org Name"
+#  end
+class Eco::API::Custom::Mailer < Eco::API::Common::Loaders::Workflow::Mailer
+  extend Eco::Language::Klass::WhenInherited
+  when_inherited(&config_block)
+end

data/lib/eco/api/custom/namespace.rb

@@ -4,4 +4,6 @@ module Custom
   module Policy; end
   module ErrorHandler; end
   module Parser; end
+  module Config; end
+  module Workflow; end
 end

data/lib/eco/api/custom/workflow.rb

@@ -0,0 +1,9 @@
+# Helper class to create a custom `Config`
+# @example Example of usage:
+#  class Custom::Config::DefaultOptions < Eco::API::Custom::Workflow
+#    after(:options) do
+#      options.deep_merge!(send_invites: false) unless options.dig(:send_invites)
+#    end
+#  end
+class Eco::API::Custom::Workflow < Eco::API::Common::Loaders::Workflow
+end

data/lib/eco/api/custom.rb

@@ -7,6 +7,9 @@ module Eco
 end
 
 require_relative 'custom/namespace'
+require_relative 'custom/config'
+require_relative 'custom/workflow'
+require_relative 'custom/mailer'
 require_relative 'custom/use_case'
 require_relative 'custom/policy'
 require_relative 'custom/error_handler'

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

@@ -19,7 +19,6 @@ module Eco
         attr_reader :parent
         attr_reader :nodes, :children_count
         attr_reader :depth, :path
-        attr_reader :enviro
 
         attr_reader :source
 
@@ -35,7 +34,7 @@ module Eco
         #    ]}]
         #    tree = TagTree.new(tree.to_json)
         # @param tagtree [String] representation of the tagtree in json.
-        def initialize(tagtree = [], name: nil, id: nil, depth: -1, path: [], parent: nil, _weight: nil, enviro: nil)
+        def initialize(tagtree = [], name: nil, id: nil, depth: -1, path: [], parent: nil, _weight: nil)
           @depth  = depth
           @parent = parent
 
@@ -45,9 +44,7 @@ module Eco
           else
             @source = tagtree
           end
-          fatal("You are trying to initialize a TagTree with a null tagtree") if !@source
-          fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(API::Common::Session::Environment)
-          @enviro = enviro
+          raise ArgumentError, "You are trying to initialize a TagTree with a null tagtree" if !@source
 
           if @source.is_a?(Array)
             @id        = id
@@ -66,7 +63,7 @@ module Eco
           @path.push(@id) unless top?
 
           @nodes = @raw_nodes.map.with_index do |cnode, idx|
-            TagTree.new(cnode, depth: depth + 1, path: @path.dup, parent: self, _weight: idx, enviro: @enviro)
+            self.class.new(cnode, depth: depth + 1, path: @path.dup, parent: self, _weight: idx)
           end
 
           init_hashes
@@ -80,11 +77,28 @@ module Eco
           !archived?
         end
 
+        # @note that archived nodes will also be passed over to the copy
         # @return [Eco::API::Organization::TagTree]
         def dup
           self.class.new(as_json, name: name, id: id)
         end
 
+        # @return [Array] with the differences
+        def diff(tagtree, differences: {}, level: 0, **options)
+          require 'hashdiff'
+          Hashdiff.diff(self.as_json, tagtree.as_json, **options.slice(:array_path, :similarity, :use_lcs))
+        end
+
+        # It generates a merged tagtree out of two sources
+        # @note it merges the first level nodes (and their children) as it comes
+        # @return [Eco::API::Organization::TagTree] result of merging both trees
+        def merge(other)
+          raise ArgumentError, "Expecting Eco::API::Organization::TagTree. Given: #{other.class}" unless other.is_a?(Eco::API::Organization::TagTree)
+          mid   = [self.id, other.id].join('|')
+          mname = [self.name, other.name].join('|')
+          self.class.new(as_json | other.as_json, id: mid, name: mname)
+        end
+
         # @return [Eco::API::Organization::TagTree] with **non** `archived` nodes only
         def active_tree
           self.class.new(as_json(include_archived: false), name: name, id: id)
@@ -162,12 +176,6 @@ module Eco
           parent.name unless parent.top?
         end
 
-        # @return [Array] with the differences
-        def diff(tagtree, differences: {}, level: 0, **options)
-          require 'hashdiff'
-          Hashdiff.diff(self.as_json, tagtree.as_json, **options.slice(:array_path, :similarity, :use_lcs))
-        end
-
         def top?
           depth == -1
         end
@@ -410,17 +418,6 @@ module Eco
             h.merge(n.hash_paths)
           end
         end
-
-        def fatal(msg)
-          raise msg if !@enviro
-          @enviro.logger.fatal(msg)
-          raise msg
-        end
-
-        def warn(msg)
-          raise msg if !@enviro
-          @enviro.logger.warn(msg)
-        end
       end
     end
   end

data/lib/eco/api/session/batch/base_policy.rb

@@ -20,9 +20,10 @@ module Eco
         # @attr_reader min [Integer] `min` **required** number of occurrences of the property
         class BasePolicy
           extend Eco::API::Common::ClassHierarchy
+          # adds evaluate method to enable block calls as DSL
+          include Eco::Language::Methods::DslAble
 
           class << self
-
             # If the class for `key` exists, it returns it. Otherwise it generates it.
             # @note for this to work, `key` should be one of the submodels of the current class' `model`
             # @return [Eco::API::Session::Batch::BasePolicy] or subclass thereof
@@ -52,16 +53,14 @@ module Eco
                   end
 
                   if block
-                    block.call(policy)
+                    policy.evaluate(policy, &block)
                     self
                   else
                     policy
                   end
                 end
-
               end
             end
-
           end
 
           include Enumerable
@@ -75,6 +74,16 @@ module Eco
             @policies = {}
           end
 
+          def max(value = :unused)
+            return @max if value == :unused
+            self.max = value
+          end
+
+          def min(value = :unused)
+            return @min if value == :unused
+            self.min = value
+          end
+
           def attr(as_namespace: false)
             return @attr if !as_namespace || root?
             "#{@_parent.attr(as_namespace: true)}:#{@attr}"
@@ -222,7 +231,6 @@ module Eco
             return model if model.is_a?(Hash)
             model.to_h if model.respond_to?(:to_h)
           end
-
         end
       end
     end

data/lib/eco/api/session/batch/job.rb

@@ -9,6 +9,8 @@ module Eco
         # @attr_reader status [Eco::API::Session::Batch::Status] if launched: the `status` of the `batch`
         # @attr_reader feedback [Eco::API::Session::Batch::Feedback] helper class for feedback and end-user decision making
         class Job < Eco::API::Common::Session::BaseSession
+          include Eco::Language::Methods::DslAble
+
           @types = [:get, :create, :update, :delete]
           @sets  = [:core, :details, :account]
 
@@ -105,7 +107,7 @@ module Eco
                 unless unique && @queue_hash.key?(entry)
                   @queue_hash[entry] = true
                   @queue.push(entry)
-                  @callbacks[entry]  = Proc.new if block_given?
+                  @callbacks[entry]  = block if block_given?
                 end
               end
             end
@@ -230,13 +232,13 @@ module Eco
             end.join("\n")
           end
 
-          def as_update(data, *args)
+          def as_update(data, **kargs)
             if data.is_a?(Array)
               data.map do |e|
-                feedback.as_update(e, *args)
+                feedback.as_update(e, **kargs)
               end.compact.select {|e| e && !e.empty?}
             else
-              feedback.as_update(data, *args)
+              feedback.as_update(data, **kargs)
             end
           end
 
@@ -278,14 +280,15 @@ module Eco
           def api_included(full_queue)
             return full_queue if type == :create
             return full_queue unless excluded_callback = session.config.people.api_excluded
-            excluded = options.dig(:include, :excluded)
-            if excluded.is_a?(Hash) && excluded[:only]
-              full_queue.select {|entry| excluded_callback.call(entry, session, options, self)}
-            elsif options.dig(:include, :excluded)
-              full_queue
-            else
-              full_queue.select {|entry| !excluded_callback.call(entry, session, options, self)}
+
+            inc_excluded  = options.dig(:include, :excluded)
+            excluded_only = inc_excluded.is_a?(Hash) && excluded[:only]
+            is_excluded   = Proc.new do |entry|
+              evaluate(entry, session, options, self, &excluded_callback)
             end
+            return full_queue.select(&is_excluded) if excluded_only
+            return full_queue                      if inc_excluded
+            full_queue.reject(&is_excluded)
           end
 
           # Applies the changes introduced by api policies

data/lib/eco/api/session/batch/jobs.rb

@@ -74,10 +74,10 @@ module Eco
           # @yieldparam job [Eco::API::Session::Batch::Job] the job we have launched against the server.
           # @yieldparam status [Eco::API::Session::Batch::Status] the status of the batch job launch.
           # @return [Eco::API::Session::Batch::Job]
-          def add(job)
+          def add(job, &block)
             fatal "Expected Eco::API::Session::Batch::Job object. Given #{job.class}" unless job.is_a?(Eco::API::Session::Batch::Job)
             @jobs[job.name] = job
-            @callbacks[job] = Proc.new if block_given?
+            @callbacks[job] = block if block_given?
           end
 
           def pending?

data/lib/eco/api/session/batch/jobs_groups.rb

@@ -63,7 +63,7 @@ module Eco
           # @yieldparam group [Eco::API::Session::Batch::Jobs] the group of jobs we have launched against the server.
           # @yieldparam group_status [Hash<Eco::API::Session::Batch::Job, Eco::API::Session::Batch::Status>] the status of the launched batch jobs.
           # @return [Eco::API::Session::Batch::Jobs] the group of jobs.
-          def new(name, order: :last)
+          def new(name, order: :last, &block)
             fatal "Can't create job group named '#{name}' because it already exists." if exists?(name)
 
             Batch::Jobs.new(enviro, name: name).tap do |group|
@@ -75,7 +75,7 @@ module Eco
                 @order.unshift(group)
               end
 
-              @callbacks[group] = Proc.new if block_given?
+              @callbacks[group] = block if block_given?
             end
           end
 

data/lib/eco/api/session/config/files.rb

@@ -26,9 +26,9 @@ module Eco
 
           attr_key :timestamp_pattern
 
-          def add_validation(format)
+          def add_validation(format, &block)
             raise "Block must be given" unless block_given?
-            @validations[format] = Proc.new
+            @validations[format] = block
           end
 
           def validate(format, input)

data/lib/eco/api/session/config/people.rb

@@ -48,9 +48,9 @@ module Eco
           end
 
           # with given a person what is the criteria of exclusion
-          def api_excluded
+          def api_excluded(&block)
             return self["api_excluded"] unless block_given?
-            self["api_excluded"] = Proc.new
+            self["api_excluded"] = block
           end
 
           # internal-external fields map

data/lib/eco/api/session/config/sftp.rb

@@ -12,6 +12,10 @@ module Eco
             !!required
           end
 
+          def enviro_subpaths
+            self['enviro_subpaths'] ||= {}
+          end
+
           def enviro_subpath
             enviro_subpaths[config.active_enviro]
           end

data/lib/eco/api/session/config/tagtree.rb

@@ -8,6 +8,9 @@ module Eco
 
           attr_key :file, :structure_id
 
+          # @note it retrieves the tree this way:
+          #   1. If there's a file tagtree.json file, it uses it
+          #   2. If no file, retrieves `structure_id` (config)
           # @param include_archived [Boolean] whether or not it should include archived nodes.
           # @return [Eco::API::Organization::TagTree]
           def scope_tree(enviro: nil, include_archived: true, raise_on_missing: true)
@@ -20,7 +23,7 @@ module Eco
 
             if tree_file = self.file
               if (tree = file_manager.load_json(tree_file)) && !tree.empty?
-                @tagtree = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
+                @tagtree = Eco::API::Organization::TagTree.new(tree)
               end
             elsif self.structure_id
               kargs.merge(id: self.structure_id)
@@ -36,6 +39,7 @@ module Eco
 
           # Among all the locations structures it selects the one with more location nodes
           # If `id` is provided, it only retrieves this locations structure.
+          # @param [enviro] used for re-caching
           def live_tree(id: nil, enviro: nil, include_archived: false, **kargs, &block)
             existing_cache   = !!@live_tree
             first_load       = !existing_cache
@@ -47,7 +51,6 @@ module Eco
             refresh_cache    = existing_cache && !switching_target
 
             kargs = {
-              enviro:               enviro,
               includeArchivedNodes: include_archived
             }.merge(kargs)
 
@@ -81,7 +84,7 @@ module Eco
           # @note it does not memoize
           # @param include_archived [Boolean] whether or not to include archived **nodes**
           # @return [Eco::API::Organization::TagTree, NilClass]
-          def live_tree_get(id: nil, enviro: nil, include_archived: false, **kargs, &block)
+          def live_tree_get(id: nil, include_archived: false, **kargs, &block)
             return nil unless apis.active_api.version_available?(:graphql)
             return nil unless graphql = apis.api(version: :graphql)
 
@@ -92,14 +95,13 @@ module Eco
 
             return nil unless tree = graphql.currentOrganization.locationStructure(**kargs, &block)
 
-            args = { enviro: enviro, id: tree.id, name: tree.name }
-            Eco::API::Organization::TagTree.new(tree.treeify, **args)
+            Eco::API::Organization::TagTree.new(tree.treeify, id: tree.id, name: tree.name)
           end
 
           # Retrieves all the location structures of the organisation
           # @param include_archived [Boolean] whether or not to include archived **nodes**
           # @return [Array<Eco::API::Organization::TagTree>]
-          def live_trees(enviro: nil, include_archived: false, **kargs, &block)
+          def live_trees(include_archived: false, **kargs, &block)
             [].tap do |eco_trees|
               next unless apis.active_api.version_available?(:graphql)
               next unless graphql = apis.api(version: :graphql)
@@ -110,8 +112,7 @@ module Eco
 
               next unless trees = graphql.currentOrganization.locationStructures(**kargs, &block)
               trees.each do |tree|
-                args     = { enviro: enviro, id: tree.id, name: tree.name }
-                eco_tree = Eco::API::Organization::TagTree.new(tree.treeify, **args)
+                eco_tree = Eco::API::Organization::TagTree.new(tree.treeify, id: tree.id, name: tree.name)
                 eco_trees.push(eco_tree)
               end
             end