squared 0.4.20 → 0.4.21

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

@@ -10,8 +10,9 @@ module Squared
           include Common::Shell
           extend Forwardable
 
-          OPT_VALUE = /\A([^=]+)=(.+)\z/
-          private_constant :OPT_VALUE
+          OPT_VALUE = /\A-{0,2}([^= ]+)(?: *= *| +)(.+)\z/
+          OPT_SINGLE = /\A-([A-Za-z\d])(.+)\z/
+          private_constant :OPT_VALUE, :OPT_SINGLE
 
           class << self
             include Common::Format
@@ -45,11 +46,23 @@ module Squared
               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?
+
+                opts = opts.first(count) if count >= 0
+                opts.send(reverse ? :reverse_each : :each) { |key| target.delete(key) }
+                ret.concat(opts)
+              end
+              ret
+            end
+
             def strip(val)
               return [] unless val
 
               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?)
+              val.map { |s| s.sub(OPT_SINGLE, '\1=\2').sub(OPT_VALUE, '\1=\2') }.reject(&:empty?)
             end
 
             def select(list, bare: true, no: true, single: false, double: false)
@@ -63,16 +76,34 @@ module Squared
 
             def arg?(target, *args, value: false, **)
               r, s = args.partition { |val| val.is_a?(Regexp) }
-              unless s.empty?
-                s.map! { |val| Regexp.escape(val.start_with?('-') ? val : shell_option(val)) }
-                r << /\A(?:#{s.join('|')})#{value ? '[ =].' : '(?: |=|\z)'}/
-              end
+              r << matchopts(s, value: value) unless s.empty?
               Array(target).compact.any? { |val| r.any? { |pat| pat.match?(val.to_s) } }
             end
 
             def pattern?(val)
               val.match?(/(?:\A\^|\$\z)/) || val.match?(/(?:\.[*+]|\(\?:|\\[dsw]|\[.+\]|\{\d+,?\d*\})/)
             end
+
+            private
+
+            def matchopt(val, value = false)
+              /\A#{val.size == 1 ? shortopt(val) : longopt(val, value)}/
+            end
+
+            def matchopts(list, value = false)
+              a, b = list.partition { |val| val.size == 1 || val.match?(OPT_SINGLE) }
+              /\A(?:#{shortopt(*a)}|#{longopt(*b, value)})/
+            end
+
+            def shortopt(*group)
+              group.map! { |s| s.sub(/\A-/, '') }
+              "-(?:#{Regexp.escape(group.join('|'))})(?:\\z|[^ =]| +[^ -])"
+            end
+
+            def longopt(*group, value)
+              group.map! { |s| s.sub(/\A--/, '') }
+              "--(?:#{Regexp.escape(group.join('|'))})(?:#{value ? '=[^ ]| +[^ -]' : '[= ]|\z'})"
+            end
           end
 
           attr_reader :target, :extras, :found, :errors, :values, :project, :path
@@ -80,11 +111,14 @@ module Squared
           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, :delete_at, :join, :map, :map!, :select, :select!, :reject, :size
+                         :pop, :push, :concat, :index, :join, :map, :map!, :detect, :select, :select!, :reject, :size,
+                         :delete_at
 
           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
 
           def initialize(opts, list, target = Set.new, project: nil, path: nil, **kwargs, &blk)
             @target = target.is_a?(Set) ? target : target.to_set
@@ -95,7 +129,7 @@ module Squared
             parse(list, opts, **kwargs, &blk)
           end
 
-          def parse(list, opts = extras, no: nil, single: nil, args: false, first: nil, &blk)
+          def parse(list, opts = extras, no: nil, single: nil, args: false, first: nil, underscore: nil, &blk)
             @extras = []
             @values = []
             bare = []
@@ -148,7 +182,7 @@ module Squared
                 else
                   next
                 end
-                m << flag if val[n + 2] == 'm'
+                m << flag if flag.size == 1 && val[n + 2] == 'm'
                 bare << flag if val.end_with?('?')
               else
                 bare << val
@@ -156,6 +190,22 @@ 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+)?\z/],
@@ -171,7 +221,7 @@ module Squared
                 add "-#{opt}"
               elsif bare.include?(opt)
                 add(opt.size == 1 ? "-#{opt}" : "--#{opt}")
-              elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
+              elsif opt.match?(/\Ano[-_]/) && no.include?(name = opt[3..-1])
                 add "--no-#{name}"
               else
                 if opt =~ OPT_VALUE
@@ -182,8 +232,14 @@ module Squared
                     add 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) && path
-                    add quote_option(key, path + val, merge: merge)
+                  elsif p.include?(key)
+                    if val.match?(/\A(["']).+\1\z/)
+                      add shell_option(key, val, escape: false, merge: merge, sep: sep)
+                    elsif path
+                      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)
                   elsif merge
@@ -219,57 +275,86 @@ module Squared
             self
           end
 
+          def append_any(*args, **kwargs)
+            (args.empty? ? extras : args.flatten).each do |val|
+              if exist?(val)
+                add_path(val, **kwargs)
+              else
+                add_quote(val, **kwargs)
+              end
+            end
+            self
+          end
+
           def uniq(list)
-            items = map { |val| nameonly(val) }
+            ignore = map { |val| nameonly(val) }
             list.reject do |val|
-              next true if items.include?(s = nameonly(val))
+              next true if ignore.include?(s = nameonly(val))
 
-              pat = /\A#{s = fill_option(s)}(?:#{s.start_with?('--') ? '[= ]' : '.*'}|\z)/
+              pat = OptionPartition.send(:matchopt, s)
               any? { |opt| opt.match?(pat) }
             end
           end
 
-          def uniq!(list)
-            n = size
-            concat uniq(list)
-            extras if size > n
-          end
-
           def clear(opts = nil, errors: false, **kwargs)
             styles = project.theme[:inline] if project
-            if !opts
-              opts = errors ? @errors : @extras
-            elsif errors
-              OptionPartition.clear(target, @errors, styles: styles, **kwargs)
-              @errors.clear
+            if errors
+              OptionPartition.clear(target, self.errors, styles: styles, **kwargs)
+              self.errors.clear
+              return self unless opts
             end
-            OptionPartition.clear(target, opts.reject { |val| found.include?(val) }, styles: styles, **kwargs)
+            opts ||= extras
+            OptionPartition.clear(target, if found.empty?
+                                            opts
+                                          else
+                                            opts.reject { |val| found.include?(val) }
+                                          end, styles: styles, **kwargs)
             opts.clear
             self
           end
 
-          def adjoin(*args, start: false)
+          def adjoin(*args, with: nil, start: false)
             i = -1
-            (items = to_a).each_with_index do |val, index|
-              if i == 0
-                next unless val.start_with?('-')
-
-                i = index
-                break
-              elsif index > 0 && !val.start_with?('-')
-                if start
+            temp = to_a
+            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
-                i = 0
+              end
+            else
+              temp.each_with_index do |val, index|
+                if i == 0
+                  next unless val.start_with?('-')
+
+                  i = index
+                  break
+                elsif index > 0 && !val.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 = items[0...i] + args + items[i..-1]
+              args = temp[0...i] + args + temp[i..-1]
               target.clear
             end
             merge args
@@ -282,7 +367,7 @@ module Squared
           end
 
           def add_quote(*args, **kwargs)
-            merge(args.map { |val| shell_quote(val, **kwargs) })
+            merge(args.map! { |val| shell_quote(val, **kwargs) })
             self
           end
 
@@ -305,7 +390,8 @@ module Squared
               if path
                 found.each { |val| add_path(val) }
               else
-                merge(quote ? found.map! { |val| shell_quote(val) } : found)
+                found.map! { |val| shell_quote(val) } if quote
+                merge found
               end
             end
             self
@@ -313,6 +399,7 @@ module Squared
 
           def reset(errors: false)
             extras.clear
+            found.clear
             clear(errors: true) if errors
             self
           end
@@ -339,6 +426,39 @@ 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?
+
+            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_first(path: true, reverse: !first)
+              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
+          end
+
+          def uniq!(list)
+            unless (list = uniq(list)).empty?
+              concat list
+              self
+            end
+          end
+
           private
 
           def nameonly(val)

data/lib/squared/workspace/series.rb

@@ -49,11 +49,7 @@ module Squared
 
         def base_set(obj)
           TASK_BASE.clear
-                   .concat((if TASK_KEYS.empty?
-                              obj.tasks
-                            else
-                              obj.tasks.reject { |val| TASK_KEYS.include?(val) }
-                            end).freeze)
+          TASK_BASE.concat(obj.tasks.reject { |val| TASK_KEYS.include?(val) })
         end
 
         private
@@ -210,27 +206,25 @@ module Squared
 
       def chain?(val)
         @chain.each_value do |tasks|
-          tasks.flatten(1).each do |task|
-            next unless Rake::Task[task].already_invoked
+          tasks.flatten(1).each do |name|
+            next unless (task = invoked_get(name))
 
-            if val == task || Rake::Task[task].prerequisites.any? { |pr| pr == val && Rake::Task[val].already_invoked }
-              return true
-            end
+            return true if name == val || task.prerequisites.any? { |pr| pr == val && Rake::Task[pr].already_invoked }
           end
         end
         false
       end
 
       def multiple?(val = nil)
-        already_invoked?(multiple, val)
+        already_invoked? multiple, val
       end
 
       def sync?(val = nil)
-        already_invoked?(sync, val)
+        already_invoked? sync, val
       end
 
       def parallel?(val = nil)
-        already_invoked?(parallel, val)
+        already_invoked? parallel, val
       end
 
       def exclude?(key, empty = false)
@@ -239,12 +233,16 @@ module Squared
 
       private
 
+      def invoked_get(name)
+        return unless Rake::Task.task_defined?(name) && (ret = Rake::Task[name]).already_invoked
+
+        ret
+      end
+
       def already_invoked?(list, val)
-        if val
-          list.include?(val) && Rake::Task[val].already_invoked
-        else
-          Rake::Task.tasks.any? { |obj| obj.already_invoked && list.include?(obj.name) }
-        end
+        return Rake::Task.tasks.any? { |obj| obj.already_invoked && list.include?(obj.name) } unless val
+
+        list.include?(val) && !invoked_get(val).nil?
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.4.20
+  version: 0.4.21
 platform: ruby
 authors:
 - An Pham