squared 0.6.9 → 0.7.1

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

@@ -32,7 +32,7 @@ module Squared
               @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,29 +21,30 @@ 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?
+                       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)
@@ -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,15 +76,13 @@ 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)
@@ -93,7 +92,7 @@ module Squared
             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
@@ -115,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)
 
@@ -141,7 +152,8 @@ module Squared
             end
 
             def pattern?(val)
-              val.match?(/\A\^|\$\z/) || val.match?(/[.)][*+?]|\(\?:|\\[dsw\d]|\[.+\]|\{\d+,?\d*\}/i)
+              val.start_with?('\A', '^') || val.end_with?('\z', '$') ||
+              val.match?(/[.)][*+?]|\(\?:|\\[dsw\d]|\[.+\]|\{\d+,?\d*\}/i)
             end
 
             private
@@ -159,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
 
@@ -356,13 +368,14 @@ module Squared
 
           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])
+            pass = kwargs[:pass] ||= []
+            OptionPartition.append(target, *args, **kwargs, &blk)
+            errors.concat(pass)
             self
           end
 
           def append_any(*args, escape: false, quote: true, **kwargs)
-            (args.empty? ? extras : args.flatten).each do |val|
+            (args.empty? ? extras : args.flatten(1)).each do |val|
               if block_given?
                 temp = val
                 val = yield val
@@ -399,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
@@ -408,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)
@@ -494,10 +507,10 @@ module Squared
 
           def add_path(*args, option: nil, force: true, double: false, **kwargs)
             if args.empty?
-              args = select { |val| val.is_a?(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
@@ -510,8 +523,7 @@ module Squared
           end
 
           def add_quote(*args, **kwargs)
-            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
 
@@ -544,6 +556,12 @@ module Squared
             self
           end
 
+          def detach
+            ret = extras
+            @extras = []
+            ret
+          end
+
           def delim
             add '--'
             self
@@ -552,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)
@@ -566,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)
@@ -584,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|
@@ -664,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'