squared 0.4.6 → 0.4.7

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

@@ -0,0 +1,197 @@
+# 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 args.empty?
+
+              target << '--' if delim && !target.include?('--')
+              ret = args.flatten.map { |val| escape ? shell_escape(val, quote: quote) : shell_quote(val) }
+              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
+                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
+                  match = ->(flag, pat) { flag.include?(key) && pat.match?(val) }
+                  if e.include?(key)
+                    target << shell_option(key, val)
+                  elsif q.include?(key)
+                    target << quote_option(key, val, double: qq.include?(key))
+                  elsif p.include?(key) && path
+                    target << quote_option(key, path.join(val))
+                  elsif m.include?(key)
+                    target << basic_option(key, val, merge: true)
+                  elsif b.include?(key) || match.(i, /^\d+$/) || match.(f, /^\d*(?:\.\d+)?$/) || match.(si, /^-?\d+$/)
+                    target << basic_option(key, val)
+                  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/series.rb

@@ -135,7 +135,7 @@ module Squared
           task_desc(val, name: key)
           task key => items
         end
-        @multiple += sync
+        @multiple.concat(sync)
       end
 
       def name_get(key)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.7
 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
@@ -121,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Rake task generator for managing multi-language workspaces.
 test_files: []