squared 0.5.12 → 0.6.0

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

@@ -21,7 +21,7 @@ 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?('--')
@@ -29,6 +29,22 @@ module Squared
                 pat, s = Array(strip)
                 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 escape
@@ -43,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)
@@ -84,6 +100,20 @@ module Squared
               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?
@@ -120,13 +150,12 @@ module Squared
             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, :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
+          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
@@ -134,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)
@@ -171,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'
@@ -196,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
@@ -205,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))
@@ -225,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 == '--'
@@ -243,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
@@ -269,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
@@ -308,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})"
@@ -347,22 +382,18 @@ 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
+            index = -1
             temp = to_a
             if with
               pat = case with
@@ -373,44 +404,50 @@ 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
+              temp.each_with_index do |val, i|
+                if index == 0
                   next unless val.start_with?('-')
 
-                  i = index
+                  index = i
                   break
-                elsif index > 0 && !val.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
 
@@ -419,6 +456,62 @@ module Squared
             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)
@@ -452,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?
@@ -461,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
@@ -474,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
@@ -513,6 +605,12 @@ 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?
             Rake::Win32.windows?
           end
@@ -531,31 +629,31 @@ module Squared
           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 = 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
             return ret unless block_given?
 

data/lib/squared/workspace/repo.rb

@@ -3,16 +3,6 @@
 module Squared
   module Workspace
     module Repo
-      class << self
-        def read_manifest(path)
-          require 'rexml/document'
-          return unless (file = path + '.repo/manifest.xml').exist?
-
-          doc = REXML::Document.new(file.read)
-          doc.elements['manifest/include'].attributes['name']&.sub('.xml', '')
-        end
-      end
-
       attr_reader :manifest_url, :manifest
 
       def repo(url, manifest = 'latest', run: nil, script: nil, args: nil, dev: nil, prod: nil,
@@ -25,18 +15,18 @@ module Squared
                       @root = nil unless path.directory?
                     elsif !@root.exist?
                       @root.mkpath
-                    elsif !repo_install?
-                      @root = nil unless repo_confirm
+                    elsif !repo_install? && !repo_confirm
+                      @root = nil
                     end
+                    raise_error Errno::EEXIST, path.cleanpath, hint: 'REPO_HOME' unless @root
                   end
-                  raise_error("path invalid: #{val}", hint: 'REPO_HOME') unless @root
                   path.realdirpath
                 elsif (val = env('REPO_ROOT'))
                   @root = Pathname.new(val).realdirpath
                   if !@root.exist?
                     @root.mkpath
-                  elsif !repo_install?(parent: true)
-                    raise_error("path does not exist: #{val}", hint: 'REPO_ROOT') unless repo_confirm
+                  elsif !repo_install?(parent: true) && !repo_confirm
+                    raise_error Errno::EEXIST, @root, hint: 'REPO_ROOT'
                   end
                   @root.join(main).realdirpath
                 elsif repo_install?(parent: true) && (!@home.exist? || @root + main == @home)
@@ -51,9 +41,13 @@ module Squared
         @manifest = manifest
         data = scriptobj
         if repo?
+          sc, ru = env('REPO_BUILD', '').split(',', 2).map!(&:strip)
           if script
-            if (val = env('REPO_BUILD'))
-              data[:script] = case val
+            data[:script] = if sc.to_s.empty?
+                              script
+                            else
+                              data[:env][:script] = true
+                              case sc
                               when 'verbose'
                                 @verbose = 1
                                 if script.is_a?(Array)
@@ -67,20 +61,23 @@ module Squared
                                 @warning = false
                                 script
                               else
-                                val
+                                sc
                               end
-              data[:env] = true
-            else
-              data[:script] = script
-            end
+                            end
             data[:args] = (val = env('REPO_SCRIPT')) ? shell_split(val, join: true) : args
-          elsif (val = env('REPO_BUILD'))
-            data[:run] = val
-            data[:env] = true
+            data[:global][:script] = true
           else
-            data[:run] = run
+            ru ||= sc
+          end
+          if run
+            data[:run] = if ru.to_s.empty?
+                           run
+                         else
+                           data[:env][:run] = true
+                           ru
+                         end
+            data[:global][:run] = true
           end
-          data[:global] = true
           data[:dev] = env_match 'REPO_DEV', dev
           data[:prod] = env_match 'REPO_PROD', prod
           if (val = env('REPO_GROUP'))
@@ -98,9 +95,8 @@ module Squared
           if script
             data[:script] = script
             data[:args] = args
-          else
-            data[:run] = run
           end
+          data[:run] = run if run
           data[:dev] = dev
           data[:prod] = prod
           script_set(data, group: group, ref: ref)
@@ -115,7 +111,7 @@ module Squared
 
         namespace task_name('repo') do |ns|
           path = ns.scope.path
-          branch = env('REPO_MANIFEST') || Repo.read_manifest(root)
+          branch = env('REPO_MANIFEST') || repo_manifest
           target = branch || manifest
           stage = nil
           opts = %w[force rebase detach submodules fail no-update gc]
@@ -160,7 +156,7 @@ module Squared
             args = args.to_a
             u = env('REPO_URL') || manifest_url
             m = args.first && !opts.include?(args.first) ? args.shift : target
-            g = args.first && !opts.include?(args.first) ? args.shift : nil
+            g = (args.shift if args.first && !opts.include?(args.first))
             g = case (val = env('REPO_GROUPS'))
                 when '', NilClass
                   g
@@ -216,7 +212,7 @@ module Squared
             end
           end
 
-          series.sync.append(
+          series.sync.push(
             task_join(path, 'all'),
             task_join(path, 'init'),
             task_join(path, 'sync')
@@ -224,11 +220,19 @@ module Squared
         end
       end
 
+      def repo_manifest(path = root)
+        return unless (file = path + '.repo/manifest.xml').exist?
+
+        require 'rexml/document'
+        doc = REXML::Document.new(file.read)
+        doc.elements['manifest/include'].attributes['name']&.sub('.xml', '')
+      end
+
       def repo_confirm
         return false unless root.directory?
 
         path = sub_style(root, styles: theme[:inline])
-        @repo_override = Common::Prompt.confirm(
+        @repo_override = env('REPO_Y', equals: '1') || Common::Prompt.confirm(
           "#{log_title(:warn)} \"#{path}\" is not empty. Continue with installation?",
           'N',
           timeout: env('REPO_TIMEOUT', 15, ignore: '0')
@@ -247,7 +251,7 @@ module Squared
       def repo_opts(*args)
         return args unless (n = ARGV.index('--'))
 
-        ARGV[(n + 1)..-1].concat(args)
+        ARGV[n.succ..-1].concat(args)
       end
 
       def repo?

data/lib/squared/workspace/series.rb

@@ -199,9 +199,7 @@ module Squared
       end
 
       def batch?(obj, key)
-        return false unless (data = batch_get(key))
-
-        data.keys.any? { |ref| obj.ref?(ref) }
+        (data = batch_get(key)) ? data.keys.any? { |ref| obj.ref?(ref) } : false
       end
 
       def chain?(val)
@@ -240,9 +238,11 @@ module Squared
       end
 
       def already_invoked?(list, val)
-        return Rake::Task.tasks.any? { |obj| obj.already_invoked && list.include?(obj.name) } unless val
-
-        list.include?(val) && !invoked_get(val).nil?
+        if val
+          list.include?(val) && !invoked_get(val).nil?
+        else
+          Rake::Task.tasks.any? { |obj| obj.already_invoked && list.include?(obj.name) }
+        end
       end
     end
 

data/lib/squared/workspace/support/base.rb

@@ -3,30 +3,9 @@
 module Squared
   module Workspace
     module Support
-      class << self
-        def hashobj
-          Hash.new { |data, key| data[key] = {} }
-        end
-
-        def hashlist
-          Hash.new { |data, key| data[key] = [] }
-        end
-
-        def hashdup(data, pass: {})
-          ret = {}
-          data.each do |key, val|
-            ret[key] = case val
-                       when Hash
-                         pass[val] ||= hashdup(val, pass: pass)
-                       when Proc, Method
-                         val
-                       else
-                         val.dup
-                       end
-          end
-          ret
-        end
-      end
+      RunData = Struct.new('RunData', :run, :block)
+      ChainData = Struct.new('ChainData', :action, :step, :with, :before, :after, :sync)
+      BannerData = Struct.new('BannerData', :command, :order, :styles, :border)
     end
   end
 end