squared 0.4.30 → 0.5.0

data/lib/squared/common/base.rb

@@ -63,7 +63,6 @@ module Squared
           hash: %i[green black!],
           array: %i[blue black!],
           number: [:magenta],
-          boolean: [:magenta],
           undefined: %i[red italic]
         },
         logger: {
@@ -94,28 +93,28 @@ module Squared
       PATH.freeze
       ARG.freeze
       VAR.each_value(&:freeze)
-      VAR[:theme].each_value { |val| val.freeze.each_value(&:freeze) }
+      VAR[:theme].each_value(&:freeze)
       VAR.freeze
     end
 
     module_function
 
-    def as_a(obj, meth = nil, flat: nil, compact: false, &blk)
+    def as_a(obj, *meth, flat: nil, compact: false, &blk)
       return [] if obj.nil?
 
       unless obj.is_a?(::Array)
-        obj = if obj.respond_to?(:to_ary)
-                obj.to_ary
-              elsif obj.respond_to?(:to_a) && !obj.is_a?(::Hash) && (val = obj.to_a).is_a?(::Array)
+        obj = if obj.respond_to?(:to_a) && !obj.is_a?(::Hash) && (val = obj.to_a).is_a?(::Array)
                 val
               else
                 [obj]
               end
       end
-      obj = flat.is_a?(::Numeric) ? obj.flatten(flat) : obj.flatten if flat
+      obj = obj.flatten(flat.is_a?(::Numeric) ? flat : nil) if flat
       obj = obj.compact if compact
-      obj = obj.map(&meth) if meth
-      block_given? ? obj.select(&blk) : obj
+      obj = obj.map(&meth.shift) until meth.empty?
+      return obj unless block_given?
+
+      obj.select(&blk)
     end
   end
 end

data/lib/squared/common/format.rb

@@ -29,19 +29,13 @@ module Squared
         bright_white!: '107'
       }.freeze
       BOX_GRAPH = ['│', '─', '├', '└', '┬'].freeze
-      BOX_BORDER = ['│', '─', '┌', '┐', '┘', '└', '├', '┤', '┬', '┴'].tap do |val|
-        if ENV['TERM']&.end_with?('256color')
-          val.slice!(2, 4)
-          val.insert(2, '╭', '╮', '╯', '╰')
-        end
-        val.freeze
-      end
+      BOX_BORDER = ['│', '─', '╭', '╮', '╯', '╰', '├', '┤', '┬', '┴'].freeze
       TEXT_STYLE = [:bold, :dim, :italic, :underline, :blinking, nil, :inverse, :hidden, :strikethrough].freeze
       private_constant :AIX_TERM, :BOX_GRAPH, :BOX_BORDER, :TEXT_STYLE
 
       def enable_aixterm
         unless (colors = __get__(:colors)).frozen?
-          colors.merge!(AIX_TERM)
+          colors.update(AIX_TERM)
         end
         self
       end
@@ -67,7 +61,7 @@ module Squared
         end
         wrap = ->(s, n) { "\x1B[#{n.join(';')}m#{s}\x1B[0m" }
         code = []
-        args.concat(Array(styles)).flatten.each_with_index do |type, i|
+        args.concat(as_a(styles)).flatten.each_with_index do |type, i|
           next unless type
 
           if index == -1
@@ -108,7 +102,7 @@ module Squared
         ret = wrap.call(ret, code) unless code.empty?
         return ret unless data
 
-        out = +''
+        out = ''.dup
         data.to_a.each_with_index do |group, i|
           next if i == 0
 
@@ -141,11 +135,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.call(k, v || args) }
         else
-          set.call(key, args)
+          set.call(key.to_sym, args)
         end
       end
 
@@ -157,8 +151,7 @@ module Squared
           when Logger::WARN then :warn
           when Logger::ERROR then :error
           when Logger::FATAL then :fatal
-          else :unknown
-          end
+          else :unknown end
         else
           level.to_s.downcase.to_sym
         end
@@ -178,9 +171,8 @@ module Squared
         args = args.map(&:to_s)
         if level.is_a?(::Numeric)
           if append && respond_to?(:log)
-            (log rescue nil).tap do |ref|
-              ref.add(level, message(subject, *args, hint: hint, space: ', ')) if ref.is_a?(::Logger)
-            end
+            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
@@ -190,16 +182,16 @@ module Squared
           emphasize(args, title: title + (subject ? " #{subject}" : ''), sub: sub, pipe: -1)
         else
           msg = [log_title(level, color: color)]
-          msg << (color ? sub_style(subject.to_s, styles: (@theme && @theme[:subject]) || :bold) : subject) if subject
+          msg << (color ? sub_style(subject, styles: (@theme && @theme[:subject]) || :bold) : subject) if subject
           msg << args.shift if msg.size == 1
           message(msg.join(' '), *args, hint: hint)
         end
       end
 
-      def log_console(*args, pipe: 1)
+      def puts_oe(*args, pipe: 1)
         return if args.first == false && args.size == 1
 
-        if pipe.is_a?(::Pathname)
+        if pipe.is_a?(Pathname)
           begin
             File.open(pipe, 'a') do |f|
               br = File::SEPARATOR == '\\' ? "\r\n" : "\n"
@@ -213,27 +205,28 @@ module Squared
         (pipe == 2 ? $stderr : $stdout).puts(*args)
       end
 
-      alias puts_oe log_console
-
       module_function
 
       def message(*args, hint: nil, empty: false, space: ARG[:SPACE])
-        (empty ? args.reject { |val| val.nil? || (val.respond_to?(:empty?) && val.empty?) } : args)
-          .join(space) + (hint ? " (#{hint})" : '')
+        (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, pipe: nil,
-                    border: @theme.is_a?(::Hash) && @theme[:border])
+                    border: @theme && @theme[:border])
         n = 0
-        max = ->(a) { n = [n, a.max_by(&:size).size].max }
-        set = ->(s) { Array(s).map(&:to_s).tap { |a| max.call(a) } }
+        max = ->(v) { n = [n, v.max_by(&:size).size].max }
+        set = lambda do |v|
+          ret = as_a(v, :to_s)
+          max.call(ret)
+          ret
+        end
         title &&= set.call(title)
         footer &&= set.call(footer)
         if val.is_a?(::Array)
           lines = val.map(&:to_s)
         else
           lines = val.to_s.lines(chomp: true)
-          lines[0] = "#{val.class}: #{lines.first}" if (err = val.is_a?(::StandardError))
+          lines[0] = "#{val.class}: #{lines.first}" if (err = val.is_a?(StandardError))
         end
         n = cols || max.call(lines)
         if $stdout.tty?
@@ -253,8 +246,8 @@ module Squared
           sub.each { |h| s = sub_style(s, **h) }
           s = "#{b0} #{s} #{b0}"
           if border
-            s = sub_style(s, pat: /\A(#{Regexp.escape(b0)})(.+)\z/om, styles: border)
-            s = sub_style(s, pat: /\A(.+)(#{Regexp.escape(b0)})\z/om, 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
@@ -288,7 +281,7 @@ module Squared
           else
             pipe = $stdout unless pipe.respond_to?(:puts)
           end
-          pipe.puts(out)
+          pipe.puts out
         else
           err ? warn(out) : puts(out)
         end

data/lib/squared/common/prompt.rb

@@ -11,24 +11,22 @@ module Squared
         agree = /^#{Regexp.escape(agree)}$/i if agree.is_a?(::String)
         cancel = /^#{Regexp.escape(cancel)}$/i if cancel.is_a?(::String)
         Timeout.timeout(timeout) do
-          begin
-            while (ch = Readline.readline(msg))
-              ch = ch.chomp
-              case (ch.empty? ? default : ch)
-              when agree
-                return true
-              when cancel
-                return false
-              end
-              attempts -= 1
-              exit 1 unless attempts > 0
+          while (ch = Readline.readline(msg))
+            ch = ch.chomp
+            case (ch.empty? ? default : ch)
+            when agree
+              return true
+            when cancel
+              return false
             end
-          rescue Interrupt
-            puts
-            exit 0
-          else
-            false
+            attempts -= 1
+            exit 1 unless attempts > 0
           end
+        rescue Interrupt
+          puts
+          exit 0
+        else
+          false
         end
       end
 
@@ -37,49 +35,50 @@ module Squared
         require 'readline'
         require 'timeout'
         if list
-          grep &&= Array(grep).map { |val| Regexp.new(val) }
+          grep &&= (grep.is_a?(::Enumerable) ? grep : [grep]).map { |val| Regexp.new(val) }
           items = []
           list.each do |val|
             next if grep&.none? { |pat| pat.match?(line) }
 
-            items << val.to_s.chomp
+            items << val.chomp
             puts "#{items.size.to_s.rjust(2)}. #{val}"
           end
           max = items.size
           raise_error 'empty selection list' if max == 0
-          min = grep ? 1 : [min, max].min
+          min = [min, max].min
           if auto
-            msg = "#{msg}: [#{min}-#{max}#{if multiple
-                                             "|,#{multiple.is_a?(::Numeric) ? "{#{multiple}}" : ''}"
-                                           end}] "
+            msg = "#{msg}: [1-#{max}#{if multiple
+                                        "|,#{multiple.is_a?(Numeric) ? "{#{multiple}}" : ''}"
+                                      end}] "
           end
         end
         valid = ->(s) { s.match?(/^-?\d+$/) && s.to_i.between?(min, max) }
         Timeout.timeout(timeout) do
-          begin
-            while (ch = Readline.readline(msg))
-              unless (ch = ch.strip).empty?
-                if multiple
-                  a = ch.split(/\s*,\s*/)
-                  b = a.select { |s| valid.call(s) }.map!(&:to_i).sort
-                  next unless a.size == b.size
-                  return items ? b.map! { |i| items[i - 1] } : b unless multiple.is_a?(::Numeric) && multiple != b.size
-                elsif valid.call(ch)
-                  return items ? items[ch.to_i - 1] : ch.to_i
-                end
-              end
-              attempts -= 1
-              next if attempts > 0
+          while (ch = Readline.readline(msg))
+            unless (ch = ch.strip).empty?
+              if multiple
+                a = ch.split(/\s*,\s*/)
+                b = a.select { |s| valid.call(s) }.map!(&:to_i).sort
+                next unless a.size == b.size
+                return b unless items
+                next if multiple.is_a?(::Numeric) && multiple != b.size
 
-              exit 1 if force
-              break
+                return b.map! { |i| items[i - 1] }
+              elsif valid.call(ch)
+                return items ? items[ch.to_i - 1] : ch.to_i
+              end
             end
-          rescue Interrupt
-            puts
-            exit 0
-          else
-            multiple ? [] : nil
+            attempts -= 1
+            next if attempts > 0
+            break unless force
+
+            exit 1
           end
+        rescue Interrupt
+          puts
+          exit 0
+        else
+          multiple ? [] : nil
         end
       end
 
@@ -94,19 +93,19 @@ module Squared
           elsif block_given?
             Readline.readmultiline(msg, history, &blk)
           else
-            Readline.readmultiline(msg, history) { |line| multiline.any? { |val| line.split.last.end_with?(val.to_s) } }
+            Readline.readmultiline(msg, history) { |line| multiline.any? { |val| line.split.last.end_with?(val) } }
           end
         end
         case force
         when ::TrueClass, ::FalseClass
           msg = "#{msg} %s " % if multiline
-                                 multiline.is_a?(::Enumerable) ? "{#{multiline.to_a.join('|')}}" : multiline
+                                 multiline.is_a?(::Enumerable) ? "{#{multiline.join('|')}}" : multiline
                                else
                                  "(#{force ? 'required' : 'optional'}):"
                                end
           ret = (prompt.call || '').strip
-          multiline.each { |val| break if ret.delete_suffix!(val.to_s) } if multiline.is_a?(::Enumerable)
-          exit 1 if force && ret.empty?
+          multiline.each { |val| break if ret.delete_suffix!(val) } if multiline.is_a?(::Enumerable)
+          raise_error 'user cancelled' if force && ret.empty?
           ret
         else
           prompt.call

data/lib/squared/common/shell.rb

@@ -6,31 +6,28 @@ require 'rake'
 module Squared
   module Common
     module Shell
-      QUOTE_VALUE = /\A(["'])(.*)\1\z/m.freeze
-      private_constant :QUOTE_VALUE
-
       module_function
 
       def shell_escape(val, quote: false, force: false, double: false, option: false, override: false)
-        if (r = /\A(--?)([^=\s]+)((=|\s+)(["'])?(?(5)(.*)\5|(.*)))?\z/m.match(val = val.to_s))
-          if (data = r[2].match(QUOTE_VALUE))
+        if (r = /\A(--?)([^= ]+)((=|\s+)(["'])?(?(5)(.*)\5|(.*)))?\z/m.match(val = val.to_s))
+          if (data = r[2].match(/\A(["'])(.+)\1\z/))
             double = data[1] == '"'
             override = true
           elsif !r[3] || r[6]
             return val
           end
-          opt = if r[7].match?(/\A["']/)
-                  "#{r[7]}#{r[7][0]}"
-                elsif r[7].match?(/["']\z/)
-                  "#{r[7][-1]}#{r[7]}"
-                else
-                  return val unless r[7].match?(/\s/)
-
-                  r[7]
-                end
-          r[1] + (data ? data[2] : r[2]) + r[4] + shell_quote(opt, force: force, double: double, override: override)
-        elsif option && val =~ /\A(-{0,2}[^=\s-][^=\s]*)=(.+)\z/m
-          return val if $2.match?(QUOTE_VALUE)
+          if r[7].match?(/\A["']/)
+            opt = "#{r[7]}#{r[7][0]}"
+          elsif r[7].match?(/["']\z/)
+            opt = "#{r[7][-1]}#{r[7]}"
+          else
+            return val unless r[7].match?(/\s/)
+
+            opt = r[7]
+          end
+          r[1] + (data ? data[2] : r[2]) + r[4] + shell_quote(opt, double: double, force: force, override: override)
+        elsif option && val =~ /\A([^=]+)=(.+)\z/m
+          return val if $2.match?(/\A(["']).+\1\z/m)
 
           "#{$1}=%s" % if $2.include?(' ')
                          shell_quote($2, option: false)
@@ -38,92 +35,81 @@ module Squared
                          Rake::Win32.windows? ? $2 : Shellwords.escape($2)
                        end
         elsif Rake::Win32.windows?
-          quote ? shell_quote(val, force: force, double: double) : val
-        elsif val.empty?
-          ''
+          quote ? shell_quote(val, double: double, force: force) : val
         else
-          Shellwords.escape(val)
+          val.empty? ? '' : Shellwords.escape(val)
         end
       end
 
-      def shell_quote(val, option: true, force: true, double: false, preserve: true, override: false)
+      def shell_quote(val, option: true, force: true, double: false, override: false)
         val = val.to_s
         return val if (!force && !val.include?(' ')) || val.empty?
 
-        if option
-          pat = /\A(?:-[^=\s-](?:=|\s+)?|(--)?[^=\s-][^=\s]*(?(1)(?:=|\s+)|=))(["']).+\2\z/m
-          return val if val.match?(pat)
+        if option && val.match?(/(?:\A|\A[^=\s]+(?:=|\s+)|#{Rake::Win32.windows? ? '[\\\/]' : '\/'})(["']).+\1\z/m)
+          return val
         end
-        q = ->(s) { s.gsub("'\\\\''", "'") }
-        if val =~ QUOTE_VALUE
-          return val if $1 == '"' && Rake::Win32.windows? && val.match?(/(?:[#{File::SEPARATOR} ]|\\")/o)
 
-          base = $2 unless preserve
-        end
         if double || Rake::Win32.windows? || (ARG[:QUOTE] == '"' && !override)
-          "\"#{q.call(base || val).gsub(/(?<!\\)"/, '\\"')}\""
+          "\"#{val.gsub(/(?<!\\)"/, '\\"')}\""
         else
-          base ? val : "'#{q.call(val).gsub("'", "'\\\\''")}'"
+          "'#{val.gsub("'", "'\\\\''")}'"
         end
       end
 
       def shell_option(flag, val = nil, escape: true, quote: true, option: true, force: true, double: false,
                        merge: false, override: false)
         flag = flag.to_s
-        if flag =~ QUOTE_VALUE
+        if flag =~ /\A(["'])(.+)\1\z/
           double = $1 == '"'
           flag = $2
           escape = false
           override = true
         end
-        sep = unless flag.empty?
-                if flag[0] == '-'
-                  flag[1] == '-' ? '=' : ' '
-                elsif flag.size == 1
-                  pre = '-'
-                  merge ? '' : ' '
-                else
-                  pre = '--'
-                  '='
-                end
-              end
-        "#{pre}#{flag}#{unless val.nil?
-                          "#{sep}#{if escape
-                                     shell_escape(val, quote: quote, double: double, override: override)
-                                   elsif quote
-                                     shell_quote(val, option: option, force: force, double: double, override: override)
-                                   else
-                                     val
-                                   end}"
-                        end}"
+        if flag[0] == '-'
+          b = flag[1] == '-' ? '=' : ' '
+        elsif flag.size == 1
+          a = '-'
+          b = merge ? '' : ' '
+        else
+          a = '--'
+          b = '='
+        end
+        "#{a}#{flag}#{if val
+                        "#{b}#{if escape
+                                 shell_escape(val, quote: quote, double: double, override: override)
+                               elsif quote
+                                 shell_quote(val, option: option, force: force, double: double, override: override)
+                               else
+                                 val
+                               end}"
+                      end}"
       end
 
-      def shell_split(val, quote: false, force: false, join: nil)
-        ret = val.shellsplit.map! { |opt| shell_escape(opt, quote: quote, force: force, double: true, option: true) }
+      def shell_split(val, join: nil, **kwargs)
+        ret = val.shellsplit
+        ret.map! { |opt| shell_escape(opt, double: true, option: true, **kwargs) }
         return ret unless join
 
         ret.join(join.is_a?(::String) ? join : ' ')
       end
 
-      def shell_bin(name, env: true)
-        key = name.upcase
-        shell_quote((env && ENV["PATH_#{key}"]) || PATH[key] || PATH[key.to_sym] || name,
-                    option: false, force: false, double: true)
+      def line_width(lines)
+        ret = [lines.max_by(&:size).size, 80].max
+        [ret, Rake.application.terminal_width].min
       end
 
       def fill_option(val, **kwargs)
-        return val unless val.is_a?(::String)
         return "-#{val}" if val.match?(/\A(?:[a-z]\d*|\d)\z/i)
 
         shell_escape(val.start_with?('-') ? val : "--#{val}", **kwargs)
       end
 
-      def quote_option(flag, val, option: true, double: false, merge: false)
-        shell_option(flag, val, escape: false, option: option, double: double, merge: merge)
+      def quote_option(flag, val, **kwargs)
+        shell_option(flag, val, escape: false, **kwargs)
       end
 
-      def basic_option(flag, val, merge: false)
-        shell_option(flag, val, escape: false, force: false, merge: merge)
+      def basic_option(flag, val, **kwargs)
+        shell_option(flag, val, escape: false, force: false, **kwargs)
       end
     end
   end

data/lib/squared/common/system.rb

@@ -1,55 +1,49 @@
 # 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 = Kernel.system(*args, **kwargs)
+          return ret if ret || !exception
+
+          raise $?.to_s
         else
-          return Kernel.send(name, *args, **kwargs)
+          Kernel.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)
-        src = Pathname.new(src)
-        dest = Pathname.new(dest)
-        raise "#{dest.cleanpath} (not found)" if !create && !dest.parent.exist?
+      def copy_dir(src, dest, glob = ['**/*'], create: false, link: nil, force: false, pass: nil, hidden: false,
+                   verbose: true)
+        base = Pathname.new(src)
+        target = Pathname.new(dest)
+        raise "#{target.cleanpath} (not found)" if !create && !target.parent.exist?
 
         subdir = {}
-        dest.mkpath if create
+        target.mkpath if create
+        flags = hidden ? [File::FNM_DOTMATCH] : []
         if pass
           exclude = []
-          Array(pass).each { |val| exclude.concat(Dir.glob(src + val)) }
+          pass = [pass] unless pass.is_a?(::Array)
+          pass.each { |val| exclude.concat(Dir.glob(val, *flags, base: base)) }
         end
-        Array(glob).each do |val|
-          Dir.glob(src + val) do |path|
-            next if exclude&.include?(path) || (path = Pathname.new(path)).directory?
+        (glob.is_a?(::Enumerable) ? glob : [glob]).each do |val|
+          Dir.glob(val, *flags, base: base) do |file|
+            next if exclude&.include?(file) || (entry = base + file).directory?
 
-            dir = dest.join(path.relative_path_from(src)).dirname
+            dir = target.join(file).dirname
             if (data = subdir[dir.to_s])
-              data << path
+              data << entry
             else
               dir.mkpath
-              subdir[dir.to_s] = [path]
+              subdir[dir.to_s] = [entry]
             end
           end
         end
@@ -57,13 +51,14 @@ module Squared
         soft = 0
         subdir.each do |dir, files|
           if link
-            files.dup.tap do |items|
+            files.dup.yield_self do |items|
               files.clear
               items.each do |file|
                 if file.exist?
-                  if !file.symlink?
+                  if file.symlink?
+                    next unless force
+                  else
                     files << file
-                  elsif !force
                     next
                   end
                 end
@@ -81,15 +76,17 @@ module Squared
           out = FileUtils.cp(files, dir, verbose: false)
           count += out.size
         end
-        puts [dest.realpath, subdir.size, soft > 0 ? "#{count}+#{soft}" : count].join(' => ') if verbose
+        puts [target.realpath, subdir.size, soft > 0 ? "#{count}+#{soft}" : count].join(' => ') if verbose
       end
 
       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? }
+          target = Pathname.new(dest)
+          if target.directory?
+            src = [src] unless src.is_a?(::Enumerable)
+            src = src.reject { |val| target.join(File.basename(val)).exist? }
             return if src.empty?
-          elsif path.exist?
+          elsif target.exist?
             return
           end
         end