squared 0.5.16 → 0.6.0

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

@@ -10,9 +10,9 @@ module Squared
           include Common::Shell
           extend Forwardable
 
-          OPT_NAME = /\A(?:(--)|-)((?(1)[^=\s-][^=\s]*|[^=\s-]))\z/
-          OPT_VALUE = /\A-{0,2}([^=\s-][^=\s]*)(?:=|\s+)(\S.*)\z/
-          OPT_SINGLE = /\A-([^=\s-])(.+)\z/
+          OPT_NAME = /\A(?:(--)|-)((?(1)[A-Za-z\d]+|[A-Za-z\d]))\z/
+          OPT_VALUE = /\A-{0,2}([^= ]+)(?: *= *| +)(.+)\z/
+          OPT_SINGLE = /\A-([A-Za-z\d])(.+)\z/
           private_constant :OPT_NAME, :OPT_VALUE, :OPT_SINGLE
 
           class << self
@@ -21,19 +21,33 @@ module Squared
             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.is_a?(String) ? val.gsub(pat, s || '') : val }
+                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
+                  if escape
                     shell_escape(val, quote: quote, double: double)
                   else
                     shell_quote(val, force: force, double: double)
@@ -45,13 +59,13 @@ module Squared
               else
                 target.concat(ret)
               end
-              ret
+              err || ret
             end
 
             def clear(target, opts, pass: true, styles: nil, **kwargs)
               return if opts.empty?
 
-              kwargs[:subject] ||= stripext target.first
+              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)
@@ -86,24 +100,29 @@ module Squared
               ret.select { |val| single ? val.size == 1 : val.size > 1 }
             end
 
-            def arg?(target, *args, value: false, **)
-              r, s = args.partition { |val| val.is_a?(Regexp) }
-              r << matchopts(s, value) unless s.empty?
-              a = target.to_a
-              if (n = a.index('--'))
-                a = a[0..n]
+            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
-              r.any? { |pat| a.any?(pat) }
-            end
+              data = keys.map { |item| item[1].size > 1 ? item[1][0..-2] : [] }.reject(&:empty?)
+              return if data.empty?
 
-            def opt?(val)
-              return false unless val.is_a?(String)
+              data.each { |key| key.each { |i| list[i] = nil } }
+              list.compact!
+              list
+            end
 
-              val.start_with?('-') && (OPT_NAME.match?(val) || OPT_VALUE.match?(val) || OPT_SINGLE.match?(val))
+            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 pattern?(val)
-              val.match?(/(?:\A\^|\$\z)/) || val.match?(/(?:\.[*+]|\(\?:|\\[dsw]|\[.+\]|\{\d+,?\d*})/)
+              val.match?(/(?:\A\^|\$\z)/) || val.match?(/(?:\.[*+]|\(\?:|\\[dsw]|\[.+\]|\{\d+,?\d*\})/)
             end
 
             private
@@ -121,23 +140,22 @@ module Squared
             end
 
             def shortopt(*group)
-              group.map! { |s| Regexp.escape(s.delete_prefix('-')) }
-              "-(?:#{group.join('|')})(?:\\z|[^ =]| +[^ -])"
+              group.map! { |s| s.delete_prefix('-') }
+              "-(?:#{Regexp.escape(group.join('|'))})(?:\\z|[^ =]| +[^ -])"
             end
 
             def longopt(*group, value)
-              group.map! { |s| Regexp.escape(s.delete_prefix('--')) }
-              "--(?:#{group.join('|')})(?:#{value ? '=[^ ]| +[^ -]' : '[= ]|\z'})"
+              group.map! { |s| s.delete_prefix('--') }
+              "--(?:#{Regexp.escape(group.join('|'))})(?:#{value ? '=[^ ]| +[^ -]' : '[= ]|\z'})"
             end
           end
 
-          attr_reader :target, :extras, :found, :errors, :values, :project, :path
+          attr_reader :target, :extras, :found, :errors, :values, :project, :path, :sep
 
           def_delegators :@target, :+, :-, :<<, :any?, :none?, :include?, :add, :add?, :find, :find_all, :find_index,
-                         :merge, :compact, :delete, :delete?, :delete_if, :grep, :grep_v, :inspect, :to_a, :to_s
-          def_delegators :@extras, :empty?, :each, :each_with_index, :partition, :dup, :first, :last, :shift, :unshift,
-                         :pop, :push, :concat, :index, :join, :map, :map!, :detect, :select, :select!, :reject, :size,
-                         :delete_at
+                         :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
@@ -145,10 +163,11 @@ module Squared
           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, **kwargs, &blk)
+          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)
@@ -182,7 +201,7 @@ module Squared
             .each do |val|
               if (n = val.index('='))
                 flag = val[0, n]
-                case val[n + 1]
+                case val[n.succ]
                 when 'e'
                   e << flag
                 when 'b'
@@ -207,7 +226,7 @@ module Squared
                 else
                   next
                 end
-                m << flag if flag.size == 1 && val[n + 2] == 'm'
+                m << flag if val[n + 2] == 'm'
                 bare << flag if val.end_with?('?')
               else
                 bare << val
@@ -216,7 +235,7 @@ module Squared
             no = (no || []).map { |val| (n = val.index('=')) ? val[0, n] : val }
             bare.concat(no)
             if underscore
-              tr = ->(list) { list.map { |val| val.tr('-', '_') } }
+              tr = ->(a) { a.map { |val| val.tr('-', '_') } }
               @values.concat(tr.call(@values))
               bare.concat(tr.call(bare))
               e.concat(tr.call(e))
@@ -236,7 +255,7 @@ module Squared
               [f, /\A\d*(?:\.\d+)?\z/],
               [si, /\A-?\d+\z/]
             ].freeze
-            numcheck = ->(k, v) { numtype.any? { |flag, pat| flag.include?(k) && pat.match?(v) } }
+            numcheck = ->(k, v) { numtype.any? { |flag, pat| flag.include?(k) && v.match?(pat) } }
             skip = false
             opts.each do |opt|
               next skip = true if opt == '--'
@@ -254,21 +273,21 @@ module Squared
                   val = $2
                   merge = m.include?(key)
                   if e.include?(key)
-                    add shell_option(key, val, merge: merge)
+                    add shell_option(key, val, merge: merge, sep: sep)
                   elsif q.include?(key)
-                    add quote_option(key, val, double: qq.include?(key), merge: merge)
+                    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)
+                      add shell_option(key, val, escape: false, merge: merge, sep: sep)
                     elsif path
-                      add quote_option(key, path + val, merge: merge)
+                      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)
+                    add basic_option(key, val, merge: merge, sep: sep)
                   elsif merge
-                    add basic_option(key, val, merge: true)
+                    add basic_option(key, val, merge: true, sep: sep)
                   else
                     push opt
                   end
@@ -280,28 +299,33 @@ module Squared
                 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('|')})=(.+)\z/m
+            @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)
+          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)
+          def append(*args, **kwargs, &blk)
             args = extras if args.empty?
-            OptionPartition.append(target, *args, **kwargs)
+            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
@@ -319,7 +343,7 @@ module Squared
           end
 
           def values_of(*args, strict: true, first: false, last: false)
-            eq, s = strict ? ['=', '[^ ]+'] : ['(?:=| +)', '[^-][^ ]*']
+            eq, s = strict ? [sep, '[^ ]+'] : ['(?:=| +)', '[^-][^ ]*']
             g = ["\"((?:[^\"]|(?<=\\\\)\"(?!$#{windows? ? '| ' : ''}))*)\""]
             g << "'((?:[^']|'\\\\'')*)'" unless windows?
             g << "(#{s})"
@@ -358,23 +382,19 @@ module Squared
           def clear(opts = nil, errors: false, **kwargs)
             styles = project.theme[:inline] if project
             if errors
-              OptionPartition.clear(target, self.errors, styles: styles, **kwargs)
-              self.errors.clear
+              OptionPartition.clear(target, @errors, styles: styles, **kwargs)
+              @errors.clear
               return self unless opts
             end
             opts ||= extras
-            OptionPartition.clear(target, if found.empty?
-                                            opts
-                                          else
-                                            opts.reject { |val| found.include?(val) }
-                                          end, styles: styles, **kwargs)
+            OptionPartition.clear(target, opts - found, styles: styles, **kwargs)
             opts.clear
             self
           end
 
           def adjoin(*args, with: nil, start: false)
-            i = -1
-            temp = compact
+            index = -1
+            temp = to_a
             if with
               pat = case with
                     when String, Symbol
@@ -384,53 +404,114 @@ module Squared
                     else
                       with
                     end
-              temp.each_with_index do |val, index|
+              temp.each_with_index do |val, i|
                 if val.to_s.match?(pat)
-                  i = index + (start.is_a?(Numeric) ? start : 1)
+                  index = i + (start.is_a?(Numeric) ? start : 1)
                   break
                 end
               end
             else
-              temp.each_with_index do |val, index|
-                if i == 0
-                  next unless val.is_a?(String) && val.start_with?('-')
+              temp.each_with_index do |val, i|
+                if index == 0
+                  next unless val.start_with?('-')
 
-                  i = index
+                  index = i
                   break
-                elsif index > 0 && !val.to_s.start_with?('-')
+                elsif i > 0 && !val.start_with?('-')
                   if start
-                    i = index + (start.is_a?(Numeric) ? start : 1)
+                    index = i + (start.is_a?(Numeric) ? start : 1)
                     break
                   end
-                  i = 0
+                  index = 0
                 end
               end
             end
-            if i > 0
+            if index > 0
               if args.empty?
                 args = dup
                 reset
               else
                 args.each { |val| remove val }
               end
-              args = temp[0...i] + args + temp[i..-1]
+              args = temp[0...index] + args + temp[index..-1]
               target.clear
             end
             merge args
             self
           end
 
-          def add_path(*args, **kwargs)
-            add shell_quote(path ? path.join(*args) : File.join(*args), option: false, **kwargs)
+          def add_path(*args, force: true, double: false, **kwargs)
+            if args.empty?
+              args = select { |s| s.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) })
+            merge(args.compact.map! { |val| 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)
@@ -464,7 +545,7 @@ module Squared
             self
           end
 
-          def append?(key, val = nil, type: nil, force: false, **kwargs)
+          def append?(key, val = nil, type: nil, force: false, sep: '=', **kwargs)
             return false unless force || !arg?(key)
 
             val = yield self if block_given?
@@ -473,11 +554,11 @@ module Squared
             type ||= :quote if kwargs.empty?
             add case type
                 when :quote
-                  quote_option(key, val)
+                  quote_option(key, val, sep: sep)
                 when :basic
-                  basic_option(key, val)
+                  basic_option(key, val, sep: sep)
                 else
-                  shell_option(key, val, **kwargs)
+                  shell_option(key, val, sep: sep, **kwargs)
                 end
             true
           end
@@ -486,24 +567,23 @@ module Squared
             OptionPartition.arg?(target, *args, **kwargs)
           end
 
-          def exist?(*args, add: false, first: false, last: false)
-            return false unless path
-            return path.join(*args).exist? unless args.empty?
+          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).is_a?(String)
+              return false unless (val = first ? self.first : self.last)
 
-              path.join(val).exist?.tap do |ret|
+              with_glob?(val, glob).tap do |ret|
                 next unless add && ret
 
-                add_path(first ? shift : pop)
+                add_first(path: true, reverse: !first)
               end
             else
-              each_with_index do |val, index|
-                next unless val.is_a?(String) && path.join(val).exist?
+              each_with_index do |val, i|
+                next unless with_glob?(val, glob)
 
                 if add
-                  remove_at index
+                  remove_at i
                   add_path val
                 end
                 return true
@@ -525,8 +605,13 @@ module Squared
             val[OPT_VALUE, 1] || val
           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?
-            require 'rake'
             Rake::Win32.windows?
           end
         end
@@ -536,50 +621,40 @@ module Squared
             super[/[^:]+\z/, 0]
           end
 
-          alias to_ary to_a
-
-          attr_reader :delim, :extras
+          attr_reader :delim
 
-          def initialize(data = [], delim: ' ', partition: '--', uniq: /\A--?[^=\s-][^=\s]*(?:=|\s+)\S/)
-            @delim = delim
-            @partition = partition
-            @uniq = uniq
-            @extras = []
+          def initialize(data = [], delim: ' ')
             super(data.compact)
-          end
-
-          def compact
-            to_ary.map!(&:to_s).reject(&:empty?)
+            @delim = delim
           end
 
           def last(val, pat)
-            (@last ||= []).append([val, pat, $1]) if val =~ pat
+            (@last ||= []).push([val, pat, $1]) if val =~ pat
             self << val
           end
 
           def pass(&blk)
-            ret = compact
+            ret = to_a.map!(&:to_s).reject(&:empty?)
             @last&.each do |val, pat, key|
-              i = []
-              j = nil
-              ret.each_with_index do |opt, index|
+              items = []
+              index = nil
+              ret.each_with_index do |opt, i|
                 if opt == val
-                  j = index
-                elsif j && opt[pat, 1] == key
-                  i << index
+                  index = i
+                elsif index && opt[pat, 1] == key
+                  items << i
                 end
               end
-              next unless j && !i.empty?
+              next unless index && !items.empty?
 
-              val = ret[j]
-              cur = j
-              i.each do |k|
+              val = ret[index]
+              cur = index
+              items.each do |k|
                 ret[cur] = ret[k]
                 cur = k
               end
-              ret[i.last] = val
+              ret[items.last] = val
             end
-            ret.concat(extras.map(&:to_s).reject(&:empty?)) unless extras.empty?
             return ret unless block_given?
 
             ret.reject(&blk)
@@ -601,73 +676,18 @@ module Squared
 
           def temp(*args, &blk)
             args.compact!
-            pass(&blk)
-              .concat(args)
-              .join(@delim)
+            ret = pass(&blk)
+            ret = Set.new(ret.concat(args)).to_a unless args.empty?
+            ret.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)
-            extras!(obj) || super
-          end
-
-          def add?(obj)
-            extras!(obj) || super
-          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
-
-          private
-
-          def extras!(obj)
-            return if extras.empty? && !extras?(obj)
-
-            extras << obj unless !extras.include?(@partition) && include?(obj) && @uniq.match?(obj.to_s)
-            self
-          end
-
-          def extras?(obj)
-            obj == @partition || (include?(obj) && !@uniq.match?(obj.to_s))
-          end
         end
       end
     end