squared 0.6.1 → 0.6.3

data/lib/squared/workspace/project/support/class.rb

@@ -1,638 +1,55 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module Squared
   module Workspace
     module Project
       module Support
-        class OptionPartition
-          include Common::Shell
-          extend Forwardable
-
-          OPT_NAME = /\A(?:(--)|-)((?(1)[^\[\]=\s-][^\[\]=\s]*|[^\[\]=\s-]))\z/
-          OPT_VALUE = /\A-{0,2}([^\[\]=\s-][^\[\]=\s]*)(?:\s*=\s*|\s+)(.+)\z/
-          OPT_SINGLE = /\A-([^\[\]=\s-])(.+)\z/
-          private_constant :OPT_NAME, :OPT_VALUE, :OPT_SINGLE
-
-          class << self
-            include Common::Format
-            include Shell
-            include Prompt
-
-            def append(target, *args, delim: false, escape: false, quote: true, strip: nil, force: true, double: false,
-                       filter: nil, **)
-              return if (ret = args.flatten).empty?
-
-              target << '--' if delim && !target.include?('--')
-              if strip
-                pat, s = Array(strip)
-                ret.map! { |val| val.gsub(pat, s || '') }
-              end
-              ret, err = ret.partition { |val| filter.match?(val) } if filter
-              if block_given?
-                out = []
-                err ||= []
-                ret.each do |val|
-                  case (s = yield val)
-                  when String
-                    out << s
-                  when NilClass, FalseClass
-                    err << val
-                  else
-                    out << val
-                  end
-                end
-                ret = out
-              end
-              if escape || quote
-                ret.map! do |val|
-                  if opt?(val)
-                    val
-                  elsif escape
-                    shell_escape(val, quote: quote, double: double)
-                  else
-                    shell_quote(val, force: force, double: double)
-                  end
-                end
-              end
-              if target.is_a?(Set)
-                target.merge(ret)
-              else
-                target.concat(ret)
-              end
-              err || ret
-            end
-
-            def clear(target, opts, pass: true, styles: nil, **kwargs)
-              return if opts.empty?
-
-              kwargs[:subject] ||= target.first.stripext
-              kwargs[:hint] ||= 'unrecognized'
-              append(target, opts, delim: true) if kwargs.delete(:append)
-              warn log_message(Logger::WARN, opts.join(', '), pass: true, **kwargs)
-              exit 1 unless pass || confirm("Run? [#{sub_style(target, styles: styles)}]", 'N')
-            end
-
-            def delete_key(target, *args, value: false, reverse: false, count: -1)
-              ret = []
-              args.each do |val|
-                next if (opts = target.grep(matchopt(val, value))).empty?
-
-                opts = opts.first(count) if count >= 0
-                opts.send(reverse ? :reverse_each : :each) { |key| target.delete(key) }
-                ret.concat(opts)
-              end
-              ret
-            end
-
-            def strip(val)
-              return [] unless val
-
-              val = shell_split val if val.is_a?(String)
-              val.map { |s| s.sub(OPT_SINGLE, '\1=\2').sub(OPT_VALUE, '\1=\2').sub(OPT_NAME, '\2') }.reject(&:empty?)
-            end
-
-            def select(list, bare: true, no: true, single: false, double: false)
-              ret = bare ? list.grep_v(/=/) : list.grep(/=/).map! { |val| val.split('=', 2).first }
-              ret.map! { |val| val.split('|', 2).last }
-              ret = ret.grep_v(/\Ano-/) unless no
-              return ret if single == double
-
-              ret.select { |val| single ? val.size == 1 : val.size > 1 }
-            end
+        autoload :OptionPartition, File.expand_path('optionpartition', __dir__)
 
-            def uniq!(list, pass = [])
-              keys = {}
-              list.each_with_index do |val, i|
-                j = val =~ OPT_VALUE ? $1 : val
-                (keys[j] ||= []) << i unless pass.include?(j)
-              end
-              data = keys.map { |item| item[1].size > 1 ? item[1][0..-2] : [] }.reject(&:empty?)
-              return if data.empty?
-
-              data.each { |key| key.each { |i| list[i] = nil } }
-              list.compact!
-              list
-            end
-
-            def arg?(target, *args, value: false, **)
-              r, s = args.partition { |val| val.is_a?(Regexp) }
-              r << matchopts(s, value) unless s.empty?
-              s = target.to_a.compact
-              r.any? { |pat| s.any?(pat) }
-            end
-
-            def opt?(val)
-              val.start_with?('-') && (OPT_NAME.match?(val) || OPT_VALUE.match?(val) || OPT_SINGLE.match?(val))
-            end
-
-            def pattern?(val)
-              val.match?(/(?:\A\^|\$\z)/) || val.match?(/(?:\.[*+]|\(\?:|\\[dsw]|\[.+\]|\{\d+,?\d*\})/)
-            end
-
-            private
-
-            def matchopt(val, value = false)
-              /\A#{val.size == 1 ? shortopt(val) : longopt(val, value)}/
-            end
-
-            def matchopts(list, value = false)
-              a, b = Array(list).partition { |val| val.size == 1 || val.match?(OPT_SINGLE) }
-              return /\A#{shortopt(*a)}}/ if b.empty?
-              return /\A#{longopt(*b, value)}/ if a.empty?
-
-              /\A(?:#{shortopt(*a)}|#{longopt(*b, value)})/
-            end
-
-            def shortopt(*group)
-              group.map! { |s| s.delete_prefix('-') }
-              "-(?:#{Regexp.escape(group.join('|'))})(?:\\z|[^ =]| +[^ -])"
-            end
-
-            def longopt(*group, value)
-              group.map! { |s| s.delete_prefix('--') }
-              "--(?:#{Regexp.escape(group.join('|'))})(?:#{value ? '=[^ ]| +[^ -]' : '[= ]|\z'})"
-            end
+        class JoinSet < Set
+          def self.to_s
+            super[/[^:]+\z/, 0]
           end
 
-          attr_reader :target, :extras, :found, :errors, :values, :project, :path, :sep
+          alias to_ary to_a
 
-          def_delegators :@target, :+, :-, :<<, :any?, :none?, :include?, :add, :add?, :find, :find_all, :find_index,
-                         :merge, :delete, :delete?, :delete_if, :grep, :grep_v, :inspect, :to_a, :to_s
-          def_delegators :@extras, :empty?, :each, :each_with_index, :partition, :dup, :first, :shift, :unshift,
-                         :pop, :push, :concat, :index, :join, :map, :map!, :detect, :select, :select!, :reject, :size
-
-          def_delegator :@extras, :delete, :remove
-          def_delegator :@extras, :delete_at, :remove_at
-          def_delegator :@extras, :delete_if, :remove_if
-          def_delegator :@extras, :find_all, :detect_all
-          def_delegator :@extras, :find_index, :detect_index
-
-          def initialize(opts, list, target = Set.new, project: nil, path: nil, sep: '=', **kwargs, &blk)
-            @target = target.is_a?(Set) ? target : target.to_set
-            @project = project
-            @path = path || project&.path
-            @sep = sep
-            @errors = []
-            @found = []
-            parse(list, opts, **kwargs, &blk)
-          end
+          attr_reader :delim, :extras, :multiple
 
-          def parse(list, opts = extras, no: nil, single: nil, args: false, first: nil, underscore: nil, &blk)
+          def initialize(data = [], delim: ' ', partition: '--', uniq: /\A--?[^=\s-]/, multiple: [])
+            @delim = delim
+            @partition = partition
+            @uniq = uniq
+            @multiple = multiple
             @extras = []
-            @values = []
-            bare = []
-            e = []
-            b = []
-            m = []
-            p = []
-            q = []
-            qq = []
-            i = []
-            f = []
-            si = []
-            bl = []
-            list.flat_map do |val|
-              x, y = val.split('|', 2)
-              if y
-                if (n = val.index('='))
-                  x += val[n..-1]
-                end
-                [x, y]
-              else
-                x
-              end
-            end
-            .each do |val|
-              if (n = val.index('='))
-                flag = val[0, n]
-                case val[n.succ]
-                when 'e'
-                  e << flag
-                when 'b'
-                  b << flag
-                when 'm'
-                  m << flag
-                when 'q'
-                  qq << flag if val[n + 2] == 'q'
-                  q << flag
-                when 'p'
-                  p << flag
-                when 'i'
-                  i << flag
-                when 'f'
-                  f << flag
-                when 'n'
-                  si << flag
-                when 'v'
-                  @values << Regexp.escape(flag)
-                when '!'
-                  bl << flag
-                else
-                  next
-                end
-                m << flag if val[n + 2] == 'm'
-                bare << flag if val.end_with?('?')
-              else
-                bare << val
-              end
-            end
-            no = (no || []).map { |val| (n = val.index('=')) ? val[0, n] : val }
-            bare.concat(no)
-            if underscore
-              tr = ->(a) { a.map { |val| val.tr('-', '_') } }
-              @values.concat(tr.call(@values))
-              bare.concat(tr.call(bare))
-              e.concat(tr.call(e))
-              b.concat(tr.call(b))
-              m.concat(tr.call(m))
-              p.concat(tr.call(p))
-              q.concat(tr.call(q))
-              qq.concat(tr.call(qq))
-              i.concat(tr.call(i))
-              f.concat(tr.call(f))
-              si.concat(tr.call(si))
-              bl.concat(tr.call(bl))
-              no.concat(tr.call(no))
-            end
-            numtype = [
-              [i, /\A\d+\z/],
-              [f, /\A\d*(?:\.\d+)?\z/],
-              [si, /\A-?\d+\z/]
-            ].freeze
-            numcheck = ->(k, v) { numtype.any? { |flag, pat| flag.include?(k) && v.match?(pat) } }
-            skip = false
-            opts.each do |opt|
-              next skip = true if opt == '--'
-              next push opt if skip
-
-              if single&.match?(opt)
-                add "-#{opt}"
-              elsif bare.include?(opt)
-                add(opt.size == 1 ? "-#{opt}" : "--#{opt}")
-              elsif opt.start_with?(/no[-_]/) && no.include?(name = opt[3..-1])
-                add "--no-#{name}"
-              else
-                if opt =~ OPT_VALUE
-                  key = $1
-                  val = $2
-                  merge = m.include?(key)
-                  if e.include?(key)
-                    add shell_option(key, val, merge: merge, sep: sep)
-                  elsif q.include?(key)
-                    add quote_option(key, val, double: qq.include?(key), merge: merge, sep: sep)
-                  elsif p.include?(key)
-                    if val.match?(/\A(["']).+\1\z/)
-                      add shell_option(key, val, escape: false, merge: merge, sep: sep)
-                    elsif path
-                      add quote_option(key, path + val, merge: merge, sep: sep)
-                    else
-                      push opt
-                    end
-                  elsif b.include?(key) || (bl.include?(key) && %w[true false].include?(val)) || numcheck.call(key, val)
-                    add basic_option(key, val, merge: merge, sep: sep)
-                  elsif merge
-                    add basic_option(key, val, merge: true, sep: sep)
-                  else
-                    push opt
-                  end
-                  opt = key
-                else
-                  push opt
-                  skip = true if args
-                end
-                skip = true if first&.any? { |s| s.is_a?(Regexp) ? opt.match?(s) : !opt.include?(s) }
-              end
-            end
-            @values = @values.empty? ? /\A\s+\z/ : /\A(#{@values.join('|')})#{sep}(.+)\z/m
-            @extras.each_with_index(&blk) if block_given?
-            self
-          end
-
-          def swap(opts = nil, &blk)
-            unless opts
-              opts = found
-              @found = []
-            end
-            opts.sort!(&blk) if block_given?
-            @extras = opts
-            self
-          end
-
-          def append(*args, **kwargs, &blk)
-            args = extras if args.empty?
-            out = OptionPartition.append(target, *args, **kwargs, &blk)
-            errors.concat(out) if out && (block_given? || kwargs[:filter])
-            self
-          end
-
-          def append_any(*args, quote: true, **kwargs)
-            (args.empty? ? extras : args.flatten).each do |val|
-              val = yield val if block_given?
-              next unless val.is_a?(String)
-
-              if exist?(val)
-                add_path(val, **kwargs)
-              elsif quote
-                add_quote(val, **kwargs)
-              else
-                add val
-              end
-            end
-            self
-          end
-
-          def delete_key(*args, **kwargs)
-            OptionPartition.delete_key(target, *args, **kwargs)
-            self
-          end
-
-          def values_of(*args, strict: true, first: false, last: false)
-            eq, s = strict ? [sep, '[^ ]+'] : ['(?:=| +)', '[^-][^ ]*']
-            g = ["\"((?:[^\"]|(?<=\\\\)\"(?!$#{windows? ? '| ' : ''}))*)\""]
-            g << "'((?:[^']|'\\\\'')*)'" unless windows?
-            g << "(#{s})"
-            args.map! do |opt|
-              if opt.size == 1
-                /(?:\A| )-#{opt} ?([^ ]+)/
-              else
-                /(?:\A| )--#{opt + eq}(?:#{g.join('|')})/
-              end
-            end
-            ret = []
-            target.each do |opt|
-              args.each do |pat|
-                next unless opt =~ pat
-
-                ret << ($1 || $2 || $3)
-                break
-              end
-            end
-            return ret unless first || last
-
-            if last.is_a?(Numeric)
-              ret.last(last)
-            elsif last
-              ret.last
-            else
-              first.is_a?(Numeric) ? ret.first(first) : ret.first
-            end
-          end
-
-          def uniq(list)
-            ignore = map { |val| nameonly(val) }
-            list.reject { |val| ignore.include?(s = nameonly(val)) || any?(OptionPartition.send(:matchopt, s)) }
-          end
-
-          def clear(opts = nil, errors: false, **kwargs)
-            styles = project.theme[:inline] if project
-            if errors
-              OptionPartition.clear(target, @errors, styles: styles, **kwargs)
-              @errors.clear
-              return self unless opts
-            end
-            opts ||= extras
-            OptionPartition.clear(target, opts - found, styles: styles, **kwargs)
-            opts.clear
-            self
-          end
-
-          def adjoin(*args, with: nil, start: false)
-            index = -1
-            temp = to_a
-            if with
-              pat = case with
-                    when String, Symbol
-                      /\A#{Regexp.escape(with)}\z/
-                    when Array
-                      OptionPartition.send(:matchopts, with)
-                    else
-                      with
-                    end
-              temp.each_with_index do |val, i|
-                if val.to_s.match?(pat)
-                  index = i + (start.is_a?(Numeric) ? start : 1)
-                  break
-                end
-              end
-            else
-              temp.each_with_index do |val, i|
-                if index == 0
-                  next unless val.start_with?('-')
-
-                  index = i
-                  break
-                elsif i > 0 && !val.start_with?('-')
-                  if start
-                    index = i + (start.is_a?(Numeric) ? start : 1)
-                    break
-                  end
-                  index = 0
-                end
-              end
-            end
-            if index > 0
-              if args.empty?
-                args = dup
-                reset
-              else
-                args.each { |val| remove val }
-              end
-              args = temp[0...index] + args + temp[index..-1]
-              target.clear
-            end
-            merge args
-            self
-          end
-
-          def add_path(*args, force: true, double: false, **kwargs)
-            if args.empty?
-              args = select { |val| val.is_a?(String) }
-              args.map! { |val| path + val } if path
-              append(args, force: force, **kwargs)
-            else
-              add shell_quote(path ? path.join(*args) : File.join(*args), option: false, force: force, double: double)
-            end
-            self
-          end
-
-          def add_quote(*args, **kwargs)
-            args.compact!
-            merge(args.map! { |val| val == '--' || OptionPartition.opt?(val) ? val : shell_quote(val, **kwargs) })
-            self
-          end
-
-          def add_option(flag, val = nil, **kwargs)
-            add shell_option(flag, val, **kwargs)
-            self
-          end
-
-          def add_first(fallback = nil, prefix: nil, path: false, quote: false, reverse: false, expect: false, **kwargs)
-            val = (reverse ? pop : shift) || fallback
-            if val
-              val.delete_prefix!(prefix) if prefix
-              return self if block_given? && !(val = yield val).is_a?(String)
-
-              if path
-                add_path(val, **kwargs)
-              elsif quote
-                add_quote(val, **kwargs)
-              else
-                add val
-              end
-            elsif expect
-              raise(expect.is_a?(String) ? expect : 'no value provided')
-            end
-            self
-          end
-
-          def last(val = nil, &blk)
-            unless block_given?
-              case val
-              when NilClass
-                return extras.last
-              when Numeric
-                return extras.last(val)
-              when String, Array, Regexp
-                val = OptionPartition.send(:matchopts, val) unless val.is_a?(Regexp)
-                blk = proc { |s| s&.match?(val) }
-              else
-                raise TypeError, "unknown: #{val}"
-              end
-            end
-            ret = find_all(&blk)
-            unless ret.empty?
-              ret = case val
-                    when NilClass
-                      ret.first(1)
-                    when Numeric
-                      ret.first(val)
-                    else
-                      ret
-                    end
-              ret.each do |opt|
-                delete opt
-                add opt
-              end
-            end
-            val.nil? ? ret.first : ret
-          end
-
-          def splice(*exclude, quote: true, delim: true, path: false, pattern: false, &blk)
-            found, other = if block_given?
-                             partition(&blk)
-                           elsif exclude.first.is_a?(Symbol)
-                             partition(&exclude.first)
-                           else
-                             partition do |val|
-                               next false if pattern && OptionPartition.pattern?(val)
-
-                               exclude.none? { |pat| val.match?(Regexp.new(pat)) }
-                             end
-                           end
-            unless found.empty?
-              add '--' if delim
-              extras.clear
-              concat other
-              if path
-                found.each { |val| add_path(val) }
-              else
-                found.map! { |val| shell_quote(val) } if quote
-                merge found
-              end
-            end
-            self
-          end
-
-          def reset(errors: false)
-            extras.clear
-            found.clear
-            clear(errors: true) if errors
-            self
-          end
-
-          def append?(key, val = nil, type: nil, force: false, sep: '=', **kwargs)
-            return false unless force || !arg?(key)
-
-            val = yield self if block_given?
-            return false unless val
-
-            type ||= :quote if kwargs.empty?
-            add case type
-                when :quote
-                  quote_option(key, val, sep: sep)
-                when :basic
-                  basic_option(key, val, sep: sep)
-                else
-                  shell_option(key, val, sep: sep, **kwargs)
-                end
-            true
-          end
-
-          def arg?(*args, **kwargs)
-            OptionPartition.arg?(target, *args, **kwargs)
+            super(data.compact)
           end
 
-          def exist?(*args, add: false, first: false, last: false, glob: false)
-            return with_glob?(File.join(*args), glob) unless args.empty?
-
-            if first || last
-              return false unless (val = first ? self.first : self.last)
-
-              with_glob?(val, glob).tap do |ret|
-                next unless add && ret
-
-                add_first(path: true, reverse: !first)
-              end
-            else
-              each_with_index do |val, i|
-                next unless with_glob?(val, glob)
-
-                if add
-                  remove_at i
-                  add_path val
-                end
-                return true
-              end
-              false
+          def multiple=(val)
+            case val
+            when Enumerable
+              @multiple.concat(val.to_a.map(&:to_s))
+            when String, Symbol, Pathname
+              @multiple << val.to_s
+            when NilClass, FalseClass
+              @multiple.clear
             end
           end
 
-          def uniq!(list)
-            unless (list = uniq(list)).empty?
-              concat list
-              self
-            end
+          def insert(*args)
+            replace Set.new(compact.insert(*args))
           end
 
-          private
-
-          def nameonly(val)
-            val[OPT_VALUE, 1] || val
+          def slice(*args)
+            compact.slice(*args)
           end
 
-          def with_glob?(val, glob = true)
-            return false unless path && val.is_a?(String) && !val.empty?
-
-            path.join(val).exist? || (glob && !path.glob(val).empty?)
-          end
-
-          def windows?
-            Rake::Win32.windows?
-          end
-        end
-
-        class JoinSet < Set
-          def self.to_s
-            super[/[^:]+\z/, 0]
+          def slice!(*args)
+            data = compact
+            data.slice!(*args).tap { replace Set.new(data) }
           end
 
-          attr_reader :delim
-
-          def initialize(data = [], delim: ' ')
-            super(data.compact)
-            @delim = delim
+          def compact
+            to_ary.map!(&:to_s).reject(&:empty?)
           end
 
           def last(val, pat)
@@ -641,7 +58,7 @@ module Squared
           end
 
           def pass(&blk)
-            ret = to_a.map!(&:to_s).reject(&:empty?)
+            ret = compact
             @last&.each do |val, pat, key|
               items = []
               index = nil
@@ -662,6 +79,7 @@ module Squared
               end
               ret[items.last] = val
             end
+            ret.concat(extras.map(&:to_s).reject(&:empty?)) unless extras.empty?
             return ret unless block_given?
 
             ret.reject(&blk)
@@ -683,18 +101,72 @@ module Squared
 
           def temp(*args, &blk)
             args.compact!
-            ret = pass(&blk)
-            ret = Set.new(ret.concat(args)).to_a unless args.empty?
-            ret.join(@delim)
+            pass(&blk)
+              .concat(args)
+              .join(@delim)
           end
 
           def done
             to_s.tap { clear }
           end
 
+          def merge(enum)
+            if !extras.empty?
+              extras.concat(enum.to_a)
+              self
+            elsif (n = enum.find_index { |val| extras?(val) })
+              data = enum.to_a
+              @extras = if n == 0
+                          data
+                        else
+                          super(data[0...n])
+                          data[n..-1]
+                        end
+              self
+            else
+              super
+            end
+          end
+
+          def <<(obj)
+            return super if extras.empty? && !extras?(obj)
+
+            unless !extras.include?(@partition) && include?(obj) && @uniq.match?(s = obj.to_s) && !multiple.include?(s)
+              extras << obj
+            end
+            self
+          end
+
+          def to_a
+            pass
+          end
+
           def to_s
             pass.join(@delim)
           end
+
+          def to_enum(*args)
+            pass.to_enum(*args)
+          end
+
+          def to_json(*args)
+            pass.to_json(*args)
+          end
+
+          def to_yaml(*args)
+            pass.to_yaml(*args)
+          end
+
+          alias add :<<
+          alias add? :<<
+          alias push :<<
+          alias concat merge
+
+          private
+
+          def extras?(obj)
+            obj == @partition || (include?(obj) && (!@uniq.match?(s = obj.to_s) || multiple.include?(s)))
+          end
         end
       end
     end