squared 0.6.1 → 0.6.3

data/lib/squared/workspace/project/base.rb

@@ -3,6 +3,8 @@
 require 'json'
 require 'logger'
 
+require_relative 'support/class'
+
 module Squared
   module Workspace
     module Project
@@ -109,11 +111,11 @@ module Squared
 
         subtasks({
           'graph' => %i[run print].freeze,
-          'unpack' => %i[zip gz tar ext].freeze,
+          'unpack' => %i[zip gz tar ext],
           'asdf' => %i[set exec current update latest where reshim]
         })
 
-        attr_reader :name, :project, :workspace, :path, :theme, :group, :parent, :dependfile,
+        attr_reader :name, :project, :workspace, :path, :theme, :group, :parent, :children, :dependfile,
                     :exception, :pipe, :verbose, :global
 
         def initialize(workspace, path, name, *, group: nil, first: {}, last: {}, error: {}, common: ARG[:COMMON],
@@ -380,11 +382,7 @@ module Squared
                       if flag == :run
                         graph args
                       else
-                        out, done = graph(args, out: [])
-                        out.map! do |val|
-                          n = done.index { |proj| val.match?(/ #{Regexp.escape(proj.name)}(?:@\d|\z)/) }
-                          n ? val.subhint(n.succ) : val
-                        end
+                        out = graph(args, out: [], order: {})
                         emphasize(out, title: path, right: true, border: borderstyle, sub: [
                           opt_style(theme[:header], /\A(#{Regexp.escape(path.to_s)})(.*)\z/),
                           opt_style(theme[:active], /\A(#{Regexp.escape(name)})(.*)\z/),
@@ -491,7 +489,7 @@ module Squared
               proj = self
               instance_eval(&blk) if block_given?
             end
-            @children << proj
+            children << proj
           end
           self
         end
@@ -553,31 +551,31 @@ module Squared
             cmd = cmd.join(' && ')
           else
             cmd, opts, var, flags, extra = args
-          end
-          if cmd
-            return run_b(cmd, sync: sync, from: from) if cmd.is_a?(Proc) || cmd.is_a?(Method)
-
-            cmd = as_get cmd, from
-            opts = compose(opts, script: false) if opts && respond_to?(:compose)
-            flags = append_hash(flags, target: []).join(' ') if flags.is_a?(Hash)
-            case opts
-            when Hash
-              cmd = Array(cmd).push(flags)
-                              .concat(append_hash(opts, target: [], build: true))
-                              .compact
-                              .join(' ')
-            when Enumerable
-              cmd = Array(cmd).concat(opts.to_a)
-              cmd.map! { |val| "#{val} #{flags}" } if flags
-              cmd = cmd.join(' && ')
+            if cmd
+              return run_b(cmd, sync: sync, from: from) if cmd.is_a?(Proc) || cmd.is_a?(Method)
+
+              cmd = as_get cmd, from
+              opts = compose(opts, script: false) if opts && respond_to?(:compose)
+              flags = append_hash(flags, target: []).join(' ') if flags.is_a?(Hash)
+              cmd = case opts
+                    when Hash
+                      Array(cmd).push(flags)
+                                .concat(append_hash(opts, target: [], build: true))
+                                .compact
+                                .join(' ')
+                    when Enumerable
+                      cmd = Array(cmd).concat(opts.to_a)
+                      cmd.map! { |val| "#{val} #{flags}" } if flags
+                      cmd.join(' && ')
+                    else
+                      [cmd, flags, opts].compact.join(' ')
+                    end
             else
-              cmd = [cmd, flags, opts].compact.join(' ') if opts || flags
-            end
-          else
-            return unless (opts || extra) && respond_to?(:compose)
+              return unless (opts || extra) && respond_to?(:compose)
 
-            cmd = compose(as_get(opts, from), flags, script: true, args: extra, from: from)
-            from = :script if from == :run && script?
+              cmd = compose(as_get(opts, from), flags, script: true, args: extra, from: from)
+              from = :script if from == :run && script?
+            end
           end
           run(cmd, var, sync: sync, banner: banner, from: from)
         end
@@ -596,12 +594,12 @@ module Squared
                 if proj.respond_to?(meth.to_sym)
                   begin
                     proj.__send__(meth, sync: sync)
-                    next
                   rescue StandardError => e
                     on_error(e, :prereqs, exception: true)
                   end
+                else
+                  print_error(name, "method: #{meth}", subject: 'prereqs', hint: 'undefined')
                 end
-                print_error(name, 'method not found', subject: 'prereqs', hint: meth)
               end
             elsif proj.build?
               proj.build(sync: sync)
@@ -618,7 +616,7 @@ module Squared
         end
 
         def doc(*, sync: invoked_sync?('doc'), **)
-          run_b(@doc, sync: sync, banner: from_base?('doc') ? verbose? : verbosetype > 0, from: :doc)
+          run_b(@doc, sync: sync, banner: from_base?('doc') ? verbose? : !silent?, from: :doc)
         end
 
         def lint(*, sync: invoked_sync?('lint'), **)
@@ -659,7 +657,7 @@ module Squared
                 entry = basepath(val = val.to_s)
                 if entry.directory? && val.match?(%r{[\\/]\z})
                   log&.warn "rm -rf #{entry}"
-                  rm_rf(entry, verbose: verbosetype > 0)
+                  rm_rf(entry, verbose: !silent?)
                 else
                   log&.warn "rm #{entry}"
                   (val.include?('*') ? Dir[entry] : [entry]).each do |file|
@@ -678,7 +676,7 @@ module Squared
           on :last, :clean unless pass
         end
 
-        def graph(start = [], tasks = nil, *, sync: invoked_sync?('graph'), pass: [], out: nil, **)
+        def graph(start = [], tasks = nil, *, sync: invoked_sync?('graph'), pass: [], out: nil, order: nil, **)
           env('GRAPH', strict: true) do |val|
             tasks ||= []
             split_escape(val) do |task|
@@ -696,12 +694,19 @@ module Squared
             data[name] << self
             on :first, :graph
           end
-          ret = graph_branch(self, data, tasks, out, sync: sync, pass: pass)
+          ret = graph_branch(self, data, tasks, out, sync: sync, pass: pass, order: order)
         rescue StandardError => e
           on_error(e, :graph, exception: true)
         else
           if out
-            [out, ret]
+            if order
+              out.map! do |val|
+                name = ret.find { |proj| val.match?(/ #{Regexp.escape(proj.name)}(?:@\d|\z)/) }&.name
+                (n = name && order[name]) ? val.subhint(n.succ) : val
+              end
+            else
+              [out, ret]
+            end
           else
             on :last, :graph
           end
@@ -770,7 +775,7 @@ module Squared
               break uri = url if data
             end
             unless data && (ext ||= URI.decode_www_form_component(URI.parse(uri).path[/\.([\w%]+)(?:\?|\z)/, 1]))
-              raise_error(data ? TypeError : RuntimeError, "no content#{data ? ' type' : ''}", hint: uri)
+              raise_error(data ? TypeError : RuntimeError, "no content#{' type' if data}", hint: uri)
             end
           end
           ext = ext.downcase
@@ -800,7 +805,7 @@ module Squared
             when 'zip', 'aar'
               session 'unzip', shell_quote(file), quote_option('d', target)
             when 'tar', /\A(?:t|tar\.)?[gx]z\z/
-              flags = +(verbose ? 'v' : '')
+              flags = +(silent? ? '' : 'v')
               if ext.end_with?('gz')
                 flags += 'z'
               elsif ext.end_with?('xz')
@@ -865,7 +870,7 @@ module Squared
             cmd << name
           else
             cmd << name
-            banner = flag == :update || flag == :reshim
+            banner = false if flag == :latest || flag == :where
           end
           success?(run(banner: banner, from: :"asdf:#{flag}"), flag == :set || flag == :reshim)
         end
@@ -918,16 +923,16 @@ module Squared
 
           cmd = cmd.target if cmd.is_a?(OptionPartition)
           if interactive && sync && (!@session || !option('y'))
-            title, y, hint = case interactive
-                             when Array
-                               interactive
-                             when String
-                               [interactive, 'N']
-                             else
-                               ['Run', 'Y']
-                             end
-            title = "#{title} #{sub_style(hint, styles: theme[:active])}" if hint
-            exit 1 unless confirm_basic("#{title}?", cmd, y)
+            msg, y, h = case interactive
+                        when Array
+                          interactive
+                        when String
+                          [interactive, 'N']
+                        else
+                          %w[Run Y]
+                        end
+            msg = "#{msg} #{sub_style(h, theme[:active])}" if h
+            exit 1 unless confirm_basic("#{msg}?", cmd, y)
           end
           cmd = session_done cmd
           log&.info cmd
@@ -1023,6 +1028,8 @@ module Squared
         end
 
         def exist?(*args)
+          return false if (args = args.compact).empty?
+
           basepath(*args).exist?
         end
 
@@ -1083,6 +1090,10 @@ module Squared
           @prod != false && workspace.prod?(pat: @prod, **scriptargs)
         end
 
+        def empty?
+          children.empty?
+        end
+
         def exclude?(*refs)
           !@exclude.empty? && has_value?(@exclude, refs.flatten)
         end
@@ -1157,7 +1168,7 @@ module Squared
           log_console(*args, pipe: kwargs[:pipe] || pipe)
         end
 
-        def run_s(*cmd, sync: true, banner: verbosetype > 0, from: nil, **kwargs)
+        def run_s(*cmd, sync: true, banner: !silent?, from: nil, **kwargs)
           cmd.flatten!
           case cmd.last
           when Hash, TrueClass, FalseClass
@@ -1202,11 +1213,11 @@ module Squared
           end
         end
 
-        def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], depth: 0,
+        def graph_branch(target, data, tasks = nil, out = nil, sync: true, pass: [], done: [], order: nil, depth: 0,
                          single: false, last: false, context: nil)
-          tag = ->(proj) { "#{proj.name}#{SEM_VER.match?(proj.version) ? "@#{proj.version}" : ''}" }
+          tag = ->(proj) { "#{proj.name}#{"@#{proj.version}" if SEM_VER.match?(proj.version)}" }
           script = ->(proj) { workspace.script_get(:graph, group: proj.group, ref: proj.allref)&.fetch(:graph, nil) }
-          dedupe = lambda do |name|
+          uniq = lambda do |name|
             next [] unless (ret = data[name])
 
             ret.dup.each do |proj|
@@ -1217,7 +1228,7 @@ module Squared
             ret
           end
           if depth == 0
-            items = dedupe.call(target.name) - done
+            items = uniq.call(target.name) - done
             single = items.size == 1
           else
             items = data[target.name] - done
@@ -1241,7 +1252,7 @@ module Squared
           items.each_with_index do |proj, i|
             next if done.include?(proj)
 
-            t = dedupe.call(name = proj.name)
+            t = uniq.call(name = proj.name)
             j = if out
                   if i == items.size.pred || (post = items[i.succ..-1] - done).empty?
                     true
@@ -1250,10 +1261,41 @@ module Squared
                   end
                 end
             unless target.name == name || (none = (t - done).empty?)
-              graph_branch(proj, data, tasks, out, sync: sync, pass: pass, done: done, depth: depth.succ,
+              graph_branch(proj, data, tasks, out, sync: sync, pass: pass, done: done, order: order, depth: depth.succ,
                                                    single: single, last: j == true, context: target)
             end
-            if !out
+            if out
+              if none
+                a, b, c, d = ARG[:GRAPH]
+                out << if depth == 0
+                         "#{i == items.size.pred ? d : c}#{b * 4} #{tag.call(proj)}"
+                       else
+                         s = +''
+                         k = 0
+                         final = data.keys.last
+                         while k < depth
+                           indent = k > 0 ? ((last && !j) || (j && k == depth.pred) || single) : j && last && depth == 1
+                           s += "#{indent || (last && data[final].last == context) ? ' ' : a}   "
+                           k += 1
+                         end
+                         s += "#{j ? d : c}#{b * 3} #{tag.call(proj)}"
+                       end
+              end
+              if order
+                n = order.size
+                order[name] ||= if proj.parent
+                                  if order[s = proj.parent.name]
+                                    order[s] += 1
+                                    n.pred
+                                  else
+                                    order[s] = n.succ
+                                    n
+                                  end
+                                else
+                                  n
+                                end
+              end
+            else
               (tasks || (subtasks = script.call(proj)) || (dev? ? %w[build copy] : %w[depend build])).each do |meth|
                 next if pass.include?(meth)
 
@@ -1269,21 +1311,6 @@ module Squared
                   proj.__send__(meth.to_sym, sync: sync)
                 end
               end
-            elsif none
-              a, b, c, d = ARG[:GRAPH]
-              out << if depth == 0
-                       "#{i == items.size.pred ? d : c}#{b * 4} #{tag.call(proj)}"
-                     else
-                       s = ''.dup
-                       k = 0
-                       final = data.keys.last
-                       while k < depth
-                         indent = k > 0 ? ((last && !j) || (j && k == depth.pred) || single) : j && last && depth == 1
-                         s += "#{indent || (last && data[final].last == context) ? ' ' : a}   "
-                         k += 1
-                       end
-                       s + "#{j ? d : c}#{b * 3} #{tag.call(proj)}"
-                     end
             end
             done << proj
           end
@@ -1299,16 +1326,22 @@ module Squared
               obj.enabled? ? [obj] : []
             else
               workspace.find(group: val, ref: val.to_sym)
+            end.sort do |a, b|
+              if a.parent == b
+                -1
+              else
+                b.parent == a ? 1 : 0
+              end
             end.each do |proj|
               next if pass.include?(name = proj.name)
 
               if proj.graph? && !data.key?(name) && !root.include?(name)
                 graph_collect(proj, data: data, pass: pass, root: root + [name, target.name])
               end
-              unless (objs = data.fetch(name, [])).include?(target)
-                deps << proj
-                deps.concat(objs)
-              end
+              next if (objs = data.fetch(name, [])).include?(target)
+
+              deps << proj
+              deps.concat(objs)
             end
           end
           deps.uniq!
@@ -1344,11 +1377,13 @@ module Squared
                   ENV[name] || ENV.fetch(key, '')
                 end
           if !equals.nil?
-            ret = ret == equals.to_s
+            ret = Array(equals).any? { |val| ret == val.to_s }
           elsif ret.empty? || (ignore && Array(ignore).any? { |val| ret == val.to_s })
             ret = default
           end
-          block_given? && !ret.nil? ? yield(ret) : ret
+          return yield ret if block_given? && !ret.nil?
+
+          ret
         end
 
         def session(*cmd, prefix: cmd.first, main: true, path: true, options: true)
@@ -1359,14 +1394,16 @@ module Squared
           ret = JoinSet.new(cmd.flatten(1))
           if options
             env("#{prefix.upcase}_OPTIONS") do |val|
-              if val.start_with('-')
-                ret.concat(shell_parse(val))
+              if val.start_with?('-')
+                ret.merge(shell_parse(val))
               else
-                split_escape(val) { |opt| ret.last(fill_option(opt), /\A(--?[^= ]+)[= ].+\z/m) }
+                split_escape(val) { |opt| ret.last(fill_option(opt), /\A(--?[^=\s-][^=\s]*)[=\s].+\z/m) }
               end
             end
           end
-          main ? @session = ret : ret
+          return ret unless main
+
+          @session = ret
         end
 
         def session_output(*cmd, **kwargs)
@@ -1495,7 +1532,7 @@ module Squared
               val
             end
           end
-          (lines << sub_style(ARG[:BORDER][1] * n, styles: border)).join("\n")
+          (lines << sub_style(ARG[:BORDER][1] * n, border)).join("\n")
         end
 
         def print_footer(*lines, sub: nil, reverse: false, right: false, border: borderstyle, **)
@@ -1503,30 +1540,32 @@ module Squared
           sub = as_a sub
           lines.map! do |val|
             s = right ? val.rjust(n) : val.ljust(n)
-            sub.each { |h| s = sub_style(s, **h) }
+            sub.each { |h| sub_style!(s, **h) }
             s
           end
-          [sub_style(ARG[:BORDER][1] * n, styles: border)].concat(lines)
-                                                          .tap { |ret| ret.reverse! if reverse }
-                                                          .join("\n")
+          [sub_style(ARG[:BORDER][1] * n, border)].concat(lines)
+                                                  .tap { |ret| ret.reverse! if reverse }
+                                                  .join("\n")
         end
 
         def print_status(*args, from: nil, **kwargs)
-          return if stdin?
+          return if stdin? || silent?
 
           case from
           when :outdated
             out = print_footer("major #{args[0]} / minor #{args[1]} / patch #{args[2]}", right: true).split("\n")
-            out[1] = sub_style(out[1], **opt_style(theme[:major], /^( +major )(\d+)(.+)$/, 2))
-            out[1] = sub_style(out[1], **opt_style(theme[:active], /^(.+)(minor )(\d+)(.+)$/, 3))
-            out[1] = sub_style(out[1], **opt_style(theme[:current], /^(.+)(patch )(\d+)(.+)$/, 3)) if theme[:current]
-            puts out
+            sub_style!(out[1], **opt_style(theme[:major], /^( +major )(\d+)(.+)$/, 2))
+            sub_style!(out[1], **opt_style(theme[:active], /^(.+)(minor )(\d+)(.+)$/, 3))
+            sub_style!(out[1], **opt_style(theme[:current], /^(.+)(patch )(\d+)(.+)$/, 3)) if theme[:current]
           when :completed
-            return unless verbose && kwargs[:start]
+            return unless kwargs[:start]
 
-            puts log_message(Logger::INFO, *args, sub_style('completed', styles: theme[:active]),
-                             subject: kwargs[:subject], hint: time_format(time_epoch - kwargs[:start]))
+            out = log_message(Logger::INFO, *args, sub_style('completed', theme[:active]),
+                              subject: kwargs[:subject], hint: time_format(time_epoch - kwargs[:start]))
+          else
+            return
           end
+          puts out
         end
 
         def format_desc(action, flag, opts = nil, **kwargs)
@@ -1619,7 +1658,7 @@ module Squared
         end
 
         def empty_status(msg, title, obj, always: false)
-          "#{msg}#{!always && (!obj || obj == 0 || obj.to_s.empty?) ? '' : message(hint: message(title, obj.to_s))}"
+          "#{msg}#{message(hint: message(title, obj.to_s)) unless !always && (!obj || obj == 0 || obj.to_s.empty?)}"
         end
 
         def append_repeat(flag, opts, target: @session)
@@ -1699,11 +1738,12 @@ module Squared
                           **kwargs)
           return if list.empty?
 
+          kwargs[:ignore] = false if no && !kwargs.key?(:ignore)
           [].tap do |ret|
             list.flatten.each do |flag|
               next unless (val = option(flag, target: target, **kwargs))
 
-              if val == '0' && no
+              if no && val == '0'
                 flag = "no-#{flag}"
                 val = nil
               end
@@ -1804,6 +1844,12 @@ module Squared
           print_error(e, subject: name)
         end
 
+        def parse_env(key)
+          env(key) do |val|
+            val.start_with?('-') ? shell_parse(val) : split_escape(val).map! { |opt| fill_option(opt) }
+          end || []
+        end
+
         def param_guard(action, flag, args:, key: nil, pat: nil, values: nil)
           if args && key
             val = args.fetch(key, nil)
@@ -1819,29 +1865,44 @@ module Squared
         end
 
         def confirm_basic(msg, target, default = 'Y', style: :inline, **kwargs)
-          confirm("#{msg} [#{sub_style(target.to_s, styles: theme[style])}]", default, **kwargs)
+          confirm("#{msg} [#{sub_style(target.to_s, theme[style])}]", default, **kwargs)
         end
 
-        def confirm_outdated(pkg, ver, rev, cur = nil, lock: false, col1: 0, **kwargs)
-          a = sub_style(case rev
+        def confirm_outdated(pkg, ver, rev, cur = nil, lock: false, col0: 0, col1: 0, col2: nil, col3: 0, col4: 0,
+                             **kwargs)
+          h = sub_style(case rev
                         when 1
                           'MAJOR'
                         when 2
                           'MINOR'
                         else
                           'PATCH'
-                        end, styles: (rev == 1 && theme[:major]) || theme[:header])
-          b = sub_style(pkg.ljust(col1), styles: theme[:inline])
-          c = lock ? sub_style((cur || 'locked').rjust(7), styles: color(:red)) : cur&.rjust(7)
+                        end, (rev == 1 && theme[:major]) || theme[:header])
+          case col0
+          when 0
+            col0 = "#{h}: "
+          when Numeric
+            puts h
+            col0 = ' ' * col0
+          else
+            puts h
+          end
+          b = sub_style pkg.ljust(col1), theme[:inline]
+          cur ||= 'locked' if lock
+          c = if cur
+                cur = cur.ljust(col2 || cur.size.succ)
+                lock ? sub_style(cur, color(:red)) : cur
+              end
           d = rev == 1 || lock ? 'N' : 'Y'
-          confirm("#{a}: #{b}#{c} #{sub_style(ver.rjust(col1 > 0 ? 10 : 0), styles: theme[:inline])}  ", d, **kwargs)
+          e = "#{col0}#{b}#{c}#{sub_style(col1 > 0 ? ver.ljust(col3) : ver.rjust(ver.size.succ), theme[:inline])}"
+          confirm("#{e}#{col4 > 0 ? ' ' * [col4 - e.stripstyle.size - 1, 2].max : '  '}", d, **kwargs)
         end
 
         def choice_index(msg, list, values: nil, accept: nil, series: false, trim: nil, column: nil, multiple: false,
                          force: true, **kwargs)
           puts unless series || printfirst?
           ret = choice(msg, list, multiple: multiple, force: force, **kwargs).tap do |val|
-            next unless val.empty?
+            next unless !val || val.empty?
 
             exit 1 if force
             return nil
@@ -1853,12 +1914,12 @@ module Squared
             ret = ret.first unless multiple
           end
           if accept
-            hint = Array(ret).map { |val| sub_style(val.to_s, styles: theme[:inline]) }.join(', ')
+            hint = Array(ret).map { |val| sub_style(val.to_s, theme[:inline]) }.join(', ')
             accept = Array(accept).map { |val| Array(val) }
             ret = Array(ret) if accept.any? { |val| val[1] == true }
             loop do
               item = accept.first
-              c = confirm("#{item[0]}#{hint ? " [#{hint}]" : ''}", item[2] ? 'Y' : 'N')
+              c = confirm("#{item[0]}#{" [#{hint}]" if hint}", item[2] ? 'Y' : 'N')
               if item[1] == true
                 ret << c
               elsif !c
@@ -2012,7 +2073,7 @@ module Squared
         end
 
         def indexerror(val, list = nil)
-          raise_error IndexError, "requested index #{val}", hint: list && "of #{list.size}"
+          raise_error IndexError, "requested index #{val}", hint: ("of #{list.size}" if list)
         end
 
         def indexchar
@@ -2188,7 +2249,7 @@ module Squared
         end
 
         def theme_set(common)
-          @theme = if !verbose
+          @theme = if silent?
                      {}
                    elsif common
                      workspace.theme
@@ -2223,7 +2284,7 @@ module Squared
                   __send__ key
                 end
               end
-              next if (items = @children.select { |item| item.task_include?(key) }).empty?
+              next if (items = children.select { |item| item.task_include?(key) }).empty?
 
               ws.task_desc(@desc, action, 'workspace')
               task task_join(action, 'workspace') => items.map! { |item| task_join(item.name, action) }
@@ -2304,7 +2365,13 @@ module Squared
           else
             $?.success?
           end.tap do |ret|
-            print_success if ret && stdout? && banner? && cond.none? { |val| val == false }
+            next unless cond.none? { |val| val == false }
+
+            if block_given?
+              yield ret
+            elsif ret && stdout? && banner?
+              print_success
+            end
           end
         end
 
@@ -2328,20 +2395,42 @@ module Squared
           verbosetype > 1
         end
 
+        def silent?
+          verbosetype == 0
+        end
+
         def warning?
           workspace.warning
         end
 
         def has_value?(target, *args)
+          return false unless target.is_a?(Enumerable)
+
           args = args.first if args.size == 1 && args.first.is_a?(Enumerable)
           case target
           when Hash
             args.is_a?(Enumerable) ? args.any? { |obj| target.value?(obj) } : target.value?(args)
-          when Enumerable
-            args.is_a?(Enumerable) ? args.any? { |obj| target.include?(obj) } : target.include?(args)
           else
-            false
+            args.is_a?(Enumerable) ? args.any? { |obj| target.include?(obj) } : target.include?(args)
+          end
+        end
+
+        def has_value!(target, *args, first: false)
+          return unless target.is_a?(Enumerable)
+
+          args = args.first if args.size == 1 && args.first.is_a?(Enumerable)
+          found = false
+          args.each do |val|
+            if target.respond_to?(:delete?)
+              found = true if target.delete?(val)
+            elsif target.respond_to?(:delete)
+              found = true if target.delete(val)
+            elsif target.include?(val)
+              found = true
+            end
+            break if found && first
           end
+          target if found
         end
 
         def variables