squared 0.8.2 → 0.8.4

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

@@ -10,10 +10,11 @@ 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/
-          private_constant :OPT_NAME, :OPT_VALUE, :OPT_SINGLE
+          OPT_NAME = /\A(?:(--)|-)((?(1)[^=\s-][^=\s]*|[^=\s-]))\z/.freeze
+          OPT_VALUE = /\A-{0,2}([^=\s-][^=\s]*)(?:=|\s+)(\S.*)\z/.freeze
+          OPT_SINGLE = /\A-([^=\s-])(.+)\z/.freeze
+          QUOTE_VALUE = /\A(["'])(.+)\1\z/m.freeze
+          private_constant :OPT_NAME, :OPT_VALUE, :OPT_SINGLE, :QUOTE_VALUE
 
           class << self
             include Common::Format
@@ -22,12 +23,21 @@ module Squared
 
             def append(target, *args, delim: false, escape: false, quote: true, strip: nil, double: false, filter: nil,
                        pass: nil, **kwargs)
-              return if (ret = args.flatten(1)).empty?
+              ret = args.flatten(1)
+              return if ret.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! do |val|
+                  next val unless val.is_a?(String)
+
+                  if pat.is_a?(String) && pat.size == 1 && s.nil?
+                    val.delete_prefix(pat)
+                  else
+                    val.gsub(pat, s || '')
+                  end
+                end
               end
               if filter
                 ret, err = ret.partition { |val| filter.match?(val.to_s) }
@@ -87,8 +97,26 @@ module Squared
 
             def strip(val)
               val = shell_split val if val.is_a?(String)
-              Array(val).map { |s| s.sub(OPT_SINGLE, '\1=\2').sub(OPT_VALUE, '\1=\2').sub(OPT_NAME, '\2') }
-                        .reject(&:empty?)
+              ret = []
+              pass = -1
+              args = Array(val)
+              args.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
             end
 
             def select(list, bare: true, no: true, single: false, double: false)
@@ -102,21 +130,17 @@ module Squared
 
             def union(list, other)
               base = list.map { |val| parse_option(val).first }
-              other.each do |val|
-                next if base.include?(parse_option(val).first)
-
-                list << val
-              end
-              list
+              list + other.each_with_object([]) { |val, out| out << val unless base.include?(parse_option(val).first) }
             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?)
+              data = list.each_with_object({})
+                         .with_index do |(val, out), i|
+                           j = val =~ OPT_VALUE ? $1 : val
+                           (out[j] ||= []) << i unless pass.include?(j)
+                         end
+                         .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 } }
@@ -162,8 +186,11 @@ 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
             end
 
             private
@@ -218,7 +245,7 @@ module Squared
           end
 
           def parse(list, opts = extras, no: nil, single: nil, args: false, multiple: nil, first: nil, underscore: nil,
-                    stdin: false, &blk)
+                    explicit: false, bool: %w[true false], stdin: false, &blk)
             @extras = []
             @values = []
             bare = []
@@ -232,7 +259,10 @@ module Squared
             f = []
             si = []
             bl = []
+            ex = []
             ml = []
+            re = {}
+            ar = {}
             sw = {}
             se = {}
             list.flat_map do |val|
@@ -261,13 +291,13 @@ module Squared
                       else
                         [flag]
                       end
+                bare.concat(mod) if val.chomp!('?')
+                m.concat(mod) if val.chomp!('m')
                 case val[n.succ]
                 when 'e'
                   e.concat(mod)
                 when 'b'
                   b.concat(mod)
-                when 'm'
-                  m.concat(mod)
                 when 'q'
                   qq.concat(mod) if val[n + 2] == 'q'
                   q.concat(mod)
@@ -286,13 +316,27 @@ module Squared
                 when '+'
                   ml.concat(mod)
                   bare.concat(mod)
-                else
-                  next
+                when '/'
+                  begin
+                    val = val[n.succ..-1]
+                    pat = eval(val)
+                    raise SyntaxError unless pat.is_a?(Regexp)
+
+                    mod.each { |key| re[key] = pat }
+                  rescue SyntaxError
+                    warn "#{self.class}: invalid pattern (#{val})"
+                  end
+                when '{'
+                  group = val[(n + 2)..-1].chomp!('}')&.split(',')
+                  if group
+                    mod.each { |key| ar[key] = group }
+                  else
+                    warn "#{self.class}: invalid group (#{val})"
+                  end
                 end
-                m.concat(mod) if val[n + 2] == 'm'
-                bare.concat(mod) if val.end_with?('?')
               else
                 bare << val
+                ex << val if explicit
                 mod = [val]
               end
               mod.each do |key|
@@ -325,7 +369,7 @@ module Squared
             end
             numtype = [
               [i, /\A\d+\z/],
-              [f, /\A\d*(\.\d+)?\z/],
+              [f, /\A(\d+(\.\d*)?|\d*\.\d+)\z/],
               [si, /\A-?\d+\z/]
             ].freeze
             numcheck = ->(k, v) { numtype.any? { |flag, pat| flag.include?(k) && v.match?(pat) } }
@@ -355,33 +399,57 @@ module Squared
               elsif opt.start_with?(/no[-_]/) && no.include?(s = opt[3..-1])
                 add "--no-#{s}"
               else
+                has = lambda do |list, key|
+                  return true if list.include?(key)
+                  return false unless (pre = list.find { |s| s.end_with?(':*') })
+
+                  key.start_with?(pre.chomp('*')) && !key.end_with?(':')
+                end
                 if opt =~ OPT_VALUE
                   key = $1
                   val = $2
-                  has = lambda do |a|
-                    return true if a.include?(key)
-                    return false unless (k = a.find { |s| s.end_with?(':*') })
-
-                    key.start_with?(k.chomp('*')) && !key.end_with?(':')
-                  end
-                  kwargs = { sep: se[key] || sep, merge: has.call(m), switch: sw[key] }
-                  if has.call(e) || (has.call(bl) && %w[true false].include?(val))
+                  get = ->(h) { h[key] || h.find { |k,| k.end_with?(':*') }.last }
+                  kwargs = { sep: se[key] || sep, merge: has.call(m, key), switch: sw[key] }
+                  if has.call(e, key) || (has.call(bl, key) && bool.include?(val))
                     add shell_option(key, val, **kwargs)
-                  elsif has.call(q)
-                    add quote_option(key, val, double: has.call(qq), **kwargs)
-                  elsif has.call(p)
-                    if val.match?(/\A(["']).+\1\z/)
-                      add shell_option(key, val, escape: false, **kwargs)
+                  elsif has.call(ex, key) && bool.include?(val)
+                    add shell_option(key, val, explicit: explicit, **kwargs)
+                  elsif has.call(q, key)
+                    add quote_option(key, val, double: has.call(qq, key), **kwargs)
+                  elsif has.call(p, key)
+                    if val =~ QUOTE_VALUE
+                      add shell_option(key, val, double: $1 == '"', escape: false, **kwargs)
                     elsif path
                       add quote_option(key, path + val, **kwargs)
                     else
                       push opt
                     end
-                  elsif kwargs[:merge] || has.call(b) || numcheck.call(key, val) || se[key] || sw[key]
+                  elsif !ar.empty? && has.call(ar.keys, key)
+                    group = get.call(ar)
+                    if group.include?(val)
+                      add shell_option(key, val, force: false, **kwargs)
+                    elsif @strict
+                      clear([opt], hint: "include != {#{group.join(',')}}")
+                    else
+                      push opt
+                    end
+                  elsif !re.empty? && has.call(re.keys, key)
+                    pat = get.call(re)
+                    if val.match?(pat)
+                      add quote_option(key, val, **kwargs)
+                    elsif @strict
+                      clear([opt], hint: "match != /#{pat.source}/")
+                    else
+                      push opt
+                    end
+                  elsif kwargs[:merge] || has.call(b, key) || numcheck.call(key, val) || se[key] || sw[key]
                     add basic_option(key, val, **kwargs)
                   else
                     push opt
                   end
+                  opt = key unless opt == last
+                elsif has.call(m, key = opt[0]) && opt[1..-1] =~ QUOTE_VALUE
+                  add basic_option(key, $2, double: $1 == '"', **kwargs, merge: true)
                   opt = key
                 else
                   push opt
@@ -449,8 +517,8 @@ module Squared
 
           def values_of(*args, strict: true, first: false, last: false)
             eq, s = strict ? [sep, '[^ ]+'] : ['(?:=| +)', '[^-][^ ]*']
-            g = ["\"((?:[^\"]|(?<=\\\\)\"(?!$#{'| ' if windows?}))*)\""]
-            g << "'((?:[^']|'\\\\'')*)'" unless windows?
+            g = ["\"((?:[^\"]|(?<=\\\\)\"(?!$#{'| ' if Common::Host.windows?}))*)\""]
+            g << "'((?:[^']|'\\\\'')*)'" unless Common::Host.windows?
             g << "(#{s})"
             list = args.map do |opt|
               if opt.size == 1
@@ -582,7 +650,11 @@ module Squared
                 val = val.delete_prefix(prefix) if prefix
                 if strip
                   pat, s = Array(strip)
-                  val = val.gsub(pat, s || '')
+                  val = if pat.is_a?(String) && pat.size == 1 && s.nil?
+                          val.delete_prefix(pat)
+                        else
+                          val.gsub(pat, s || '')
+                        end
                 end
               end
               unless block_given? && !(val = yield val).is_a?(String)
@@ -722,16 +794,13 @@ module Squared
           end
 
           def exist?(*args, add: false, first: false, last: false, glob: false)
-            return !args.first.nil? && with_glob?(File.join(*args), glob) unless args.empty?
+            return !args.include?(nil) && with_glob?(File.join(*args), glob) unless args.empty?
 
             if first || last
-              return false unless (val = first ? self.first : self.last)
+              val = first ? self.first : self.last
+              return false unless val
 
-              with_glob?(val, glob).tap do |ret|
-                next unless add && ret
-
-                add_first(path: true, reverse: !first)
-              end
+              with_glob?(val, glob).tap { |ret| add_first(path: true, reverse: !first) if add && ret }
             else
               each_with_index do |val, i|
                 next unless with_glob?(val, glob)
@@ -766,11 +835,6 @@ module Squared
 
             path.join(val).exist? || (glob && !path.glob(val).empty?)
           end
-
-          def windows?
-            require 'rake'
-            Rake::Win32.windows?
-          end
         end
       end
     end

data/lib/squared/workspace/repo.rb

@@ -126,7 +126,8 @@ module Squared
             stage = nil
             opts = %w[force rebase detach submodules fail no-update gc]
             desc = lambda do |val, alt = nil|
-              if (ver = branch || alt)
+              ver = branch || alt
+              if ver
                 val = val.sub('{0}', "opts*=#{opts.join(',')}")
                 task_desc(path, val, ver)
               else
@@ -184,8 +185,7 @@ module Squared
               end
               env('REPO_GROUPS', **envargs) do |val|
                 g = case val
-                    when '0', 'false'
-                      nil
+                    when '0', 'false' then nil
                     else
                       val
                     end
@@ -314,9 +314,7 @@ module Squared
           i = -1
           n = repo_scriptdata(proj, name).reduce(0) do |a, b|
             i += 1
-            next a unless b
-
-            a + (1 << i)
+            b ? a + (1 << i) : a
           end
           proj.global(n) && (pass || g.include?(proj.group) || r.any? { |val| proj.ref?(val) })
         end
@@ -362,7 +360,7 @@ module Squared
       def repo_install?(dir = root, parent: false)
         return true if root?(dir, pass: ['.repo']) || dir.join('.repo').directory?
 
-        parent && root.children.none? { |ent| ent.directory? && ent.basename.to_s[0] != '.' && ent != home }
+        parent && root.children.none? { |ent| ent.directory? && ent != home }
       end
     end
 

data/lib/squared/workspace/series.rb

@@ -23,8 +23,8 @@ module Squared
         @exclude = exclude.freeze
         @task = Struct::SeriesData.new(workspace.config_get(:rename))
         @data = {}
-        project.each_with_index do |obj, index|
-          if index == 0
+        project.each_with_index do |obj, i|
+          if i == 0
             target = @task.base
             obj.tasks.each do |key|
               target << key

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.8.4
 platform: ruby
 authors:
 - An Pham
@@ -80,6 +80,7 @@ files:
 - lib/squared/common.rb
 - lib/squared/common/base.rb
 - lib/squared/common/format.rb
+- lib/squared/common/host.rb
 - lib/squared/common/prompt.rb
 - lib/squared/common/shell.rb
 - lib/squared/common/system.rb
@@ -125,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.15
+rubygems_version: 4.0.19
 specification_version: 4
 summary: Rake task generator for managing multi-language workspaces.
 test_files: []