squared 0.6.9 → 0.7.0

data/lib/squared/common/format.rb

@@ -130,22 +130,19 @@ module Squared
       end
 
       def check_style(args, empty: true)
-        ret = []
         colors = __get__(:colors)
-        Array(args).flatten.compact.each do |val|
+        ret = Array(args).flatten.compact.each_with_object([]) do |val, out|
           if !val.is_a?(::Numeric)
             k = val.to_sym
-            ret << k if colors.key?(k) || colors.key?(k.to_s.sub('bright_', '').to_sym) || TEXT_STYLE.include?(k)
+            out << k if colors.key?(k) || colors.key?(k.to_s.sub('bright_', '').to_sym) || TEXT_STYLE.include?(k)
           elsif val.between?(0, 256)
-            ret << val
+            out << val
           elsif val < 0 && (b = val.to_s.split('.')[1])
             b = b[0, 3]
-            ret << "-0.#{b}".to_f unless b.to_i > 255
+            out << "-0.#{b}".to_f unless b.to_i > 255
           end
         end
-        return if ret.empty? && !empty
-
-        ret
+        ret unless ret.empty? && !empty
       end
 
       def apply_style(data, key, args, empty: true)
@@ -233,7 +230,7 @@ module Squared
               args.flatten.each { |val| f.write(val.chomp.stripstyle + br) }
             end
             return
-          rescue StandardError
+          rescue
             pipe = 2
           end
         end
@@ -290,7 +287,7 @@ module Squared
         end
         out << draw.call(b2, b3)
         if title
-          out.concat(title.map! { |t| pr.call(t) })
+          out.concat(title.map { |t| pr.call(t) })
           out << draw.call(b6, b7)
         end
         lines.each { |line| out << pr.call(line) }

data/lib/squared/common/prompt.rb

@@ -44,13 +44,13 @@ module Squared
             attempts -= 1
             exit 1 unless attempts > 0
           end
-        rescue Interrupt
-          puts
-          exit 0
-        else
-          exit 1 if force
-          false
         end
+      rescue Interrupt
+        puts
+        exit 0
+      else
+        exit 1 if force
+        false
       end
 
       def choice(msg, list = nil, min: 1, max: 1, multiple: false, index: false, grep: nil, border: nil, auto: true,
@@ -58,12 +58,11 @@ module Squared
         require 'timeout'
         if list
           grep &&= Array(grep).map { |val| Regexp.new(val) }
-          items = []
-          list.each do |val|
+          items = list.each_with_object([]) do |val, out|
             next if grep&.none? { |pat| pat.match?(line) }
 
-            items << val.to_s.chomp
-            puts '%2d. %s' % [items.size, val]
+            out << val.to_s.chomp
+            puts '%2d. %s' % [out.size, val]
           end
           max = items.size
           raise ArgumentError, 'empty selection list' if max == 0
@@ -84,12 +83,13 @@ module Squared
         between = ->(s) { s.match?(/^\d+$/) && s.to_i.between?(min, max) }
         Timeout.timeout(timeout) do
           while (ch = Readline.readline(msg))
-            unless (ch = ch.strip).empty?
+            ch.strip!
+            unless ch.empty?
               if multiple
                 k = if ch == '*'
                       (min..max).to_a
                     else
-                      ch.split(',').map! do |s|
+                      ch.split(',').flat_map do |s|
                         s.strip!
                         if s =~ /^(\d+)-(\d+)$/
                           next unless between.call($1) && between.call($2)
@@ -103,11 +103,10 @@ module Squared
                       end
                     end
                 unless k.include?(nil)
-                  k.flatten!
                   k.uniq!
                   k.sort!
                   unless multiple.is_a?(::Numeric) && multiple != k.size
-                    return index || !items ? k : k.map! { |i| items[i.pred] }
+                    return index || !items ? k : k.map { |i| items[i.pred] }
                   end
                 end
               elsif between.call(ch)
@@ -129,9 +128,7 @@ module Squared
       end
 
       def readline(msg, history = false, force: nil, multiline: nil, &blk)
-        multiline = if multiline && Readline.respond_to?(:readmultiline)
-                      multiline.is_a?(::Enumerable) || block_given? ? multiline : [multiline.to_s]
-                    end
+        multiline = nil unless Readline.respond_to?(:readmultiline)
         read = lambda do
           if !multiline
             Readline.readline(msg, history)
@@ -141,17 +138,19 @@ module Squared
             Readline.readmultiline(msg, history) do |line|
               next if line.strip.empty?
 
-              multiline.any? { |val| line.split.last.end_with?(val.to_s) }
+              Array(multiline).any? { |val| line.split.last.end_with?(val.to_s) }
             end
           end
         end
         case force
-        when ::TrueClass, ::FalseClass
-          msg = "#{msg}%s%s " % if multiline
-                                  [' ', multiline.is_a?(::Enumerable) ? "{#{multiline.to_a.join('|')}}" : multiline]
-                                else
-                                  [force ? ':' : '?', '']
-                                end
+        when true, false
+          msg = "#{msg}#{unless msg.match?(/[>:\]}$|]\z/)
+                           '%s%s' % if multiline.is_a?(::Enumerable)
+                                      [' ', "{#{multiline.to_a.join('|')}}"]
+                                    else
+                                      [multiline || (force ? ':' : '?'), '']
+                                    end
+                         end} "
           ret = (read.call || '').strip
           multiline.each { |val| break if ret.delete_suffix!(val.to_s) } if multiline.is_a?(::Enumerable)
           exit 1 if force && ret.empty?

data/lib/squared/common/shell.rb

@@ -10,26 +10,28 @@ module Squared
       private_constant :QUOTE_VALUE
 
       String.define_method(:stripquote) { sub(QUOTE_VALUE, '\2') }
-      Array.define_method(:quote!) { |**kwargs| map! { |s| Shell.shell_quote(s, **kwargs) } }
+      Array.define_method(:quote!) { |**kwargs| map { |s| Shell.shell_quote(s, **kwargs) } }
 
       module_function
 
       def shell_escape(val, quote: false, option: false, force: false, double: false, override: false)
-        if (r = /\A(--?)([^=\s]+)((=|\s+)(["'])?(?(5)(.*)\5|(.*)))?\z/m.match(val = val.to_s))
+        val = val.to_s
+        if (r = /\A(--?)([^=\s]+)((=|\s+)(["'])?(?(5)(.*)\5|(.*)))?\z/m.match(val))
           if (data = r[2].match(QUOTE_VALUE))
             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]}"
+          ch = r[7]
+          opt = if ch.start_with?('"', "'")
+                  "#{ch}#{ch[0]}"
+                elsif ch.end_with?('"', "'")
+                  "#{ch[-1]}#{ch}"
                 else
-                  return val unless r[7].match?(/\s/)
+                  return val unless ch.match?(/\s/)
 
-                  r[7]
+                  ch
                 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
@@ -44,10 +46,8 @@ module Squared
                        end
         elsif Rake::Win32.windows?
           quote ? shell_quote(val, force: force, double: double) : val
-        elsif val.empty?
-          ''
         else
-          Shellwords.escape(val)
+          val.empty? ? '' : Shellwords.escape(val)
         end
       end
 
@@ -108,7 +108,7 @@ module Squared
       end
 
       def shell_split(val, join: nil, **kwargs)
-        ret = val.shellsplit.map! { |opt| shell_escape(opt, option: true, double: true, **kwargs) }
+        ret = val.shellsplit.map { |opt| shell_escape(opt, option: true, double: true, **kwargs) }
         return ret unless join
 
         ret.join(join.is_a?(::String) ? join : ' ')
@@ -141,7 +141,7 @@ module Squared
               fill_option(item.first)
             else
               flag = item.shift
-              item.map! { |s| shell_option(flag, s, escape: escape, force: force, **kwargs) }
+              item.map { |s| shell_option(flag, s, escape: escape, force: force, **kwargs) }
             end
           end.concat(f)
         end
@@ -153,13 +153,12 @@ module Squared
         require_relative 'base'
         key = name.to_s.upcase
         key = File.basename(key, '.*') if Rake::Win32.windows?
-        shell_quote((env && ENV["PATH_#{key}"]) || PATH[key] || PATH[key.to_sym] || name,
-                    option: false, force: false, double: true)
+        shell_quote((env && ENV["PATH_#{key}"]) || PATH[key] || PATH[key.to_sym] || PATH[key = key.downcase] ||
+                    PATH[key.to_sym] || name, option: false, force: false, double: true)
       end
 
       def line_width(lines)
-        ret = [lines.empty? ? 0 : lines.max_by(&:size).size, 80].max
-        [ret, Rake.application.terminal_width].min
+        [lines.empty? ? 80 : [lines.max_by(&:size).size, 80].max, Rake.application.terminal_width].min
       end
 
       def fill_option(val, **kwargs)

data/lib/squared/common/system.rb

@@ -2,6 +2,7 @@
 
 require 'pathname'
 require 'rake'
+require 'timeout'
 
 module Squared
   module Common
@@ -11,7 +12,7 @@ module Squared
 
         def parse_link(val)
           case val
-          when ::TrueClass, 's'
+          when 's', true
             1
           when 'r'
             2
@@ -29,23 +30,34 @@ module Squared
 
       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)
+          ex = kwargs[:exception]
+          if (dir = kwargs[:chdir]) && Dir.pwd != dir
+            pwd = Dir.pwd
+            Dir.chdir(dir)
           end
+          ret = Kernel.send(name, *args)
+          Dir.chdir(pwd) if pwd
         elsif RUBY_VERSION < '2.6'
-          e = kwargs.delete(:exception)
+          ex = kwargs.delete(:exception)
           ret = Kernel.send(name, *args, **kwargs)
         else
           return Kernel.send(name, *args, **kwargs)
         end
-        return ret unless e && !ret && name == :system
+        raise $?.to_s if !ret && ex && name == :system
 
-        raise $?.to_s
+        ret
+      end
+
+      def shell_t(*args, timeout: 0, **kwargs)
+        return shell(*args, **kwargs) unless timeout > 0
+
+        begin
+          Timeout.timeout(timeout) do
+            shell(*args, **kwargs)
+          end
+        rescue Interrupt
+          exit 1
+        end
       end
 
       def copy_dir(src, dest, glob = ['**/*'], create: false, link: nil, preserve: nil, force: false, verbose: true,
@@ -57,10 +69,7 @@ module Squared
         subdir = {}
         target.mkpath if create
         flags = hidden ? [File::FNM_DOTMATCH] : []
-        if pass
-          exclude = []
-          Array(pass).each { |val| exclude.concat(Dir.glob(val, *flags, base: base)) }
-        end
+        exclude = Array(pass).each_with_object([]) { |val, out| out.concat(Dir.glob(val, *flags, base: base)) } if pass
         Array(glob).each do |val|
           Dir.glob(val, *flags, base: base) do |file|
             next if exclude&.include?(file) || (entry = base + file).directory?
@@ -109,22 +118,22 @@ module Squared
       end
 
       def copy_guard(*src, dest, base: '.', create: false, link: nil, preserve: nil, force: false, verbose: true)
-        src = src.compact.flatten
+        target = src.compact.flatten
         dest = Pathname.new(dest).realdirpath
         base = Pathname.new(base).realpath
         dir = if dest.directory?
                 true
-              elsif src.size > 1
+              elsif target.size > 1
                 raise Errno::ENOENT, dest.cleanpath.to_s unless create && !dest.exist?
 
                 dest.mkpath
                 true
               end
-        targets = src.map! { |file| [base + file, dir ? dest + File.basename(file) : dest] }
-        return if !force && (targets = targets.reject { |to| to[1].exist? }).empty?
+        target.map! { |file| [base + file, dir ? dest + File.basename(file) : dest] }
+        return if !force && (target = target.reject { |to| to[1].exist? }).empty?
 
         type = System.send :parse_link, link
-        targets.each do |file, to|
+        target.each do |file, to|
           case type
           when 0
             FileUtils.cp(file, to, preserve: preserve, verbose: verbose)

data/lib/squared/common/utils.rb

@@ -7,6 +7,35 @@ require 'time'
 module Squared
   module Common
     module Utils
+      private
+
+      def env_value(key, default = '', name: @envname, suffix: nil, strict: false)
+        if suffix
+          if (ret = ENV[[key, name, suffix].compact.join('_')])
+            return ret
+          elsif strict
+            return default
+          end
+        end
+        if name
+          return ret if (ret = ENV["#{key}_#{name}"])
+          return default if strict
+        end
+        ENV.fetch(key, default)
+      end
+
+      def env_yield(ret, default, equals: nil, notequals: nil, ignore: nil)
+        if !notequals.nil?
+          ret = Array(notequals).none? { |val| ret == val.to_s }
+        elsif !equals.nil?
+          ret = Array(equals).any? { |val| ret == val.to_s }
+        else
+          ret = default if ret.empty? || (ignore && Array(ignore).any? { |val| ret == val.to_s })
+          return if ret.nil?
+        end
+        block_given? ? yield(ret) : ret
+      end
+
       module_function
 
       def as_a(obj, *meth, flat: nil, compact: false, &blk)
@@ -29,29 +58,16 @@ module Squared
         obj.select(&blk)
       end
 
-      def split_escape(val, char: ',', &blk)
-        ret = val.split(/\s*(?<!\\)#{char}\s*/)
+      def split_escape(val, char: ',', limit: 0, &blk)
+        ret = val.split(/(?<!\\)#{char}/, limit).map(&:strip)
         return ret unless block_given?
 
-        ret.each(&blk)
-      end
-
-      def split_option(val)
-        val = val.strip
-        return [val, '', ''] unless (i = val.index('='))
-
-        last = val[i.succ..-1].strip
-        quote = ''
-        if last =~ /\A(["'])(.+)\1\z/
-          last = $2
-          quote = $1
-        end
-        [val[0..i.pred], last, quote]
+        ret.each_with_index(&blk)
       end
 
       def task_invoke(*cmd, args: [], exception: true, warning: true)
         cmd.each { |name| Rake::Task[name].invoke(*args) }
-      rescue StandardError => e
+      rescue => e
         raise if exception
 
         warn e if warning
@@ -119,47 +135,20 @@ module Squared
         val.utc.strftime(ms ? '%s%L' : '%s').to_i
       end
 
-      def rand_s(size)
-        if RUBY_VERSION >= '3.1'
-          require 'random/formatter'
-          Random.new.alphanumeric(size)
-        else
-          (0...size).map { rand(97..122).chr }.join
-        end
-      end
-
-      def env(key, default = nil, suffix: nil, strict: false, equals: nil, ignore: nil, **)
-        ret = env_value(key, suffix: suffix, strict: strict)
-        return Array(equals).any? { |val| val.to_s == ret } unless equals.nil?
-
-        ret.empty? || (ignore && Array(ignore).any? { |val| val.to_s == ret }) ? default : ret
+      def env(key, default = nil, equals: nil, notequals: nil, ignore: nil, **kwargs, &blk)
+        env_yield(env_value(key, **kwargs), default, equals: equals, notequals: notequals, ignore: ignore, &blk)
       end
 
       def env_key(*val)
         val.join('_').gsub(/\W+/, '_').upcase
       end
 
-      def env_value(key, default = '', suffix: nil, strict: false)
-        if suffix
-          if (ret = ENV["#{key + (@envname ? "_#{@envname}" : '')}_#{suffix}"])
-            return ret
-          elsif strict
-            return default
-          end
-        end
-        if @envname
-          return ret if (ret = ENV["#{key}_#{@envname}"])
-          return default if strict
-        end
-        ENV.fetch(key, default)
-      end
-
-      def env_bool(key, default = false, suffix: nil, strict: false, index: false)
+      def env_bool(key, default = false, index: false, **kwargs)
         case key
-        when ::NilClass
+        when nil
           default
         when ::String
-          case (val = env_value(key, suffix: suffix, strict: strict))
+          case (val = env_value(key, **kwargs))
           when ''
             default
           when '0', 'false'
@@ -172,10 +161,10 @@ module Squared
         end
       end
 
-      def env_pipe(key, default = 1, suffix: nil, strict: false, root: nil)
+      def env_pipe(key, default = 1, root: nil, **kwargs)
         case key
         when ::String
-          case (ret = env_value(key, suffix: suffix, strict: strict))
+          case (ret = env_value(key, **kwargs))
           when '0', '1', '2'
             return ret.to_i
           end
@@ -186,14 +175,14 @@ module Squared
 
         begin
           (root ? Pathname.new(root) + default : Pathname.new(default)).realdirpath
-        rescue StandardError => e
+        rescue => e
           warn e
           1
         end
       end
 
-      def env_match(key, default = nil, suffix: nil, strict: false, options: 0, timeout: nil)
-        case (val = env_value(key, suffix: suffix, strict: strict))
+      def env_match(key, default = nil, options: 0, timeout: nil, **kwargs)
+        case (val = env_value(key, **kwargs))
         when ''
           default
         when '0'

data/lib/squared/config.rb

@@ -14,9 +14,9 @@ module Squared
       class << self
         def parse(gem, namespace, ext = [gem])
           require gem
-          [eval(namespace), Array(ext)].tap do |data|
-            data.last.each { |key| @@mime_obj[key] = data }
-          end
+          ret = [eval(namespace), Array(ext)]
+          ret.last.each { |key| @@mime_obj[key] = ret }
+          ret
         rescue LoadError, NameError => e
           warn e
           nil
@@ -42,13 +42,15 @@ module Squared
 
       def initialize(main, name = nil, project: nil, command: nil, opts: {}, auto: true,
                      common: ARG[:COMMON], pipe: ARG[:PIPE], **kwargs)
-        if project && (project.respond_to?(:workspace) || (project = __get__(:project)[project.to_s]))
-          main = project.basepath(main).to_s
-          @project = project
-          @envname = project.instance_variable_get(:@envname)
-          @required = true
-        end
-        @name = name || @project&.name
+        @name = if project && (project.respond_to?(:workspace) || (project = __get__(:project)[project.to_s]))
+                  main = project.basepath(main).to_s
+                  @project = project
+                  @envname = project.__send__(:envname_get)
+                  @required = true
+                  project.name
+                else
+                  name
+                end
         @prefix = kwargs[:prefix] unless @project
         @ext = File.extname(main)
         @dump = kwargs[:dump]
@@ -185,7 +187,7 @@ module Squared
       def to_s
         realpath if target?
 
-        @mime.keys.map! { |ext| "#{main}.#{ext}" }.join(',')
+        @mime.keys.map { |ext| "#{main}.#{ext}" }.join(',')
       end
 
       def inspect
@@ -251,10 +253,9 @@ module Squared
       end
 
       def print_keys(type, data, keys, file: nil, opts: {})
-        out = []
         pad = 0
         symbolize = opts[:symbolize_names]
-        keys.each do |key|
+        values = keys.each_with_object([]) do |key, out|
           begin
             items = key.split('.').flat_map { |name| name =~ /^(.+)\[(\d+)\]$/ ? [$1, $2.to_i] : name }
             items = items.map(&:to_sym) if symbolize
@@ -267,7 +268,7 @@ module Squared
                 val = val[name]
               end
             end
-          rescue StandardError
+          rescue
             log&.warn "#{Viewer}(#{type}) => #{"#{file} " if file}{#{key}: undefined}"
             val = Regexp.escape($!.message)
             key = key.sub(/(#{val})\.|\.(#{val})|(#{val})/) do
@@ -285,9 +286,9 @@ module Squared
           pad = [pad, key.size].max
         end
         if stdin?
-          puts out.map!(&:last).join("\n")
+          puts values.map(&:last).join("\n")
         else
-          out.map! { |a, b| '%-*s : %s' % [pad, a, b] }
+          values.map { |a, b| '%-*s : %s' % [pad, a, b] }
         end
       end
 

data/lib/squared/version.rb

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