squared 0.6.2 → 0.6.3

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

@@ -0,0 +1,641 @@
+# 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.*)\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.is_a?(String) ? val.gsub(pat, s || '') : val }
+              end
+              ret, err = ret.partition { |val| filter.match?(val.to_s) } 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)}]", '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
+
+            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?
+              a = target.to_a
+              if (n = a.index('--'))
+                a = a[0..n]
+              end
+              r.any? { |pat| a.any?(pat) }
+            end
+
+            def opt?(val)
+              return false unless val.is_a?(String)
+
+              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| Regexp.escape(s.delete_prefix('-')) }
+              "-(?:#{group.join('|')})(?:\\z|[^ =]| +[^ -])"
+            end
+
+            def longopt(*group, value)
+              group.map! { |s| Regexp.escape(s.delete_prefix('--')) }
+              "--(?:#{group.join('|')})(?:#{value ? '=[^ ]| +[^ -]' : '[= ]|\z'})"
+            end
+          end
+
+          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, :shift, :unshift,
+                         :pop, :push, :concat, :index, :join, :detect, :map, :map!, :select, :select!, :slice, :slice!,
+                         :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
+
+          def parse(list, opts = extras, no: nil, single: nil, args: false, first: nil, underscore: nil, &blk)
+            @extras = []
+            @values = []
+            bare = []
+            e = []
+            b = []
+            m = []
+            p = []
+            q = []
+            qq = []
+            i = []
+            f = []
+            si = []
+            bl = []
+            ml = []
+            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
+                when '+'
+                  ml << flag
+                  bare << 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))
+              ml.concat(tr.call(ml))
+              no.concat(tr.call(no))
+            end
+            target.multiple = ml.map { |val| val.size == 1 ? "-#{val}" : "--#{val}" } if target.is_a?(JoinSet)
+            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 = ["\"((?:[^\"]|(?<=\\\\)\"(?!$#{'| ' if 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 = compact
+            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.is_a?(String) && val.start_with?('-')
+
+                  index = i
+                  break
+                elsif i > 0 && !val.to_s.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)
+            merge(args.compact
+                      .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 && val.is_a?(String)
+              unless block_given? && !(val = yield val).is_a?(String)
+                if path
+                  add_path(val, **kwargs)
+                elsif quote
+                  add_quote(val, **kwargs)
+                else
+                  add val
+                end
+              end
+            elsif expect
+              raise(expect.is_a?(String) ? expect : 'no value to add')
+            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)
+          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
+            end
+          end
+
+          def uniq!(list)
+            unless (list = uniq(list)).empty?
+              concat list
+              self
+            end
+          end
+
+          private
+
+          def nameonly(val)
+            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
+      end
+    end
+  end
+end

data/lib/squared/workspace/project.rb

@@ -7,6 +7,5 @@ module Squared
   end
 end
 
-require_relative 'project/support'
 require_relative 'project/base'
 require_relative 'project/git'