squared 0.4.6 → 0.4.8

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Squared
+  module Workspace
+    module Project
+      module Support
+        class OptionPartition
+          include Common::Shell
+          extend Forwardable
+
+          class << self
+            include Common::Format
+            include Shell
+            include Prompt
+
+            def append(target, *args, delim: false, escape: false, quote: true)
+              return if (ret = args.flatten).empty?
+
+              target << '--' if delim && !target.include?('--')
+              ret.map! { |val| escape ? shell_escape(val, quote: quote) : shell_quote(val) } if escape || quote
+              if target.is_a?(Set)
+                target.merge(ret)
+              else
+                target.concat(ret)
+              end
+              ret
+            end
+
+            def clear(target, opts, pass: true, styles: nil, **kwargs)
+              return if opts.empty?
+
+              kwargs[:subject] ||= stripext(target.first)
+              kwargs[:hint] ||= 'unrecognized'
+              append(target, opts, delim: true) if kwargs.delete(:append)
+              warn log_message(Logger::WARN, opts.join(', '), pass: true, **kwargs)
+              return if pass || confirm("Run? [#{sub_style(target, styles: styles)}] [y/N] ", 'N', timeout: 30)
+
+              raise_error 'user cancelled'
+            end
+
+            def arg?(target, *args, value: false)
+              r, s = args.partition { |val| val.is_a?(Regexp) }
+              unless s.empty?
+                s.map! { |val| Regexp.escape(shell_option(val)) }
+                r << /\A(?:#{s.join('|')})#{value ? '[ =].' : '(?: |=|\z)'}/
+              end
+              target.any? { |opt| r.any? { |val| opt.match?(val) } }
+            end
+          end
+
+          attr_reader :target, :extras, :found, :errors, :values, :project, :path
+
+          def_delegators :@target, :+, :-, :<<, :any?, :none?, :include?, :add, :add?, :find, :find_all, :find_index,
+                         :merge, :delete, :delete?, :grep, :inspect, :to_a, :to_s
+          def_delegators :@extras, :empty?, :each, :each_with_index, :partition, :first, :last, :shift, :pop, :push,
+                         :join, :map, :map!, :dup, :size
+
+          def initialize(opts, list, target = Set.new, project: nil, path: nil, **kwargs, &blk)
+            @target = target.is_a?(Set) ? target : Set.new(target)
+            @project = project
+            @path = path || project&.path
+            @errors = []
+            @found = []
+            parse(list, opts, **kwargs, &blk)
+          end
+
+          def parse(list, opts = extras, no: nil, single: nil, args: false, first: false, pass: ['='], &blk)
+            @extras = []
+            @values = []
+            bare = []
+            e = []
+            b = []
+            m = []
+            p = []
+            q = []
+            qq = []
+            i = []
+            f = []
+            si = []
+            list.map do |val|
+              x, y = val.split('|')
+              if y
+                if (n = val.index('='))
+                  x += val[n..-1]
+                end
+                [x, y]
+              else
+                x
+              end
+            end
+            .flatten
+            .each do |val|
+              if (n = val.index('='))
+                flag = val[0, n]
+                case val[n + 1]
+                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)
+                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)
+            skip = false
+            opts.each do |opt|
+              next @extras << opt if skip
+
+              if single&.match?(opt)
+                target << "-#{opt}"
+              elsif bare.include?(opt)
+                target << (opt.size == 1 ? "-#{opt}" : "--#{opt}")
+              elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
+                target << "--no-#{name}"
+              else
+                if opt =~ /\A([^=]+)=(.+)\z/
+                  key = $1
+                  val = $2
+                  merge = m.include?(key)
+                  r = ->(flag, pat) { flag.include?(key) && pat.match?(val) }
+                  if e.include?(key)
+                    target << shell_option(key, val, merge: merge)
+                  elsif q.include?(key)
+                    target << quote_option(key, val, double: qq.include?(key), merge: merge)
+                  elsif p.include?(key) && path
+                    target << quote_option(key, path.join(val), merge: merge)
+                  elsif b.include?(key) || r.call(i, /^\d+$/) || r.call(f, /^\d*(?:\.\d+)?$/) || r.call(si, /^-?\d+$/)
+                    target << basic_option(key, val, merge: merge)
+                  elsif merge
+                    target << basic_option(key, val, merge: true)
+                  else
+                    @extras << opt
+                  end
+                  opt = key
+                else
+                  @extras << opt
+                  skip = true if args
+                end
+                skip = true if first && pass.none? { |s| opt.include?(s) }
+              end
+            end
+            @values = @values.empty? ? /\A\s+\z/ : /\A(#{@values.join('|')})=(.+)\z/
+            @extras.each_with_index(&blk) if block_given?
+            self
+          end
+
+          def swap(opts = nil)
+            unless opts
+              opts = found
+              @found = []
+            end
+            @extras = opts
+            self
+          end
+
+          def append(*args, **kwargs)
+            OptionPartition.append(target, *(args.empty? ? extras : args), **kwargs)
+            self
+          end
+
+          def clear(opts = nil, **kwargs)
+            opts ||= (kwargs[:errors] ? errors : extras)
+            styles = project.theme[:inline] if project
+            OptionPartition.clear(target, opts.reject { |val| found.include?(val) }, styles: styles, **kwargs)
+            opts.clear
+            self
+          end
+
+          def arg?(*args, **kwargs)
+            OptionPartition.arg?(target, *args, **kwargs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'support/class'

data/lib/squared/workspace/project.rb

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

data/lib/squared/workspace/repo.rb

@@ -3,8 +3,6 @@
 module Squared
   module Workspace
     module Repo
-      include Common::Format
-
       class << self
         def read_manifest(path)
           require 'rexml/document'
@@ -149,9 +147,9 @@ module Squared
             end
           end
 
-          desc.('all[{0}]')
+          desc.call('all[{0}]')
           task 'all', [:opts] do |_, args|
-            parse_opts.(args)
+            parse_opts.call(args)
             stage ||= 'all'
             repo['sync'].invoke
             next if env('REPO_DRYRUN', equals: '2')
@@ -174,21 +172,21 @@ module Squared
             end
           end
 
-          desc.("init[manifest?=#{target},{0}]", target)
+          desc.call("init[manifest?=#{target},{0}]", target)
           task 'init', [:manifest, :opts] do |_, args|
-            parse_opts.(args)
+            parse_opts.call(args)
             stage = 'init'
             puts if newline
             system("repo init -u #{env('REPO_URL') || manifest_url} -m #{args.manifest || target}.xml", chdir: root)
             repo['all'].invoke
           end
 
-          desc.('sync[{0}]')
+          desc.call('sync[{0}]')
           task 'sync', [:opts] do |_, args|
             unless branch || stage == 'init'
               raise_error('repo not initialized', hint: task_name('repo:init'), kind: LoadError)
             end
-            parse_opts.(args)
+            parse_opts.call(args)
             cmd << "-j#{ENV.fetch('REPO_JOBS', Rake::CpuCounter.count)}"
             cmd << '--fail-fast' if failfast
             puts if newline && stage != 'init'

data/lib/squared/workspace/series.rb

@@ -66,16 +66,17 @@ module Squared
         end
       end
 
-      attr_reader :sync, :multiple, :parallel
+      attr_reader :exclude, :sync, :multiple, :parallel
 
       def_delegators :@data, :[], :each, :each_key, :keys, :fetch, :to_a, :to_s, :inspect, :merge!, :key?
       def_delegators :@workspace, :task_desc, :task_name, :task_namespace, :task_join, :format_desc
 
-      def initialize(workspace)
+      def initialize(workspace, exclude: [])
         @workspace = workspace
         @sync = []
         @multiple = []
         @parallel = []
+        @exclude = exclude.freeze
         @session = {
           group: {},
           parent: {},
@@ -89,7 +90,7 @@ module Squared
         group, parent, id = @session.values
         ws = proj.workspace
         @data.each do |key, items|
-          next if (tasks = ws.task_resolve(proj, key)).empty?
+          next if exclude.include?(key) || (tasks = ws.task_resolve(proj, key)).empty?
 
           if (g = proj.group)
             id << g
@@ -113,13 +114,13 @@ module Squared
         @data.merge!(@session[:parent]) if @session[:id].uniq.size > 1
         @data.merge!(@session[:group])
         @data.each do |key, items|
-          next if items.empty? || @workspace.task_exclude?(t = name_get(key))
+          next if items.empty? || exclude.include?(key) || @workspace.task_exclude?(t = name_get(key))
 
           key = task_name(t)
           val = format_desc(key, out: true)
           if items.size > 1
             @multiple << key
-            if parallel.include?(t) || pattern.any? { |pat| t.match?(pat) } || subcheck.(t)
+            if parallel.include?(t) || pattern.any? { |pat| t.match?(pat) } || subcheck.call(t)
               task_desc("#{val} (thread)", name: key)
               multitask key => items
               @parallel << key
@@ -135,7 +136,7 @@ module Squared
           task_desc(val, name: key)
           task key => items
         end
-        @multiple += sync
+        @multiple.concat(sync)
       end
 
       def name_get(key)

data/lib/squared/workspace.rb

@@ -10,8 +10,7 @@ module Squared
           if id.is_a?(Symbol)
             project id
           else
-            id = dirpath(id) if id.is_a?(String)
-            __get__(:project).find { |_, val| val.path.to_s == id.to_s }
+            __get__(:project).find { |_, val| File.expand_path(val.path) == File.expand_path(id) }
           end
         end
         ret.size == 1 ? ret.first : ret
@@ -33,12 +32,6 @@ module Squared
       def project(name)
         __get__(:project)[name.to_s]
       end
-
-      def dirpath(val, absolute: true)
-        Pathname.new(val).realdirpath
-      rescue StandardError
-        absolute ? Pathname.pwd.join(val) : Pathname.new(val)
-      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.8
 platform: ruby
 authors:
 - An Pham
@@ -97,6 +97,8 @@ files:
 - lib/squared/workspace/project/node.rb
 - lib/squared/workspace/project/python.rb
 - lib/squared/workspace/project/ruby.rb
+- lib/squared/workspace/project/support.rb
+- lib/squared/workspace/project/support/class.rb
 - lib/squared/workspace/repo.rb
 - lib/squared/workspace/series.rb
 - squared.gemspec