squared 0.3.14 → 0.4.0

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
@@ -53,7 +57,7 @@ module Squared
         end
         wrap = ->(s, n) { "\x1B[#{n.join(';')}m#{s}\x1B[0m" }
         code = []
-        args.concat(as_a(styles)).flatten.each_with_index do |type, i|
+        args.concat(as_a(styles)).each_with_index do |type, i|
           next unless type
 
           if index == -1
@@ -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.between?(0, 256)
+          elsif val >= 0 && val <= 256
             ret << val
           elsif val < 0 && (b = val.to_s.split('.')[1])
             b = b[0, 3]
@@ -127,11 +131,11 @@ module Squared
       def apply_style(data, key, args, empty: true)
         return if data.is_a?(::Symbol) && (data = __get__(:theme)[data]).nil?
 
-        set = ->(k, v) { data[k.to_sym] = check_style(v, empty: empty) }
+        set = ->(k, v) { data[k] = check_style(v, empty: empty) }
         if key.is_a?(::Hash)
           key.each { |k, v| set.(k, v || args) }
         else
-          set.(key, args)
+          set.(key.to_sym, args)
         end
       end
 
@@ -166,21 +170,29 @@ 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], pass: false)
+        return false if !pass && level.is_a?(::Numeric) && level < ARG[:LEVEL]
+
         args = args.map(&:to_s)
-        if args.size > 1
+        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, pipe: -1)
+          emphasize(args, title: title + (subject ? " #{subject}" : ''), sub: sub)
         else
           msg = [log_title(level, color: color)]
-          msg << (color ? sub_style(subject, :underline) : subject) if subject
-          msg << args.shift if msg.size == 1
+          if subject
+            msg << (color ? sub_style(subject, styles: (@theme && @theme[:subject]) || :bold) : subject)
+          else
+            msg += args
+            args.clear
+          end
           message(msg.join(' '), *args, hint: hint)
         end
       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|
@@ -222,27 +234,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|
@@ -257,8 +273,6 @@ module Squared
           yield out
         elsif pipe
           case pipe
-          when -1
-            return out
           when 0
             pipe = $stdin
           when 2
@@ -276,10 +290,6 @@ module Squared
         val.gsub(/\x1B\[(\d+;?)+m/, '')
       end
 
-      def stripext(val)
-        File.basename(val, File.extname(val))
-      end
-
       def raise_error(*args, hint: nil, kind: ArgumentError)
         raise kind, message(*args, hint: hint, empty: true), caller_locations(1).map(&:to_s)
       end

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))
@@ -21,7 +21,7 @@ module Squared
                 return false
               end
               attempts -= 1
-              exit 1 unless attempts > 0
+              exit 1 unless attempts >= 0
             end
           rescue Interrupt
             puts

data/lib/squared/common/shell.rb

@@ -8,79 +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].match?(/\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
-          val.empty? ? '' : Shellwords.escape(val)
+          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?(' ')
-        return val if option && val =~ /(?:^|\S=|[^=]\s+|#{Rake::Win32.windows? ? '[\\\/]' : '\/'})(["']).+\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*/)
+      def basic_option(flag, val, merge: false)
+        shell_option(flag, val, escape: false, force: false, merge: merge)
       end
     end
   end

data/lib/squared/common/system.rb

@@ -1,32 +1,23 @@
 # frozen_string_literal: true
 
 require 'pathname'
-require 'rake'
+require 'fileutils'
 
 module Squared
   module Common
     module System
       module_function
 
-      def shell(*args, name: :system, **kwargs)
-        if RUBY_ENGINE == 'jruby' && Rake::Win32.windows?
-          e = kwargs[:exception]
-          if (dir = kwargs[:chdir]) && ((pwd = Dir.pwd) != dir)
-            Dir.chdir(dir)
-            ret = Kernel.send(name, *args)
-            Dir.chdir(pwd)
-          else
-            ret = Kernel.send(name, *args)
-          end
-        elsif RUBY_VERSION < '2.6'
-          e = kwargs.delete(:exception)
-          ret = Kernel.send(name, *args, **kwargs)
+      def shell(*args, **kwargs)
+        if RUBY_VERSION < '2.6'
+          exception = kwargs.delete(:exception)
+          ret = system(*args, **kwargs)
+          return ret if ret || !exception
+
+          raise $?.to_s
         else
-          return Kernel.send(name, *args, **kwargs)
+          system(*args, **kwargs)
         end
-        return ret unless e && !ret && name == :system
-
-        raise $?.to_s
       end
 
       def copy_dir(src, dest, glob = ['**/*'], create: false, link: nil, force: false, pass: nil, verbose: true)
@@ -38,9 +29,10 @@ module Squared
         dest.mkpath if create
         if pass
           exclude = []
-          Array(pass).each { |val| exclude += Dir.glob(src.join(val)) }
+          pass = [pass] unless pass.is_a?(::Array)
+          pass.each { |val| exclude += Dir.glob(src.join(val)) }
         end
-        Array(glob).each do |val|
+        (glob.is_a?(::Array) ? glob : [glob]).each do |val|
           Dir.glob(src.join(val)) do |path|
             next if exclude&.include?(path) || (path = Pathname.new(path)).directory?
 
@@ -87,7 +79,8 @@ module Squared
       def copy_guard(src, dest, link: nil, force: false, verbose: true)
         unless force
           if (path = Pathname.new(dest)).directory?
-            src = Array(src).reject { |val| path.join(File.basename(val)).exist? }
+            src = [src] unless src.is_a?(::Array)
+            src = src.reject { |val| path.join(File.basename(val)).exist? }
             return if src.empty?
           elsif path.exist?
             return

data/lib/squared/common/utils.rb

@@ -8,6 +8,10 @@ module Squared
     module Utils
       module_function
 
+      def split_escape(val, char: ',')
+        val.split(/\s*(?<!\\)#{char}\s*/o)
+      end
+
       def task_invoke(*cmd, args: [], exception: true, warning: true)
         cmd.each { |name| Rake::Task[name].invoke(*args) }
       rescue StandardError => e
@@ -31,8 +35,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 +141,7 @@ module Squared
             return ret.to_i
           end
         when ::Numeric
-          return key if key.between?(0, 2)
+          return key if key >= 0 && key <= 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
@@ -250,8 +250,6 @@ module Squared
                                                 { pat: /\A(.+ : ")(.+)("\s*)\z/m, styles: theme[:string], index: 2 },
                                                 { pat: /\A(.+ : \{)(.+)(\}\s*)\z/m, styles: theme[:hash], index: 2 },
                                                 { pat: /\A(.+ : \[)(.+)(\]\s*)\z/m, styles: theme[:array], index: 2 },
-                                                { pat: /\A(.+ : )(true|false)(\s*)\z/m, styles: theme[:boolean],
-                                                  index: 2 },
                                                 { pat: /\A(.+ : (?!undefined))([^"\[{].*)\z/m, styles: theme[:value],
                                                   index: 2 }
                                               ]

data/lib/squared/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Squared
-  VERSION = '0.3.14'
+  VERSION = '0.4.0'
 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)
@@ -296,7 +296,7 @@ module Squared
         index = 0
         while @project[name]
           index += 1
-          name = task_name "#{project}-#{index}"
+          name = "#{project}-#{index}"
         end
         proj = ((if !ref.is_a?(Class)
                    Application.find(ref, path: path)
@@ -350,14 +350,14 @@ module Squared
       end
 
       def describe(data)
-        @describe ||= {
+        @describe = {
           alias: {},
           replace: [],
           pattern: {}
         }
         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
@@ -404,7 +404,7 @@ module Squared
       end
 
       def task_localname(val)
-        prefix && val.is_a?(String) ? val.sub(/\A#{Regexp.escape(prefix)}:/, '') : val.to_s
+        prefix && val.is_a?(String) ? val.sub(/\A#{Regexp.escape(prefix)}:/o, '') : val.to_s
       end
 
       def task_desc(*args, **kwargs)
@@ -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
@@ -455,7 +454,7 @@ module Squared
           tasks << key if obj.has?(key, baseref)
         elsif (batch = series.batch_get(key))
           obj.allref.each do |ref|
-            next unless obj.has?(key, ref) && (data = batch[ref])
+            next unless (data = batch[ref])
 
             data.each do |val|
               if (items = task_resolve(obj, val)).empty?
@@ -474,7 +473,7 @@ module Squared
           return [] if (base && !obj.ref?(baseref)) || !(data = series.alias_get(key))
 
           obj.allref.each do |ref|
-            next unless obj.has?(key, ref) && (alt = data[ref])
+            next unless (alt = data[ref])
 
             ret = task_resolve(obj, alt)
             break unless ret.empty?
@@ -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,12 +586,8 @@ module Squared
         Rake::Win32.windows?
       end
 
-      def jruby?
-        RUBY_ENGINE == 'jruby'
-      end
-
-      def jruby_win?
-        jruby? && windows?
+      def docker?
+        File.exist?('/.dockerenv')
       end
 
       def rootpath(*args)
@@ -628,14 +623,9 @@ module Squared
       private
 
       def __build__(default: nil, **)
-        unless task_defined?('squared:version')
-          task 'squared:version' do
-            puts Squared::VERSION
-          end
-        end
-        if default && task_defined?(out = task_name(default))
-          task Rake.application.default_task_name => out
-        end
+        return unless default && task_defined?(out = task_name(default))
+
+        task Rake.application.default_task_name => out
       end
 
       def puts(*args)
@@ -669,19 +659,20 @@ module Squared
       end
 
       def data_get(*args, group: nil, ref: nil, target: nil)
-        if group && (ret = target[:group][group.to_sym])
-          ret
-        elsif ref
-          if ref.is_a?(Enumerable)
-            ref.each do |key|
-              next unless (ret = target[:ref][key])
+        if group
+          target[:group][group.to_sym]
+        elsif ref.is_a?(Array)
+          ref = ref.each
+        end
+        if ref.instance_of?(Enumerator)
+          ref.each do |key|
+            next unless (ret = target[:ref][key])
 
-              return ret if args.empty? || args.any? { |val| ret.key?(val) }
-            end
-            nil
-          else
-            target[:ref][ref]
+            return ret if args.empty? || args.any? { |val| ret.key?(val) }
           end
+          nil
+        elsif ref
+          target[:ref][ref]
         end
       end
 
@@ -705,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