squared 0.8.8 → 0.9.0.pre1

data/exe/sqd

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$:.unshift(File.expand_path('../lib', __dir__)) if File.exist?(File.expand_path('../squared.gemspec', __dir__))
+
+require 'squared'
+require 'rake'
+require 'optparse'
+
+class SqdParser < OptionParser
+  include Squared::Common::Format
+  include Utils
+
+  attr_reader :options, :global
+
+  def initialize(*)
+    super
+    @options = { 'project-args': [], 'project-env': [] }
+    @global = []
+    @program_name = 'squared'
+    @raise_unknown = false
+    @require_exact = true
+  end
+
+  def parse_global(list, assert:)
+    raise ArgumentError, "cannot be used with --#{assert}" if options.key?(assert)
+
+    ARGV.each_with_index do |val, index|
+      if val == '--'
+        separator!(index: index)
+        break
+      end
+      next if val.start_with?('-') || val.include?(':') || val.empty?
+
+      global.concat(list.map { |name| "#{val}:#{name}" })
+      ARGV[index] = ''
+    end
+  end
+
+  def parse_common(list, session:, arg:)
+    if list && !list.include?('*')
+      session[arg].merge!(list.to_h { |key| [key, 'true'] })
+    else
+      session[arg] = Hash.new('true')
+    end
+  end
+
+  def banner_set(val, session:)
+    session[:BANNER] = val
+    ENV['BANNER'] = val ? 'true' : 'false'
+  end
+
+  def color_set(val, session:)
+    if (session[:COLOR] = val)
+      enable_aixterm
+      enable_drawing
+    else
+      enable_drawing false
+      Squared::Common.const_get(:VAR)[:colors].freeze
+    end
+    ENV['NO_COLOR'] = val ? nil : '1'
+    ENV['FORCE_COLOR'] = val ? '2' : '0'
+  end
+
+  def run
+    parse!(into: options)
+    if (project = options[:project])
+      pattern, project = project.partition do |val|
+        next true if val == '*'
+
+        val = ".#{val}" if val.start_with?('*')
+        val.match?(/[*+\[(]|(?<!\\)\.\.|\{\d+\}/) && Regexp.new(val)
+      rescue RegexpError
+        false
+      end
+      pattern.each do |val|
+        val = if val == '*'
+                '[^:]+'
+              else
+                val.sub(/^\*/, '.*')
+                   .sub(/(?<!\.)\*$/, '.*')
+                   .gsub(/\.([*+])/, '[^:]\1?')
+              end
+        IO.popen("rake -T \"^#{val}:\"").each { |line| project << $1 if line =~ /\Arake (#{val}):/o }
+      end
+      exit 1 if project.empty? && !pattern.empty?
+      project.uniq!
+      options[:'project-env'].each do |val|
+        n = val.index('=')
+        key = val[...n]
+        val = val[n.succ..].stripquote
+        project.each { |name| ENV["#{key}_#{env_key(name.split(':').first)}"] = val }
+      end
+      ARGV.each_with_index do |val, index|
+        if val == '--'
+          separator!(index: index)
+          break
+        end
+        next unless val.start_with?(':')
+
+        args = options[:'project-args'].shift
+        global.concat(project.map { |name| "#{name}#{val}#{"[#{args}]" if args}" })
+        ARGV[index] = ''
+      end
+    end
+    ARGV.reject!(&:empty?)
+    Rake.application.run(global.concat(ARGV))
+  end
+
+  def separator!(index:)
+    ARGV[index] = '' if ARGV.grep('--').size > 1
+  end
+
+  def error_exit(*val, hint)
+    raise OptionParser::InvalidArgument, message(*val, hint: hint)
+  end
+end
+
+SqdParser.new do |sqd|
+  session = Squared::Common::ARG
+  sqd.banner = 'Usage: sqd [options] [rake options] [global...] [:targets...] -- [rake targets...]'
+  sqd.separator ''
+  sqd.on('-R', '--ref STR,STR', Array, 'Run global commands by class reference') do |val|
+    sqd.parse_global(val, assert: :group)
+    session[:APP][:series_ref_min] = 1
+  end
+  sqd.on('-G', '--group STR,STR', Array, 'Run global commands by project group') do |val|
+    sqd.parse_global(val, assert: :ref)
+  end
+  sqd.separator ''
+  sqd.on('-P', '--project STR,PAT', Array, 'Run project commands with common arguments')
+  sqd.on('-a', '--project-args STR,STR', 'Provide command arguments for :targets (multiple)') do |val|
+    sqd.options[:'project-args'] << val
+  end
+  sqd.on('-e', '--project-env KEY=STR', 'Provide command ENV variables for :targets (multiple)') do |val|
+    sqd.error_exit('missing value', "#{val}=") unless val.include?('=')
+
+    sqd.options[:'project-env'] << val
+  end
+  sqd.separator ''
+  sqd.on('-s', '--[no-]strict', 'Do not run commands with invalid arguments') do |val|
+    session[:STRICT] = val
+    ENV['STRICT'] = val ? 'true' : 'false'
+  end
+  sqd.on('--update', 'Use update strategy for applicable commands') do
+    ENV['UPDATE'] = 'true'
+  end
+  sqd.on('-F', '--force [STR,STR]', Array, 'Enable force through ENV by application') do |val|
+    sqd.parse_common(val, session: session, arg: :FORCE)
+  end
+  sqd.on('-y', '--yes [STR,STR]', Array, 'Enable auto-approve through ENV by application') do |val|
+    sqd.parse_common(val, session: session, arg: :YES)
+  end
+  sqd.on('-d', '--dry-run', 'Run commands without any modifying actions') do
+    ENV['DRY_RUN'] = 'true'
+  end
+  sqd.separator ''
+  sqd.on('-S', '--select PAGE:CHOICE', 'Prompt menu selection pagination limits') do |val|
+    page, choice = val.split(/\D/, 2).map(&:to_i)
+    sqd.error_exit('not an integer', val) if choice.nil? ? page == 0 : choice == 0
+
+    session[:PAGE] = page if page > 0
+    session[:CHOICE] = choice if choice.to_i > 0
+    ENV['SELECT'] = "#{page}:#{choice}"
+  end
+  sqd.separator ''
+  sqd.on('-p', '--pipe 0|1|2', Integer, 'Set file descriptor for communication') do |val|
+    sqd.error_exit('out of range', val) unless val.between?(0, 2)
+
+    session[:PIPE] = val
+  end
+  sqd.on('-o', '--pipe-out FILE', 'Write command data stream to a file') do |val|
+    sqd.error_exit("missing an explicit \".#{File::SEPARATOR}\"", val) unless val.include?(File::SEPARATOR)
+
+    session[:OUT] = val
+  end
+  sqd.on('--fail 0..4', Integer, 'Set application exception level') do |val|
+    sqd.error_exit('out of range', val) unless val.between?(0, 4)
+
+    session[:FAIL] = val
+  end
+  %i[debug info warn error fatal].then do |state|
+    values = state + (0..4).map(&:to_s)
+    sqd.on('--log-level SEVERITY', values, "Set logger and exception state (#{state.join(', ')})") do |val|
+      require 'logger'
+      severity = case val
+                 when :debug then Logger::DEBUG
+                 when :info then Logger::INFO
+                 when :warn then Logger::WARN
+                 when :error then Logger::ERROR
+                 when :fatal then Logger::FATAL
+                 else
+                   val.to_i
+                 end
+      session[:LEVEL] = severity
+      ENV['LOG_LEVEL'] = severity.to_s
+    end
+  end
+  sqd.separator ''
+  sqd.on('--[no-]banner', 'Display executing command attributes') do |val|
+    sqd.banner_set(val, session: session)
+  end
+  sqd.on('-x', '--[no-]color', 'Use enhanced styling for terminal output') do |val|
+    sqd.color_set(val, session: session)
+  end
+  sqd.on('-X', '--plain', 'Disable banner and styling for all commands') do
+    sqd.banner_set(false, session: session)
+    sqd.color_set(false, session: session)
+  end
+  sqd.on('-v', '--verbose', 'Increase output verbosity (multiple)') do
+    unless session[:VERBOSE]
+      session[:VERBOSE] = $VERBOSE ? 1 : 0
+      sqd.global.unshift('--verbose')
+    end
+    ENV['VERBOSE'] = (session[:VERBOSE] += 1).to_s
+  end
+  sqd.on('--version', 'Print the current version') do
+    puts Squared::VERSION
+    exit 0
+  end
+  sqd.on('-h', '--help', 'Print the command line options') do
+    sqd.help_exit
+  end
+end.run

data/lib/squared/common/base.rb

@@ -11,14 +11,17 @@ module Squared
       COMMON: true,
       VERBOSE: nil,
       STRICT: false,
+      FORCE: {},
+      YES: {},
+      APP: {},
       BANNER: true,
-      CHOICE: 25,
-      TAB: 4,
+      PAGE: 20,
+      CHOICE: 100,
       QUOTE: "'",
       SPACE: ' => ',
       SUCCESS: 'Success',
-      GRAPH: %w[| - | \\ -].freeze,
-      BORDER: %w[| - - - - - | | - -].freeze,
+      GRAPH: %w[| - | \\ -],
+      BORDER: %w[| - - - - - | | - -],
       VIEW: 'view',
       LEVEL: ENV.fetch('LOG_LEVEL', 0).to_i,
       COLOR: ENV.fetch('NO_COLOR', '').empty?
@@ -102,7 +105,6 @@ module Squared
 
     def __freeze__
       PATH.freeze
-      ARG.each_value { |val| val.freeze if val.is_a?(::Hash) || val.is_a?(::Array) }
       ARG.freeze
       VAR.each_value(&:freeze)
       VAR[:theme].each_value { |val| val.freeze.each_value(&:freeze) }

data/lib/squared/common/format.rb

@@ -50,9 +50,14 @@ module Squared
         self
       end
 
-      def enable_drawing
-        ARG[:GRAPH] = BOX_GRAPH
-        ARG[:BORDER] = BOX_BORDER
+      def enable_drawing(state = true)
+        if state
+          ARG[:GRAPH] = BOX_GRAPH unless ARG[:GRAPH].frozen?
+          ARG[:BORDER] = BOX_BORDER unless ARG[:BORDER].frozen?
+        else
+          ARG[:GRAPH].freeze
+          ARG[:BORDER].freeze
+        end
         self
       end
 
@@ -296,7 +301,7 @@ module Squared
         if footer
           unless sub.empty? && !right
             footer.map! do |s|
-              s = s.rjust(n + ARG[:TAB]) if right
+              s = s.rjust(n + 4) if right
               sub.each { |h| sub_style!(s, **h) }
               s
             end

data/lib/squared/common/prompt.rb

@@ -1,27 +1,21 @@
 # frozen_string_literal: true
 
+require 'timeout'
+
 module Squared
   module Common
     module Prompt
       def self.reline
-        if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.7'
-          require 'readline'
-          Readline
-        else
-          begin
-            require 'reline'
-            Reline
-          rescue LoadError
-            require 'readline'
-            Readline
-          end
-        end
+        require 'reline'
+        Reline
+      rescue LoadError
+        require 'readline'
+        Readline
       end
 
       module_function
 
       def confirm(msg, accept = nil, agree: 'Y', cancel: 'N', force: false, attempts: 3, timeout: 60)
-        require 'timeout'
         if agree == 'Y' && cancel == 'N' && !msg.match?(%r{\[(Yn|nY|Y/n|y/N)\]})
           case accept
           when 'Y'
@@ -34,7 +28,7 @@ module Squared
         cancel = /^#{Regexp.escape(cancel)}$/i if cancel.is_a?(::String)
         Timeout.timeout(timeout) do
           while (ch = Prompt.reline.readline(msg))
-            ch = ch.chomp
+            ch.chomp!
             case (ch.empty? ? accept : ch)
             when agree
               return true
@@ -54,9 +48,9 @@ module Squared
         false
       end
 
-      def choice(msg, list = nil, min: 1, max: 1, multiple: false, index: false, grep: nil, border: nil, auto: true,
-                 force: true, attempts: 3, timeout: 0, empty: nil)
-        require 'timeout'
+      def choice(msg, list = nil, min: 1, max: nil, multiple: false, index: false, grep: nil, border: nil, force: true,
+                 attempts: 3, timeout: 0, pipe: 1, scroll: true, empty: nil, page: 25)
+        std = pipe == 2 ? $stderr : $stdout
         multiple = Array(multiple) if multiple.is_a?(::Numeric)
         if list
           grep &&= Array(grep).map { |val| Regexp.new(val) }
@@ -64,36 +58,71 @@ module Squared
             next if grep&.none? { |pat| pat.match?(val) }
 
             out << val.to_s.chomp
-            puts '%2d. %s' % [out.size, val]
           end
-          max = items.size
+          max = max ? [max, items.size].min : items.size
           if max == 0
             raise ArgumentError, 'empty selection list' unless empty
 
             puts empty
             exit 1
           end
+          tmpl = "%#{[items.size.to_s.size, 2].max}d. %s"
+          items = items.map.with_index { |item, i| [item, tmpl % [i.succ, item]] }
           min = grep ? 1 : [min, max].min
-          if auto
-            auto.times { puts } if auto.is_a?(::Numeric)
+          require 'io/console'
+          if min > 1 || max < items.size
+            items = items[min.pred...max]
+            min = 1
+          end
+          page = page ? [page, max].min : max
+          cur = 0
+          line = 0
+          last = (max / page.to_f).ceil
+          pre = msg
+          scroll = true if border
+          clear = -> { std.print "\r\e[K" }
+          write = lambda do |s, buf = true|
+            line += [s.lines.size, 1].max if buf
+            clear.call unless scroll && !border
+            std.puts s
+          end
+          render = lambda do |index, init = false|
+            fr = index * page
+            to = [fr + page, max].min
+            unless init
+              std.cursor_up((scroll ? 0 : page) + line.succ)
+              clear.call
+            end
+            line = 0
+            items[fr...to].each { |item| write.call(item.last, false) }
             if border == true
-              puts print_footer
+              write.call(print_footer)
             elsif border
-              puts print_footer(border: border)
+              write.call(print_footer(border: border))
+            end
+            fr = scroll ? 1 : fr.succ
+            suf = "|,#{multiple.is_a?(::Array) ? "{#{multiple.join(',')}}" : '*'}" if multiple
+            msg = "#{pre + (force ? ':' : '?')} [#{fr}-#{to}#{"/#{max}" if scroll && to < max}#{suf}] "
+            if cur == last.pred
+              cur = -1
+              last = 0 if scroll || (attempts -= 1) == 0
+            end
+            if init && last > 1 && !scroll
+              write.call('', false)
+              std.cursor_up(1)
             end
-            msg = "#{msg + (force ? ':' : '?')} [#{min}-#{max}#{if (n = multiple)
-                                                                  "|,#{n.is_a?(::Array) ? "{#{n.join(',')}}" : '*'}"
-                                                                end}] "
           end
+          render.call(0, true)
+        else
+          max ||= 1
+          last = 0
         end
         between = ->(s) { s.match?(/^\d+$/) && s.to_i.between?(min, max <= min ? Float::INFINITY : max) }
         Timeout.timeout(timeout) do
           while (ch = Prompt.reline.readline(msg))
             ch.strip!
-            unless ch.empty?
-              if ch == '-' && !force
-                break
-              elsif multiple
+            if !ch.empty?
+              if multiple
                 k = if ch == '*'
                       (min..max).to_a
                     else
@@ -114,12 +143,15 @@ module Squared
                   k.uniq!
                   k.sort!
                   unless multiple.is_a?(::Array) && !multiple.include?(k.size)
-                    return index || !items ? k : k.map { |i| items[i.pred] }
+                    return index || !items ? k : k.map { |i| items[i.pred].first }
                   end
                 end
               elsif between.call(ch)
-                return index || !items ? ch.to_i : items[ch.to_i.pred]
+                return index || !items ? ch.to_i : items[ch.to_i.pred].first
               end
+            elsif last > 0
+              render.call(cur += 1)
+              next
             end
             attempts -= 1
             next if attempts > 0
@@ -128,7 +160,7 @@ module Squared
             break
           end
         rescue Interrupt
-          puts
+          std.puts
           exit 0
         else
           [] if multiple

data/lib/squared/common/shell.rb

@@ -167,7 +167,9 @@ module Squared
       end
 
       def line_width(lines)
-        [lines.empty? ? 80 : [lines.max_by(&:size).size, 80].max, Rake.application.terminal_width].min
+        require 'io/console/size'
+        cols = IO.default_console_size.last
+        [lines.empty? ? cols : [lines.max_by(&:size).size, cols].max, Rake.application.terminal_width].min
       end
 
       def fill_option(val, **kwargs)

data/lib/squared/common/system.rb

@@ -28,15 +28,8 @@ module Squared
       module_function
 
       def shell(*args, name: :system, **kwargs)
-        if name != :system
-          kwargs.delete(:exception)
-        elsif RUBY_VERSION < '2.6'
-          ex = kwargs.delete(:exception)
-        end
-        ret = Kernel.send(name, *args, **kwargs)
-        raise $?.to_s if ex && !ret
-
-        ret
+        kwargs.delete(:exception) unless name == :system
+        Kernel.send(name, *args, **kwargs)
       end
 
       def shell_t(*args, timeout: 0, **kwargs)

data/lib/squared/config.rb

@@ -65,7 +65,7 @@ module Squared
               command = File.basename(@main)
               command = ARG[:VIEW] if command == @name
             end
-            ext = @ext[1..-1].downcase
+            ext = @ext[1..].downcase
             if (data = @@mime_obj[ext])
               add(data[1].first, command: command, opts: opts, ext: data[1])
             else
@@ -98,7 +98,7 @@ module Squared
         namespace task_name(name) do |ns|
           @mime.each do |type, items|
             items.each do |command, file, opts|
-              next if Rake::Task.task_defined?("#{ns.scope.path}:#{command}:#{type}")
+              next if Rake::Task.task_defined?(task_join(ns.scope.path, command, type))
 
               namespace command do
                 unless (data = @@mime_obj[type])
@@ -288,7 +288,7 @@ module Squared
         if project
           project.workspace.task_name(val)
         else
-          @prefix ? "#{@prefix}:#{val}" : val.to_s
+          @prefix ? task_join(@prefix, val) : val.to_s
         end
       end
 

data/lib/squared/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Squared
-  VERSION = '0.8.8'
+  VERSION = '0.9.0.pre1'
 end