squared 0.6.18 → 0.7.0

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

@@ -27,12 +27,12 @@ module Squared
           def multiple=(val)
             case val
             when Enumerable
-              @multiple.concat(val.to_a.map { |pat| pat.is_a?(Regexp) ? pat : pat.to_s })
+              @multiple.concat(val.to_a.map { |val| val.is_a?(Regexp) ? val : val.to_s })
             when String, Symbol, Pathname
               @multiple << val.to_s
             when Regexp
               @multiple << val
-            when NilClass, FalseClass
+            when nil, false
               @multiple.clear
             end
           end
@@ -47,7 +47,9 @@ module Squared
 
           def slice!(*args)
             data = compact
-            data.slice!(*args).tap { replace Set.new(data) }
+            ret = data.slice!(*args)
+            replace Set.new(data)
+            ret
           end
 
           def compact
@@ -109,7 +111,9 @@ module Squared
           end
 
           def done
-            to_s.tap { clear }
+            ret = to_s
+            clear
+            ret
           end
 
           def merge(enum)
@@ -131,10 +135,12 @@ module Squared
           end
 
           def <<(obj)
-            return super if extras.empty? && !extras?(obj)
+            unless obj.nil?
+              return super if extras.empty? && !extras?(obj)
 
-            unless !extras.include?(@partition) && include?(obj) && @uniq.match?(s = obj.to_s) && !multiple?(s)
-              extras << obj
+              unless !extras.include?(@partition) && include?(obj) && @uniq.match?(s = obj.to_s) && !multiple?(s)
+                extras << obj
+              end
             end
             self
           end

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

@@ -21,37 +21,38 @@ module Squared
             include Prompt
 
             def append(target, *args, delim: false, escape: false, quote: true, strip: nil, force: true, double: false,
-                       filter: nil, preserve: true, **)
-              return if (ret = args.flatten).empty?
+                       filter: nil, pass: nil, **)
+              return if (ret = args.flatten(1)).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 filter
+                ret, err = ret.partition { |val| filter.match?(val.to_s) }
+                pass&.concat(err)
+              end
               if block_given?
-                out = []
-                err ||= []
-                ret.each do |val|
-                  case (s = yield val)
+                ret = ret.each_with_object([]) do |val, out|
+                  arg = yield val
+                  case arg
                   when String
-                    out << s
-                  when NilClass, FalseClass
-                    err << val
+                    out << arg
+                  when nil, false
+                    pass&.push(val)
                   else
                     out << val
                   end
                 end
-                ret = out
               end
               ret.map! do |val|
                 next val if opt?(val)
 
-                if !(pa = val.is_a?(Pathname)) && escape
+                if quote || val.is_a?(Pathname)
+                  shell_quote(val, force: force, double: double)
+                elsif escape
                   shell_escape(val, quote: quote, double: double)
-                elsif quote || pa
-                  shell_quote(val, force: force, double: double, preserve: preserve)
                 else
                   val
                 end
@@ -61,7 +62,7 @@ module Squared
               else
                 target.concat(ret)
               end
-              err || ret
+              ret
             end
 
             def clear(target, opts, pass: true, styles: nil, **kwargs)
@@ -75,42 +76,23 @@ module Squared
             end
 
             def delete_key(target, *args, value: false, reverse: false, count: -1)
-              ret = []
-              args.each do |val|
+              args.each_with_object([]) do |val, out|
                 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)
+                out.concat(opts)
               end
-              ret
             end
 
             def strip(val)
               val = shell_split val if val.is_a?(String)
-              ret = []
-              pass = -1
-              (args = Array(val)).each_with_index do |s, i|
-                next if s.empty? || pass == i
-
-                if s == '--'
-                  ret << s << args[i.succ..-1].join(' ')
-                  break
-                end
-                next ret << s unless s.start_with?('-')
-
-                if !s.include?('=') && (j = args[i.succ]) && !j.start_with?('-')
-                  ret << "#{s.sub(/^-{1,2}/, '')}=#{j}"
-                  pass = i.succ
-                else
-                  ret << s.sub(OPT_SINGLE, '\1=\2').sub(OPT_VALUE, '\1=\2').sub(OPT_NAME, '\2')
-                end
-              end
-              ret
+              Array(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 = 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
@@ -132,6 +114,18 @@ module Squared
               list
             end
 
+            def parse_option(val)
+              val = val.strip
+              return [val, nil, ''] unless (i = val.index('='))
+
+              last = val[i.succ..-1].strip
+              if last =~ /\A(["'])(.*)\1\z/m
+                last = $2
+                quote = $1
+              end
+              [val[0..i.pred], last, quote || '']
+            end
+
             def parse_arg!(name, val)
               return unless val.is_a?(String)
 
@@ -158,11 +152,8 @@ module Squared
             end
 
             def pattern?(val)
-              Regexp.new(val)
               val.start_with?('\A', '^') || val.end_with?('\z', '$') ||
-              val.match?(/[.)][*+?]|\(\?[:=!><]|\\[dsw\d]|\[.+\]|\{\d+,?\d*\}/i)
-            rescue RegexpError
-              false
+              val.match?(/[.)][*+?]|\(\?:|\\[dsw\d]|\[.+\]|\{\d+,?\d*\}/i)
             end
 
             private
@@ -180,13 +171,13 @@ module Squared
             end
 
             def shortopt(*group)
-              group.map! { |s| Regexp.escape(s.delete_prefix('-')) }
-              "-(?:#{group.join('|')})(?:\\z|[^ =]| +[^ -])"
+              g = group.map { |s| Regexp.escape(s.delete_prefix('-')) }
+              "-(?:#{g.join('|')})(?:\\z|[^ =]| +[^ -])"
             end
 
             def longopt(*group, value)
-              group.map! { |s| Regexp.escape(s.delete_prefix('--')) }
-              "--(?:#{group.join('|')})(?:#{value ? '=[^ ]| +[^ -]' : '[= ]|\z'})"
+              g = group.map { |s| Regexp.escape(s.delete_prefix('--')) }
+              "--(?:#{g.join('|')})(?:#{value ? '=[^ ]| +[^ -]' : '[= ]|\z'})"
             end
           end
 
@@ -303,7 +294,7 @@ module Squared
             end
             numtype = [
               [i, /\A\d+\z/],
-              [f, /\A(\d+(\.\d*)?|\d*\.\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) } }
@@ -338,8 +329,8 @@ module Squared
                   elsif q.include?(key)
                     add quote_option(key, val, double: qq.include?(key), merge: merge, sep: sep)
                   elsif p.include?(key)
-                    if val =~ /\A(["']).+\1\z/
-                      add shell_option(key, val, double: $1 == '"', escape: false, merge: merge, sep: sep)
+                    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
@@ -357,7 +348,7 @@ module Squared
                   push opt
                   skip = true if args
                 end
-                skip = true if first&.any? { |pat| pat.is_a?(Regexp) ? opt.match?(pat) : !opt.include?(pat) }
+                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
@@ -375,23 +366,23 @@ module Squared
             self
           end
 
-          def append(*args, clear: false, preserve: '"', **kwargs, &blk)
-            args = clear ? extras.dup.tap { extras.clear } : extras if args.empty?
-            out = OptionPartition.append(target, *args, preserve: preserve, **kwargs, &blk)
-            errors.concat(out) if out && (block_given? || kwargs[:filter])
+          def append(*args, **kwargs, &blk)
+            args = extras if args.empty?
+            pass = kwargs[:pass] ||= []
+            OptionPartition.append(target, *args, **kwargs, &blk)
+            errors.concat(pass)
             self
           end
 
-          def append_any(*args, escape: false, **kwargs)
-            quote = kwargs.fetch(:quote, true)
-            (args.empty? ? extras : args.flatten).each do |val|
+          def append_any(*args, escape: false, quote: true, **kwargs)
+            (args.empty? ? extras : args.flatten(1)).each do |val|
               if block_given?
                 temp = val
                 val = yield val
                 if val.is_a?(Array)
                   found << temp
                   k, v, q = val
-                  add_option(k, v, escape: escape, double: q == '"', merge: q == true, **kwargs)
+                  add_option(k, v, escape: escape, quote: quote, double: q == '"', merge: q == true, **kwargs)
                   next
                 end
               end
@@ -399,10 +390,10 @@ module Squared
 
               if exist?(val)
                 add_path(val, **kwargs)
-              elsif escape
-                add shell_escape(val, **kwargs)
               elsif quote
                 add_quote(val, **kwargs)
+              elsif escape
+                add shell_escape(val, **kwargs)
               else
                 add val
               end
@@ -421,7 +412,7 @@ module Squared
             g = ["\"((?:[^\"]|(?<=\\\\)\"(?!$#{'| ' if windows?}))*)\""]
             g << "'((?:[^']|'\\\\'')*)'" unless windows?
             g << "(#{s})"
-            args.map! do |opt|
+            list = args.map do |opt|
               if opt.size == 1
                 /(?:\A| )-#{opt} ?([^ ]+)/
               else
@@ -430,7 +421,7 @@ module Squared
             end
             ret = []
             target.each do |opt|
-              args.each do |pat|
+              list.each do |pat|
                 next unless opt =~ pat
 
                 ret << ($1 || $2 || $3)
@@ -516,10 +507,10 @@ module Squared
 
           def add_path(*args, option: nil, force: true, double: false, **kwargs)
             if args.empty?
-              args = grep(String)
-              found.concat(args)
-              args.map! { |val| path + val } if path
-              append(args, force: force, **kwargs)
+              list = select { |val| val.is_a?(String) }
+              found.concat(list)
+              list.map! { |val| path + val } if path
+              append(list, force: force, **kwargs)
             else
               val = path ? path.join(*args) : File.join(*args)
               if option
@@ -532,9 +523,7 @@ module Squared
           end
 
           def add_quote(*args, **kwargs)
-            kwargs.delete(:quote)
-            merge(args.compact
-                      .map! { |val| val == '--' || OptionPartition.opt?(val) ? val : shell_quote(val, **kwargs) })
+            merge(args.compact.map { |s| s == '--' || OptionPartition.opt?(s) ? s : shell_quote(s, **kwargs) })
             self
           end
 
@@ -543,8 +532,8 @@ module Squared
             self
           end
 
-          def add_first(fallback = nil, prefix: nil, path: false, escape: false, reverse: false, expect: false,
-                        **kwargs)
+          def add_first(fallback = nil, prefix: nil, path: false, escape: false, quote: false, reverse: false,
+                        expect: false, **kwargs)
             val = (reverse ? pop : shift) || fallback
             if val
               temp = val
@@ -552,10 +541,10 @@ module Squared
               unless block_given? && !(val = yield val).is_a?(String)
                 if path
                   add_path(val, **kwargs)
+                elsif quote
+                  add_quote(val, **kwargs)
                 elsif escape
                   add shell_escape(val, **kwargs)
-                elsif kwargs[:quote]
-                  add_quote(val, **kwargs)
                 else
                   add val
                 end
@@ -567,6 +556,12 @@ module Squared
             self
           end
 
+          def detach
+            ret = extras
+            @extras = []
+            ret
+          end
+
           def delim
             add '--'
             self
@@ -575,7 +570,7 @@ module Squared
           def last(val = nil, &blk)
             unless block_given?
               case val
-              when NilClass
+              when nil
                 return extras.last
               when Numeric
                 return extras.last(val)
@@ -589,7 +584,7 @@ module Squared
             ret = find_all(&blk)
             unless ret.empty?
               ret = case val
-                    when NilClass
+                    when nil
                       ret.first(1)
                     when Numeric
                       ret.first(val)
@@ -607,8 +602,6 @@ module Squared
           def splice(*exclude, quote: true, delim: true, path: false, pattern: false, &blk)
             temp, other = if block_given?
                             partition(&blk)
-                          elsif exclude.first.is_a?(Symbol)
-                            partition(&exclude.first)
                           else
                             exclude.map! { |pat| Regexp.new(pat) }
                             partition do |val|
@@ -687,10 +680,11 @@ module Squared
           end
 
           def uniq!(list)
-            unless (list = uniq(list)).empty?
-              concat list
-              self
-            end
+            list = uniq list
+            return if list.empty?
+
+            concat list
+            self
           end
 
           private

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Squared
+  module Workspace
+    module Project
+      module Support
+        module Utils
+          private
+
+          def rand_s(size)
+            if RUBY_VERSION >= '3.1'
+              require 'random/formatter'
+              Random.new.alphanumeric(size)
+            else
+              (0...size).map { rand(97..122).chr }.join
+            end
+          end
+
+          def merge_list(target, list)
+            list = Array(list)
+            case target
+            when Array
+              target.concat(list)
+            when Set
+              target.merge(list)
+            else
+              Array(target).concat(list)
+            end
+          end
+
+          def matchmap(list, prefix = nil)
+            list.map do |val|
+              next val if val.is_a?(Regexp)
+
+              val = ".*#{val}" if prefix && !val.sub!(/\A(\^|\\A)/, '')
+              Regexp.new("#{prefix}#{val == '*' ? '.+' : val}")
+            end
+          end
+
+          def matchany?(list, *args, empty: true)
+            return empty if list.empty?
+
+            list.any? { |pat| args.any?(pat) }
+          end
+
+          def has_value?(target, *args)
+            args.any? { |obj,| target.include?(obj) }
+          end
+
+          def has_value!(target, *args, first: false)
+            ret = nil
+            args.each do |val|
+              if target.respond_to?(:delete?)
+                ret = target if target.delete?(val)
+              elsif target.respond_to?(:delete)
+                ret = target if target.delete(val)
+              elsif target.include?(val)
+                ret = target
+              end
+              break if ret && first
+            end
+            ret
+          end
+        end
+      end
+    end
+  end
+end

data/lib/squared/workspace/project.rb

@@ -1,11 +1,4 @@
 # frozen_string_literal: true
 
-module Squared
-  module Workspace
-    module Project
-    end
-  end
-end
-
 require_relative 'project/base'
 require_relative 'project/git'