squared 0.3.6 → 0.4.1

data/lib/squared/common/format.rb

@@ -28,12 +28,16 @@ module Squared
         bright_cyan!: '106',
         bright_white!: '107'
       }.freeze
+      AIX_GRAPH = ['│', '─', '├', '└', '┬'].freeze
+      AIX_BORDER = ['│', '─', '╭', '╮', '╯', '╰', '├', '┤', '┬', '┴'].freeze
       TEXT_STYLE = [:bold, :dim, :italic, :underline, :blinking, nil, :inverse, :hidden, :strikethrough].freeze
-      private_constant :AIX_TERM, :TEXT_STYLE
+      private_constant :AIX_TERM, :AIX_GRAPH, :AIX_BORDER, :TEXT_STYLE
 
       def enable_aixterm
         unless (colors = __get__(:colors)).frozen?
           colors.merge!(AIX_TERM)
+          ARG[:GRAPH] = AIX_GRAPH
+          ARG[:BORDER] = AIX_BORDER
         end
         block_given? ? yield(self) : self
       end
@@ -114,7 +118,7 @@ module Squared
           if !val.is_a?(::Numeric)
             val = val.to_sym
             ret << val if colors.key?(val) || TEXT_STYLE.include?(val)
-          elsif val >= 0 && val <= 256
+          elsif val.between?(0, 256)
             ret << val
           elsif val < 0 && (b = val.to_s.split('.')[1])
             b = b[0, 3]
@@ -166,16 +170,23 @@ module Squared
         color ? sub_style(ret, *styles) : ret
       end
 
-      def log_message(level, *args, subject: nil, hint: nil, color: ARG[:COLOR])
+      def log_message(level, *args, subject: nil, hint: nil, color: ARG[:COLOR], append: true, pass: false)
         args = args.map(&:to_s)
-        if args.size > 1
+        if level.is_a?(::Numeric)
+          if append && respond_to?(:log)
+            ref = log rescue nil
+            ref.add(level, message(subject, *args, hint: hint, space: ', ')) if ref.is_a?(Logger)
+          end
+          return false if !pass && level < ARG[:LEVEL]
+        end
+        if args.size > 1 && !hint
           title = log_title(level, color: false)
           sub = { pat: /^(#{title})(.+)$/, styles: __get__(:theme)[:logger][log_sym(level)] } if color
           emphasize(args, title: title + (subject ? " #{subject}" : ''), sub: sub)
         else
           msg = [log_title(level, color: color)]
           if subject
-            msg << (color ? sub_style(subject, :underline) : subject)
+            msg << (color ? sub_style(subject, styles: (@theme && @theme[:subject]) || :bold) : subject)
           else
             msg += args
             args.clear
@@ -185,6 +196,8 @@ module Squared
       end
 
       def puts_oe(*args, pipe: 1)
+        return if args.first == false && args.size == 1
+
         if pipe.is_a?(Pathname)
           begin
             File.open(pipe, 'a') do |f|
@@ -201,8 +214,8 @@ module Squared
 
       module_function
 
-      def message(*args, hint: nil, empty: false)
-        (empty ? args.reject { |val| val.nil? || val.empty? } : args).join(ARG[:SPACE]) + (hint ? " (#{hint})" : '')
+      def message(*args, hint: nil, empty: false, space: ARG[:SPACE])
+        (empty ? args.reject { |val| val.nil? || val.empty? } : args).join(space) + (hint ? " (#{hint})" : '')
       end
 
       def emphasize(val, title: nil, footer: nil, right: false, cols: nil, sub: nil, border: nil, pipe: nil)
@@ -226,27 +239,31 @@ module Squared
           require 'io/console'
           (n = [n, $stdout.winsize[1] - 4].min) rescue nil
         end
+        b0, b1, b2, b3, b4, b5, b6, b7 = ARG[:BORDER]
         out = []
-        bord = '-' * (n + 4)
-        bord = sub_style(bord, styles: border) if border
+        draw = lambda do |a, b|
+          ret = a + (b1 * (n + 2)) + b
+          ret = sub_style(ret, styles: border) if border
+          ret
+        end
         sub = as_a(sub)
         pr = lambda do |line|
           s = line.ljust(n)
           sub.each { |h| s = sub_style(s, **h) }
-          s = "| #{s} |"
+          s = "#{b0} #{s} #{b0}"
           if border
-            s = sub_style(s, pat: /\A(\|)(.+)\z/m, styles: border)
-            s = sub_style(s, pat: /\A(.+)(\|)\z/m, styles: border, index: 2)
+            s = sub_style(s, pat: /\A(#{Regexp.escape(b0)})(.+)\z/m, styles: border)
+            s = sub_style(s, pat: /\A(.+)(#{Regexp.escape(b0)})\z/m, styles: border, index: 2)
           end
           s
         end
-        out << bord
+        out << draw.(b2, b3)
         if title
           out += title.map { |t| pr.(t) }
-          out << bord
+          out << draw.(b6, b7)
         end
         lines.each { |line| out << pr.(line) }
-        out << bord
+        out << draw.(b5, b4)
         if footer
           unless sub.empty? && !right
             footer.map! do |s|

data/lib/squared/common/prompt.rb

@@ -8,8 +8,8 @@ module Squared
       def confirm(msg, default = nil, agree: 'Y', cancel: 'N', attempts: 5, timeout: 15)
         require 'readline'
         require 'timeout'
-        agree = /\A#{agree}\z/i if agree.is_a?(::String)
-        cancel = /\A#{cancel}\z/i if cancel.is_a?(::String)
+        agree = /^#{agree}$/i if agree.is_a?(::String)
+        cancel = /^#{cancel}$/i if cancel.is_a?(::String)
         Timeout.timeout(timeout) do
           begin
             while (ch = Readline.readline(msg, true))

data/lib/squared/common/shell.rb

@@ -8,78 +8,91 @@ module Squared
     module Shell
       module_function
 
-      def shell_escape(val, quote: false, force: false)
-        if (data = /\A(--?[^= ]+)((=|\s+)(["'])?(.+?)(["'])?)?\z/m.match(val = val.to_s))
-          return val if !data[2] || (!data[4] && data[5] =~ /\s/)
-
-          join = ->(opt) { data[1] + data[3] + shell_quote(opt) }
-          if data[4] == data[6]
-            data[4] ? val : join.(data[5])
+      def shell_escape(val, quote: false, force: false, double: false, override: false)
+        if (r = /\A(--?)([^= ]+)((=|\s+)(["'])?(.+?)(["'])?)?\z/m.match(val = val.to_s))
+          return val if !r[3] || (!r[5] && r[6].match?(/\s/))
+
+          combine = lambda do |opt|
+            if r[2] =~ /^(["'])(.+)\1$/
+              double = $1 == '"'
+              r[2] = $2
+              override = true
+            end
+            r[1] + r[2] + r[4] + shell_quote(opt, double: double, force: force, override: override)
+          end
+          if r[5] == r[7]
+            r[5] ? val : combine.(r[6])
           else
-            join.(data[4] + data[5] + data[6])
+            force = true
+            combine.(r[5] + r[6] + r[7])
           end
         elsif Rake::Win32.windows?
-          quote ? shell_quote(val, force: force) : val
+          quote ? shell_quote(val, double: double, force: force) : val
         else
           Shellwords.escape(val)
         end
       end
 
-      def shell_quote(val, force: true)
+      def shell_quote(val, option: true, force: true, double: false, override: false)
         val = val.to_s
-        return val if (!force && !val.include?(' ')) || val.match?(/(?:^|\S=|[^=]\s+)(["']).+\1\z/m)
-
-        Rake::Win32.windows? || ARG[:QUOTE] == '"' ? "\"#{double_quote(val)}\"" : "'#{single_quote(val)}'"
-      end
-
-      def shell_split(val, escape: true, quote: false, join: nil)
-        val = Shellwords.split(val)
-        val = val.map { |opt| shell_escape(opt, quote: quote) } if escape
-        return val unless join
+        return val if (!force && !val.include?(' ')) || (option && val.match?(/(?:^|\S=|[^=]\s+)(["']).+\1\z/m))
 
-        val.join(join.is_a?(::String) ? join : ' ')
+        if double || Rake::Win32.windows? || (ARG[:QUOTE] == '"' && !override)
+          "\"#{val.gsub(/(?<!\\)"/, '\\"')}\""
+        else
+          "'#{val.gsub("'", "'\\\\''")}'"
+        end
       end
 
-      def shell_option(flag, val = nil, escape: true, quote: true, force: true)
+      def shell_option(flag, val = nil, escape: true, quote: true, force: true, double: false, override: false,
+                       merge: false)
         flag = flag.to_s
+        if flag =~ /^(["'])(.+)\1$/
+          double = $1 == '"'
+          flag = $2
+          escape = false
+          override = true
+        end
         if flag[0] == '-'
           b = flag[1] == '-' ? '=' : ' '
+        elsif flag.size == 1
+          a = '-'
+          b = merge ? '' : ' '
         else
-          a, b = flag.size == 1 ? ['-', ' '] : ['--', '=']
+          a = '--'
+          b = '='
         end
         "#{a}#{flag}#{if val
                         "#{b}#{if escape
-                                 shell_escape(val, quote: quote)
+                                 shell_escape(val, quote: quote, double: double, override: override)
                                else
-                                 quote ? shell_quote(val, force: force) : val
+                                 quote ? shell_quote(val, force: force, double: double, override: override) : val
                                end}"
                       end}"
       end
 
-      def fill_option(val)
-        return "-#{val}" if val =~ /\A[a-z](?:\d*)\z/i
+      def shell_split(val, escape: true, quote: false, join: nil)
+        ret = Shellwords.split(val)
+        return ret if join == false
 
-        shell_escape(val.start_with?('-') ? val : "--#{val}")
-      end
+        ret = ret.map { |opt| shell_escape(opt, quote: quote) } if escape
+        return ret unless join
 
-      def quote_option(flag, val)
-        shell_option(flag, val, escape: false)
+        ret.join(join.is_a?(::String) ? join : ' ')
       end
 
-      def basic_option(flag, val)
-        shell_option(flag, val, escape: false, force: false)
-      end
+      def fill_option(val, double: false)
+        return "-#{val}" if val.match?(/^[a-z]\d*$/i)
 
-      def single_quote(val)
-        val.gsub("'", "'\\\\''")
+        shell_escape(val.start_with?('-') ? val : "--#{val}", double: double)
       end
 
-      def double_quote(val)
-        val.gsub(/(?<!\\)"/, '\\"')
+      def quote_option(flag, val, double: false)
+        shell_option(flag, val, escape: false, double: double)
       end
 
-      def split_escape(val, char: ',')
-        val.split(/\s*(?<!\\)#{char}\s*/o)
+      def basic_option(flag, val, merge: false)
+        shell_option(flag, val, escape: false, force: false, merge: merge)
       end
     end
   end

data/lib/squared/common/utils.rb

@@ -8,6 +8,23 @@ module Squared
     module Utils
       module_function
 
+      def split_escape(val, char: ',')
+        val.split(/\s*(?<!\\)#{char}\s*/o)
+      end
+
+      def split_option(val)
+        val = val.strip
+        return [val, '', ''] unless (i = val.index('='))
+
+        last = val[i + 1..-1].strip
+        quote = ''
+        if last =~ /^(["'])(.+)\1$/
+          last = $2
+          quote = $1
+        end
+        [val[0..i - 1], last, quote]
+      end
+
       def task_invoke(*cmd, args: [], exception: true, warning: true)
         cmd.each { |name| Rake::Task[name].invoke(*args) }
       rescue StandardError => e
@@ -31,8 +48,57 @@ module Squared
         Rake::Task.tasks.any? do |obj|
           next unless obj.already_invoked
 
-          args.any? { |val| val.is_a?(::Regexp) ? obj.name =~ val : val == obj.name }
+          args.any? { |val| val.is_a?(::Regexp) ? obj.name.match?(val) : val == obj.name }
+        end
+      end
+
+      def time_format(epoch, clock: false, pass: [])
+        ss = 1000
+        mm = 60 * ss
+        hh = 60 * mm
+        dd = 24 * hh
+        hm = pass.include?('s')
+        time = []
+        if !clock && (d = epoch / dd) > 0
+          time << "#{d}d"
+          epoch -= d * dd
+        end
+        if (h = epoch / hh) > 0
+          time << (clock ? h.to_s : "#{h}h")
+          epoch -= h * hh
         end
+        if (m = epoch / mm) > 0
+          time << (clock ? m.to_s.rjust(2, '0') : "#{m}m")
+          epoch -= m * mm
+        elsif clock
+          time << '00'
+        end
+        unless hm
+          if (s = epoch / ss) > 0
+            time << (clock ? s.to_s.rjust(2, '0') : "#{s}s")
+            epoch -= s * ss
+          elsif clock
+            time << '00'
+          end
+        end
+        if clock
+          time.join(':')
+        else
+          time << "#{epoch}ms" unless hm || pass.include?('ms')
+          time.join(' ')
+        end
+      end
+
+      def time_offset(val = nil)
+        val = DateTime.parse(val) if val.is_a?(::String)
+        cur = DateTime.now
+        ret = 0
+        if (r = /^([+-])(\d+):(\d+):(\d+)$/.match((val || cur).strftime('%::z')))
+          ret += (r[1] == '+' ? -1 : 1) * ((r[2].to_i * 60 * 60) + (r[3].to_i * 60) + r[4].to_i) * 1000
+        end
+        return ret unless val
+
+        (cur.strftime('%Q').to_i + time_offset) - (val.strftime('%Q').to_i + ret)
       end
 
       def env(key, default = nil, suffix: nil, strict: false, equals: nil, ignore: nil)
@@ -88,7 +154,7 @@ module Squared
             return ret.to_i
           end
         when ::Numeric
-          return key if key >= 0 && key <= 2
+          return key if key.between?(0, 2)
         end
         default
       end

data/lib/squared/config.rb

@@ -90,7 +90,7 @@ module Squared
                       @required = true
                       project ? [project, 'not found'] : ['name', 'missing']
                     end
-        warn log_message(Logger::WARN, msg, subject: self.class, hint: hint)
+        warn log_message(Logger::WARN, msg, subject: self.class, hint: hint, pass: true)
       end
 
       def build

data/lib/squared/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Squared
-  VERSION = '0.3.6'
+  VERSION = '0.4.1'
 end

data/lib/squared/workspace/application.rb

@@ -173,7 +173,7 @@ module Squared
         when Symbol
           @ref = val
         else
-          raise_error('group{Symbol} | ref{String}', hint: 'missing') if block_given?
+          raise_error 'missing group or ref' if block_given?
         end
         if block_given?
           instance_eval(&blk)
@@ -357,7 +357,7 @@ module Squared
         }
         data.each do |key, val|
           key = key.to_s
-          if /\A(\\A|\^)/ =~ key || /(\\z|\$)\z/ =~ key
+          if key.match?(/\A(\\A|\^)/) || key.match?(/(\\z|\$)\z/)
             @describe[:replace] << [Regexp.new(key), val]
           else
             @describe[val.is_a?(Regexp) ? :pattern : :alias][key.to_s] = val
@@ -415,15 +415,14 @@ module Squared
           val = name || task_join(*args)
           found = false
           replace = lambda do |data, out|
-            if (index = data.size) > 0
-              data.to_a.reverse_each { |group| out.sub!("%#{index -= 1}", group) }
-            end
+            index = data.size
+            data.to_a.reverse_each { |group| out.sub!("%#{index -= 1}", group) }
             out
           end
-          @describe[:replace].each do |pat, key|
-            next unless (data = pat.match(val))
+          @describe[:replace].each do |pat, tmpl|
+            next unless val =~ pat
 
-            val = replace.(data, key.dup)
+            val = replace.($~, tmpl.dup)
             found = true
           end
           if (out = @describe[:alias][val])
@@ -431,14 +430,14 @@ module Squared
             found = true
           else
             @describe[:pattern].each do |key, pat|
-              next unless (data = pat.match(val))
+              next unless val =~ pat
 
-              val = replace.(data, key.dup)
+              val = replace.($~, key.dup)
               found = true
               break
             end
           end
-          args = Shell.split_escape(val, char: ':').map! { |s| s.gsub('\\:', ':') } if found
+          args = split_escape(val, char: ':').map! { |s| s.gsub('\\:', ':') } if found
         end
         desc message(*args, **kwargs)
       end
@@ -564,7 +563,7 @@ module Squared
 
           key = task_join(task_localname(obj.name), key)
         end
-        @pass[:pattern].any? { |item| item.is_a?(Regexp) ? key =~ item : key == item }
+        @pass[:pattern].any? { |item| item.is_a?(Regexp) ? key.to_s.match?(item) : key == item }
       end
 
       def task_defined?(*key)
@@ -587,6 +586,10 @@ module Squared
         Rake::Win32.windows?
       end
 
+      def docker?
+        File.exist?('/.dockerenv')
+      end
+
       def rootpath(*args)
         root.join(*args)
       end
@@ -693,7 +696,7 @@ module Squared
         end
         return false if state == :prod && data[:dev] == true && data[:global]
 
-        target && pat.is_a?(Regexp) ? as_a(target).any? { |val| val =~ pat } : pat == true
+        target && pat.is_a?(Regexp) ? as_a(target).any? { |val| val.match?(pat) } : pat == true
       end
 
       def scriptobj