squared 0.4.41 → 0.5.0

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

@@ -10,36 +10,16 @@ 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
-
           class << self
             include Common::Format
             include Shell
             include Prompt
 
-            def append(target, *args, delim: false, escape: false, quote: true, strip: nil, force: true, double: false,
-                       preserve: true, **)
+            def append(target, *args, delim: false, escape: false, quote: true, **)
               return if (ret = args.flatten).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.map! do |val|
-                next val if opt?(val)
-
-                if !(pa = val.is_a?(Pathname)) && escape
-                  shell_escape(val, quote: quote, double: double)
-                elsif quote || pa
-                  shell_quote(val, force: force, double: double, preserve: preserve)
-                else
-                  val
-                end
-              end
+              ret.map! { |val| escape ? shell_escape(val, quote: quote) : shell_quote(val) } if escape || quote
               if target.is_a?(Set)
                 target.merge(ret)
               else
@@ -55,117 +35,35 @@ module Squared
               kwargs[:hint] ||= 'unrecognized'
               append(target, opts, delim: true) if kwargs.delete(:append)
               warn log_message(Logger::WARN, opts.join(', '), pass: true, **kwargs)
-              exit 1 unless pass || confirm("Run? [#{sub_style(target, styles: styles)}] [y/N] ", 'N')
-            end
-
-            def delete_key(target, *args, value: false, reverse: false, count: -1)
-              ret = []
-              args.each do |val|
-                next if (opts = target.grep(matchopt(val, value))).empty?
+              return if pass || confirm("Run? [#{sub_style(target, styles: styles)}] [y/N] ", 'N')
 
-                opts = opts.first(count) if count >= 0
-                opts.send(reverse ? :reverse_each : :each) { |key| target.delete(key) }
-                ret.concat(opts)
-              end
-              ret
+              raise_error 'user cancelled'
             end
 
             def strip(val)
               return [] unless val
 
-              val = shell_split val if val.is_a?(String)
-              ret = []
-              pass = -1
-              (args = Array(val)).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)
-              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
-
-              ret.select { |val| single ? val.size == 1 : val.size > 1 }
+              val = shell_split(val) if val.is_a?(String)
+              val.map { |s| s.sub(/\A-([a-z\d])(.+)\z/i, '\1=\2').sub(/\A--?/, '') }.reject(&:empty?)
             end
 
             def arg?(target, *args, value: false, **)
               r, s = args.partition { |val| val.is_a?(Regexp) }
-              r << matchopts(s, value) unless s.empty?
-              a = target.to_a.compact
-              if (n = a.index('--'))
-                a = a[0..n]
+              unless s.empty?
+                s.map! { |val| Regexp.escape(val.start_with?('-') ? val : shell_option(val)) }
+                r << /\A(?:#{s.join('|')})#{value ? '[ =].' : '(?: |=|\z)'}/
               end
-              a.any? { |val| r.any? { |pat| pat.match?(val.to_s) } }
-            end
-
-            def opt?(val)
-              return false unless val.is_a?(String)
-
-              val.start_with?('-') && (OPT_NAME.match?(val) || OPT_VALUE.match?(val) || OPT_SINGLE.match?(val))
-            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
-
-            def matchopt(val, value = false)
-              /\A#{val.size == 1 ? shortopt(val) : longopt(val, value)}/
-            end
-
-            def matchopts(list, value = false)
-              a, b = Array(list).partition { |val| val.size == 1 || val.match?(OPT_SINGLE) }
-              return /\A#{shortopt(*a)}/ if b.empty?
-              return /\A#{longopt(*b, value)}/ if a.empty?
-
-              /\A(?:#{shortopt(*a)}|#{longopt(*b, value)})/
-            end
-
-            def shortopt(*group)
-              group.map! { |s| Regexp.escape(s.sub(/\A-/, '')) }
-              "-(?:#{Regexp.escape(group.join('|'))})(?:\\z|[^ =]| +[^ -])"
-            end
-
-            def longopt(*group, value)
-              group.map! { |s| Regexp.escape(s.sub(/\A--/, '')) }
-              "--(?:#{Regexp.escape(group.join('|'))})(?:#{value ? '=[^ ]| +[^ -]' : '[= ]|\z'})"
+              s = target.to_a.compact
+              r.any? { |pat| s.any?(pat) }
             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, :compact, :delete, :delete?, :delete_if, :grep, :grep_v, :inspect, :to_a, :to_s
-          def_delegators :@extras, :empty?, :member?, :each, :each_with_index, :each_with_object, :partition, :dup,
-                         :first, :last, :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
-          def_delegator :@extras, :delete_if, :remove_if
-          def_delegator :@extras, :find_all, :detect_all
-          def_delegator :@extras, :find_index, :detect_index
+                         :merge, :delete, :delete?, :delete_if, :grep, :inspect, :to_a, :to_s
+          def_delegators :@extras, :empty?, :each, :each_with_index, :partition, :dup, :first, :last, :shift, :unshift,
+                         :pop, :push, :join, :map, :map!, :select, :reject, :size
 
           def initialize(opts, list, target = Set.new, project: nil, path: nil, **kwargs, &blk)
             @target = target.is_a?(Set) ? target : target.to_set
@@ -176,7 +74,7 @@ module Squared
             parse(list, opts, **kwargs, &blk)
           end
 
-          def parse(list, opts = extras, no: nil, single: nil, args: false, first: nil, underscore: nil, &blk)
+          def parse(list, opts = extras, no: nil, single: nil, args: false, first: nil, &blk)
             @extras = []
             @values = []
             bare = []
@@ -189,7 +87,6 @@ module Squared
             i = []
             f = []
             si = []
-            bl = []
             list.flat_map do |val|
               x, y = val.split('|', 2)
               if y
@@ -224,12 +121,10 @@ module Squared
                   si << flag
                 when 'v'
                   @values << Regexp.escape(flag)
-                when '!'
-                  bl << flag
                 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
@@ -237,66 +132,43 @@ module Squared
             end
             no = (no || []).map { |val| (n = val.index('=')) ? val[0, n] : val }
             bare.concat(no)
-            if underscore
-              tr = ->(list) { list.map { |val| val.tr('-', '_') } }
-              @values.concat(tr.call(@values))
-              bare.concat(tr.call(bare))
-              e.concat(tr.call(e))
-              b.concat(tr.call(b))
-              m.concat(tr.call(m))
-              p.concat(tr.call(p))
-              q.concat(tr.call(q))
-              qq.concat(tr.call(qq))
-              i.concat(tr.call(i))
-              f.concat(tr.call(f))
-              si.concat(tr.call(si))
-              bl.concat(tr.call(bl))
-              no.concat(tr.call(no))
-            end
             numtype = [
               [i, /\A\d+\z/],
-              [f, /\A(\d+(\.\d*)?|\d*\.\d+)\z/],
+              [f, /\A\d*(?:\.\d+)?\z/],
               [si, /\A-?\d+\z/]
             ].freeze
             numcheck = ->(k, v) { numtype.any? { |flag, pat| flag.include?(k) && pat.match?(v) } }
             skip = false
             opts.each do |opt|
-              next skip = true if opt == '--'
-              next push opt if skip
+              next @extras << opt if skip
 
               if single&.match?(opt)
-                add "-#{opt}"
+                target << "-#{opt}"
               elsif bare.include?(opt)
-                add(opt.size == 1 ? "-#{opt}" : "--#{opt}")
-              elsif opt.match?(/\Ano[-_]/) && no.include?(name = opt[3..-1])
-                add "--no-#{name}"
+                target << (opt.size == 1 ? "-#{opt}" : "--#{opt}")
+              elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
+                target << "--no-#{name}"
               else
-                if opt =~ OPT_VALUE
+                if opt =~ /\A([^=]+)=(.+)\z/
                   key = $1
                   val = $2
                   merge = m.include?(key)
                   if e.include?(key)
-                    add shell_option(key, val, merge: merge)
+                    target << shell_option(key, val, merge: merge)
                   elsif q.include?(key)
-                    add quote_option(key, val, double: qq.include?(key), merge: merge)
-                  elsif p.include?(key)
-                    if val =~ /\A(["']).+\1\z/
-                      add shell_option(key, val, double: $1 == '"', escape: false, merge: merge)
-                    elsif path
-                      add quote_option(key, path + val, merge: merge)
-                    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)
+                    target << quote_option(key, val, double: qq.include?(key), merge: merge)
+                  elsif p.include?(key) && path
+                    target << quote_option(key, path + val, merge: merge)
+                  elsif b.include?(key) || numcheck.call(key, val)
+                    target << basic_option(key, val, merge: merge)
                   elsif merge
-                    add basic_option(key, val, merge: true)
+                    target << basic_option(key, val, merge: true)
                   else
-                    push opt
+                    @extras << opt
                   end
                   opt = key
                 else
-                  push opt
+                  @extras << opt
                   skip = true if args
                 end
                 skip = true if first&.any? { |s| s.is_a?(Regexp) ? opt.match?(s) : !opt.include?(s) }
@@ -316,215 +188,100 @@ module Squared
             self
           end
 
-          def append(*args, clear: false, preserve: '"', **kwargs)
-            args = clear ? extras.dup.tap { extras.clear } : extras if args.empty?
-            OptionPartition.append(target, *args, preserve: preserve, **kwargs)
+          def append(*args, **kwargs)
+            OptionPartition.append(target, *(args.empty? ? extras : args), **kwargs)
             self
           end
 
-          def append_any(*args, escape: false, **kwargs)
-            quote = kwargs.fetch(:quote, true)
-            (args.empty? ? extras : args.flatten).each do |val|
-              if exist?(val)
-                add_path(val, **kwargs)
-              elsif escape
-                add shell_escape(val, **kwargs)
-              elsif quote
-                add_quote(val, **kwargs)
-              else
-                add val
-              end
-              found << val if args.empty?
-            end
-            self
-          end
-
-          def uniq(list)
-            ignore = map { |val| nameonly(val) }
-            list.reject do |val|
-              next true if ignore.include?(s = nameonly(val))
-
-              pat = OptionPartition.send(:matchopt, s)
-              any? { |opt| opt.match?(pat) }
-            end
-          end
-
           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
-              return self unless opts
+            if !opts
+              opts = errors ? @errors : @extras
+            elsif errors
+              OptionPartition.clear(target, @errors, styles: styles, **kwargs)
+              @errors.clear
             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.reject { |val| found.include?(val) }, styles: styles, **kwargs)
             opts.clear
             self
           end
 
-          def adjoin(*args, with: nil, start: false)
-            i = -1
-            temp = compact
-            if with
-              pat = case with
-                    when String, Symbol
-                      /\A#{Regexp.escape(with)}\z/
-                    when Array
-                      OptionPartition.send(:matchopts, with)
-                    else
-                      with
-                    end
-              temp.each_with_index do |val, index|
-                if val.to_s.match?(pat)
-                  i = index + (start.is_a?(Numeric) ? start : 1)
-                  break
-                end
-              end
-            else
-              temp.each_with_index do |val, index|
-                if i == 0
-                  next unless val.is_a?(String) && val.start_with?('-')
-
-                  i = index
-                  break
-                elsif index > 0 && !val.to_s.start_with?('-')
-                  if start
-                    i = index + (start.is_a?(Numeric) ? start : 1)
-                    break
-                  end
-                  i = 0
-                end
-              end
-            end
-            if i > 0
-              if args.empty?
-                args = dup
-                reset
-              else
-                args.each { |val| remove val }
-              end
-              args = temp[0...i] + args + temp[i..-1]
-              target.clear
-            end
-            merge args
-            self
+          def arg?(*args, **kwargs)
+            OptionPartition.arg?(target, *args, **kwargs)
           end
+        end
 
-          def add_path(*args, **kwargs)
-            add shell_quote(path ? path.join(*args) : File.join(*args), option: false, **kwargs)
-            self
+        class JoinSet < Set
+          def self.to_s
+            super[/[^:]+\z/, 0]
           end
 
-          def add_quote(*args, **kwargs)
-            kwargs.delete(:quote)
-            args.compact!
-            merge(args.map! { |val| val == '--' || OptionPartition.opt?(val) ? val : shell_quote(val, **kwargs) })
-            self
+          attr_reader :delim
+
+          def initialize(data = [], delim: ' ')
+            super(data.compact)
+            @delim = delim
           end
 
-          def delim
-            add '--'
-            self
+          def last(val, pat)
+            (@last ||= []).append([val, pat, $1]) if val =~ pat
+            self << val
           end
 
-          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|
-                              val = val.to_s
-                              next if pattern && OptionPartition.pattern?(val)
-
-                              exclude.none? { |pat| val.match?(pat) }
-                            end
-                          end
-            unless temp.empty?
-              add '--' if delim
-              extras.clear
-              concat other
-              if path
-                temp.each { |val| add_path(val) }
-              else
-                temp.map! { |val| shell_quote(val) } if quote
-                merge temp
+          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|
+                if opt == val
+                  j = index
+                elsif j && opt[pat, 1] == key
+                  i << index
+                end
               end
+              next unless j && !i.empty?
+
+              val = ret[j]
+              cur = j
+              i.each do |k|
+                ret[cur] = ret[k]
+                cur = k
+              end
+              ret[i.last] = val
             end
-            self
+            block_given? ? ret.reject(&blk) : ret
           end
 
-          def reset(errors: false)
-            extras.clear
-            found.clear
-            clear(errors: true) if errors
-            self
+          def and(*args)
+            self << '&&'
+            merge args
           end
 
-          def append?(key, val = nil, type: nil, force: false, **kwargs)
-            return false unless force || !arg?(key)
-
-            val = yield self if block_given?
-            return false unless val
-
-            type ||= :quote if kwargs.empty?
-            add case type
-                when :quote
-                  quote_option(key, val)
-                when :basic
-                  basic_option(key, val)
-                else
-                  shell_option(key, val, **kwargs)
-                end
-            true
+          def or(*args)
+            self << '||'
+            merge args
           end
 
-          def arg?(*args, **kwargs)
-            OptionPartition.arg?(target, *args, **kwargs)
+          def with(*args, &blk)
+            temp('&&', *args, &blk)
           end
 
-          def exist?(*args, add: false, first: false, last: false)
-            return false unless path
-            return path.join(*args).exist? unless args.empty?
-
-            if first || last
-              return false unless (val = first ? self.first : self.last).is_a?(String)
-
-              path.join(val).exist?.tap do |ret|
-                next unless add && ret
-
-                add_path(first ? shift : pop)
-              end
-            else
-              each_with_index do |val, index|
-                next unless val.is_a?(String) && path.join(val).exist?
-
-                if add
-                  remove_at index
-                  add_path val
-                end
-                return true
-              end
-              false
-            end
+          def temp(*args, &blk)
+            args.compact!
+            ret = pass(&blk)
+            ret = Set.new(ret.concat(args)).to_a unless args.empty?
+            ret.join(@delim)
           end
 
-          def uniq!(list)
-            unless (list = uniq(list)).empty?
-              concat list
-              self
-            end
+          def done
+            ret = to_s
+            clear
+            ret
           end
 
-          private
-
-          def nameonly(val)
-            val[OPT_VALUE, 1] || val
+          def to_s
+            pass.join(@delim)
           end
         end
       end

data/lib/squared/workspace/project.rb

@@ -3,16 +3,6 @@
 module Squared
   module Workspace
     module Project
-      class << self
-        attr_accessor :line_width
-
-        def max_width(lines)
-          n = [lines.empty? ? 0 : lines.max_by(&:size).size, 80].max
-          [n, Rake.application.terminal_width].min
-        end
-      end
-
-      @line_width = ENV.fetch('LOG_COLUMNS', 80).to_i
     end
   end
 end