squared 0.4.15 → 0.4.17

data/lib/squared/workspace/project/ruby.rb

@@ -91,7 +91,7 @@ module Squared
           'irb' => nil
         })
 
-        def initialize(*, autodetect: false, **kwargs)
+        def initialize(*, autodetect: false, gemspec: nil, **kwargs)
           super
           if @pass.include?(Ruby.ref)
             initialize_ref Ruby.ref
@@ -102,7 +102,8 @@ module Squared
           end
           dependfile_set GEMFILE
           @autodetect = autodetect
-          return if !@output[0].nil? || !@copy.nil? || @version || @autodetect || rakefile.empty?
+          @gemfile = path + gemspec if gemspec
+          return if !@output[0].nil? || !@copy.nil? || version || @autodetect || !rakefile
 
           begin
             File.foreach(rakefile) do |line|
@@ -125,16 +126,16 @@ module Squared
 
         def populate(*, **)
           super
-          return unless outdated? && ref?(Ruby.ref)
+          return unless (outdated? && ref?(Ruby.ref)) || @only
 
           namespace name do
             Ruby.subtasks do |action, flags|
-              next if @pass.include?(action)
+              next if task_pass?(action)
 
               if flags.nil?
                 case action
                 when 'rake'
-                  next if rakefile.empty?
+                  next unless rakefile
 
                   format_desc action, nil, "task+,opts*|#{indexchar}index+|#,pattern*"
                   task action, [:command] do |_, args|
@@ -167,13 +168,11 @@ module Squared
                     end
                   end
                 when 'irb'
-                  next unless (spec = basepath("#{project}.gemspec") || basepath("#{name}.gemspec"))
-                  next unless basepath('lib').join("#{gemname = stripext(spec)}.rb").exist?
-
                   format_desc action, nil, 'opts*,args*|:'
                   task action do |_, args|
                     args = args.to_a
-                    irb(gemname, args, args: (readline('Enter file [arguments]', force: false) if args.delete(':')))
+                    name = gemlib.any? { |file| basepath(file).join("#{gemname}.rb").exist? } ? gemname : nil
+                    irb(name, args, args: (readline('Enter file [arguments]', force: false) if args.delete(':')))
                   end
                 else
                   format_desc(action, nil, 'opts*', before: case action
@@ -276,7 +275,7 @@ module Squared
           end
         end
 
-        def copy(from: 'lib', into: @gemdir, override: false, **kwargs)
+        def copy(from: gemlib, into: @gemdir, override: false, **kwargs)
           glob = kwargs[:include]
           pass = kwargs[:exclude]
           if @copy && !override
@@ -303,9 +302,7 @@ module Squared
             begin
               copy_dir(a, b, c, pass: pass, verbose: verbose)
             rescue StandardError => e
-              log.error e
-              ret = on(:error, :copy, e)
-              raise if exception && ret != true
+              on_error e, :copy
             end
           end
           on :last, :copy
@@ -445,11 +442,11 @@ module Squared
           when :file, :script
             op = OptionPartition.new(opts, OPT_RUBY[:ruby], ruby_session, project: self, args: true)
             if file
-              op.extras.unshift(shell_quote(path + file))
+              op.unshift(shell_quote(path + file))
             elsif command
               op << quote_option('e', command, option: false)
             end
-            op.extras << args if (args = ENV.fetch('RUBY_ARGS', args))
+            op.push(args) if (args = ENV.fetch('RUBY_ARGS', args))
             op.append(delim: true, escape: false, quote: false) unless op.empty?
           when :version
             pwd_set do
@@ -568,7 +565,7 @@ module Squared
             minor = 0
             patch = 0
             update = []
-            pwd_set(pass: !pwd.nil?, from: from) do
+            pwd_set(pass: !gempwd.nil?, from: from) do
               items = [[%w[Gem Current Latest], nil]]
               IO.popen(cmd.done).each do |line|
                 if line =~ /^(\S+) \((\S+) < ([^)]+)\)$/
@@ -689,36 +686,43 @@ module Squared
             return
           when :build
             if op.empty?
-              spec = [path + "#{project}.gemspec", path + "#{name}.gemspec", *Dir.glob(path + '*.gemspec')]
-              op << File.basename(spec) if (spec = spec.find { |file| File.exist?(file) })
+              op.add_path(gemfile)
             else
-              op << shell_quote(path + op.shift)
-              op.clear(pass: false)
+              op.add_path(op.shift)
+                .clear(pass: false)
             end
           when :push
             if op.empty?
-              op << shell_quote(path + choice_index('Select a file', Dir.glob('*.gem', base: path), force: true))
+              file = path + (if (spec = gemspec)
+                               "#{spec.name}-#{spec.version}.gem"
+                             else
+                               choice_index('Select a file', Dir.glob('*.gem', base: path), force: true)
+                             end)
             else
               file = path + op.shift
+              raise_error('gem not found', hint: file) unless file.exist?
               raise_error("unknown args: #{op.join(', ')}", hint: flag) unless op.empty?
-              if file.exist?
-                op << shell_quote(file)
-              else
-                raise_error('gem not found', hint: file)
-              end
             end
-            run_rb(from: from, interactive: "Push #{sub_style(project, styles: theme[:active])}")
+            op.add_path(file)
+            run_rb(from: from, interactive: "Push #{sub_style(gemname, styles: theme[:active])}")
             return
           when :exec
-            raise_error('missing command', hint: flag) if op.empty?
-            op << basic_option('gem', project) unless op.arg?('g', 'gem')
-            if (args = command_args(op.extras))
+            min = if op.arg?('g', 'gem')
+                    1
+                  elsif op.empty?
+                    op << basic_option('gem', gemname)
+                    1
+                  else
+                    op << op.shift
+                    0
+                  end
+            if (args = command_args(op.extras, min: min, force: min == 1 && op.empty?))
               op.push(args)
             end
-            op.append(delim: true, quote: false)
+            op.append(quote: false)
           when :update
             unless op.arg?('system')
-              op.push(project) if op.empty?
+              op.push(gemname) if op.empty?
               op.adjoin
             end
             op.clear(errors: true)
@@ -726,7 +730,7 @@ module Squared
             raise_error('missing gemname', hint: flag) if op.empty?
             case flag
             when :install, :uninstall, :pristine
-              post = readline('Enter command [args]', force: true) if flag == :install && op.extras.delete(':')
+              post = readline('Enter command [args]', force: true) if flag == :install && op.remove(':')
               if op.arg?('all')
                 if flag == :pristine
                   append_repeat 'skip', op.extras
@@ -738,7 +742,7 @@ module Squared
                 items = op.extras.to_a
                 name = items.delete_at(n)
                 if (n = name.index('@')) == 0
-                  pre = project
+                  pre = gemname
                   ver = name[1..-1]
                 else
                   pre = name[0, n]
@@ -793,10 +797,11 @@ module Squared
           run_s(args, banner: false, from: :rake)
         end
 
-        def irb(name, opts = [], path: @path + 'lib', args: nil)
+        def irb(name = nil, opts = [], path: gemlib, args: nil)
           op = OptionPartition.new(opts, OPT_RUBY[:irb], session('irb'), project: self, first: [/\.rb$/])
           r = args ? [] : ['bundler/setup']
-          (r << name).each { |val| op << shell_option('r', val, merge: true) }
+          r << name if name
+          r.each { |val| op << shell_option('r', val, merge: true) }
           Array(path).each { |val| op << quote_option('I', val, merge: true) }
           if args
             op << '--' << args
@@ -807,6 +812,23 @@ module Squared
           run(banner: false)
         end
 
+        def gemspec
+          return @gemspec unless @gemspec.nil?
+
+          begin
+            if (file = gemfile)
+              @gemspec = Gem::Specification.load(file.to_s)
+            end
+          rescue StandardError => e
+            log.debug e
+          end
+          @gemspec ||= false
+        end
+
+        def gemname
+          @gemname ||= ((spec = gemspec) ? spec.name : project)
+        end
+
         def depend?
           @depend != false && (!@depend.nil? || outdated?)
         end
@@ -815,7 +837,7 @@ module Squared
           return true if super || (@copy.is_a?(Hash) && copy.fetch(:into, nil))
           return gemdir? if @gemdir
 
-          if @version
+          if version
             begin
               case @autodetect
               when 'rvm'
@@ -840,15 +862,17 @@ module Squared
           return false unless @autodetect
 
           set = lambda do |val, path|
-            log.warn "using version #{val} (given #{@version})" if @version && @version != val
-            @version = val
+            if (ver = version) && ver != val
+              log.warn "using version #{val} (given #{ver})"
+            end
+            self.version = val
             @gemdir = Pathname.new(path.strip) + gempath
           end
-          if @version
-            pwd = gempwd
-            pwd_set(pass: !pwd.nil?) do
-              out = `#{gem_output(pwd, 'list --local -d', project)}`
-              if out =~ /#{Regexp.escape(project)} \(([^)]+)\)/
+          if version
+            opt = gempwd
+            pwd_set(pass: !opt.nil?) do
+              out = `#{gem_output(opt, 'list --local -d', gemname)}`
+              if out =~ /#{Regexp.escape(gemname)} \(([^)]+)\)/
                 $1.split(/\s*,\s*/)
                   .unshift(@version)
                   .uniq
@@ -860,22 +884,21 @@ module Squared
                   end
               end
             end
-            require 'rubygems'
             @gemdir = Pathname.new(Gem.dir) + gempath
           else
             parse = lambda do |path|
               next unless path
 
-              lib = Regexp.new(['', 'gems', "#{project}-([^#{File::SEPARATOR}]+)", ''].join(File::SEPARATOR))
+              lib = Regexp.new(['', 'gems', "#{gemname}-([^#{File::SEPARATOR}]+)", ''].join(File::SEPARATOR))
               if (ver = path[lib, 1]) && (val = path[/\A(.+)#{gempath(ver[1])}/, 1])
                 set.call(ver, val)
               end
             end
             if RUBY_VERSION >= '2.6'
               target = RUBY_VERSION.start_with?('2.6') ? RubyVM : $LOAD_PATH
-              parse.call(target.resolve_feature_path(project)&.last)
+              parse.call(target.resolve_feature_path(gemname)&.last)
             end
-            if !@gemdir && !pwd_set { parse.call(`#{bundle_output('show', project)}`) }
+            if !@gemdir && !pwd_set { parse.call(`#{bundle_output('show', gemname)}`) }
               raise_error 'gems directory not found'
             end
           end
@@ -958,9 +981,9 @@ module Squared
 
         def read_rakefile
           @read_rakefile ||= [].tap do |ret|
-            pwd = rakepwd
-            pwd_set(pass: !pwd.nil?) do
-              IO.popen(rake_output(pwd, '-AT').to_s).each do |line|
+            opt = rakepwd
+            pwd_set(pass: !opt.nil?) do
+              IO.popen(rake_output(opt, '-AT').to_s).each do |line|
                 next unless line =~ /^rake ((?:[^\[: ]+:?)+)(\[[^\]]+\])?/
 
                 ret << [$1, $2]
@@ -982,26 +1005,44 @@ module Squared
         end
 
         def rakefile
-          return @rakefile if @rakefile
+          return @rakefile unless @rakefile.nil?
 
           file = Rake::Application::DEFAULT_RAKEFILES.find { |val| basepath(val).exist? }
-          @rakefile = file ? path + file : ''
+          @rakefile = file ? path + file : false
         end
 
         def rakepwd
-          return if pwd? || Rake::VERSION < '13.0.4'
+          return unless !pwd? && semgte?(Rake::VERSION, '13.0.4')
 
           quote_option 'C', path
         end
 
         def gempwd
-          return if pwd? || Gem::VERSION < '3.4.2'
+          return unless !pwd? && semgte?(Gem::VERSION, '3.4.2')
 
           quote_option 'C', path
         end
 
-        def gempath(val = @version)
-          File.join('gems', "#{project}-#{val}")
+        def gemfile
+          return @gemfile unless @gemfile.nil?
+
+          @gemfile = [project, name].map! { |val| path + "#{val}.gemspec" }
+                                    .concat(path.glob('*.gemspec'))
+                                    .find { |file| File.exist?(file) } || false
+        end
+
+        def gemlib
+          @gemlib ||= begin
+            lib = Set.new(['lib'])
+            if (spec = gemspec)
+              lib.merge(spec.require_paths || [])
+            end
+            lib.select { |file| basepath(file).exist? }
+          end
+        end
+
+        def gempath(val = version)
+          File.join('gems', "#{gemname}-#{val}")
         end
       end
 

data/lib/squared/workspace/project/support/class.rb

@@ -35,9 +35,7 @@ module Squared
               kwargs[:hint] ||= 'unrecognized'
               append(target, opts, delim: true) if kwargs.delete(:append)
               warn log_message(Logger::WARN, opts.join(', '), pass: true, **kwargs)
-              return if pass || confirm("Run? [#{sub_style(target, styles: styles)}] [y/N] ", 'N')
-
-              raise_error 'user cancelled'
+              exit 1 unless pass || confirm("Run? [#{sub_style(target, styles: styles)}] [y/N] ", 'N')
             end
 
             def strip(val)
@@ -47,6 +45,15 @@ module Squared
               val.map { |s| s.sub(/\A-([a-z\d])(.+)\z/i, '\1=\2').sub(/\A--?/, '') }.reject(&:empty?)
             end
 
+            def select(list, bare: true, no: true, single: false, double: false)
+              ret = bare ? list.grep_v(/=/) : list.grep(/=/).map! { |val| val.split('=', 2).first }
+              ret.map! { |val| val.split('|', 2).last }
+              ret = ret.grep_v(/^no-/) unless no
+              return ret if single == double
+
+              ret.select { |val| single ? val.size == 1 : val.size > 1 }
+            end
+
             def arg?(target, *args, value: false, **)
               r, s = args.partition { |val| val.is_a?(Regexp) }
               unless s.empty?
@@ -55,14 +62,21 @@ module Squared
               end
               target.any? { |opt| r.any? { |val| opt&.match?(val) } }
             end
+
+            def pattern?(val)
+              val.match?(/(?:\A\^|\$\z)/) || val.match?(/(?:\.[*+]|\(\?:|\\[dsw]|\[.+\]|\{\d+,?\d*\})/)
+            end
           end
 
           attr_reader :target, :extras, :found, :errors, :values, :project, :path
 
           def_delegators :@target, :+, :-, :<<, :any?, :none?, :include?, :add, :add?, :find, :find_all, :find_index,
-                         :merge, :delete, :delete?, :delete_if, :grep, :inspect, :to_a, :to_s
+                         :merge, :delete, :delete?, :delete_if, :grep, :grep_v, :inspect, :to_a, :to_s
           def_delegators :@extras, :empty?, :each, :each_with_index, :partition, :dup, :first, :last, :shift, :unshift,
-                         :pop, :push, :join, :map, :map!, :select, :reject, :size
+                         :pop, :push, :index, :delete_at, :join, :map, :map!, :select, :reject, :size
+
+          def_delegator :@extras, :delete, :remove
+          def_delegator :@extras, :delete_if, :remove_if
 
           def initialize(opts, list, target = Set.new, project: nil, path: nil, **kwargs, &blk)
             @target = target.is_a?(Set) ? target : Set.new(target)
@@ -140,35 +154,35 @@ module Squared
             skip = false
             opts.each do |opt|
               next skip = true if opt == '--'
-              next @extras << opt if skip
+              next push opt if skip
 
               if single&.match?(opt)
-                target << "-#{opt}"
+                add "-#{opt}"
               elsif bare.include?(opt)
-                target << (opt.size == 1 ? "-#{opt}" : "--#{opt}")
+                add(opt.size == 1 ? "-#{opt}" : "--#{opt}")
               elsif opt.start_with?('no-') && no.include?(name = opt[3..-1])
-                target << "--no-#{name}"
+                add "--no-#{name}"
               else
                 if opt =~ /\A([^=]+)=(.+)\z/
                   key = $1
                   val = $2
                   merge = m.include?(key)
                   if e.include?(key)
-                    target << shell_option(key, val, merge: merge)
+                    add shell_option(key, val, merge: merge)
                   elsif q.include?(key)
-                    target << quote_option(key, val, double: qq.include?(key), merge: merge)
+                    add quote_option(key, val, double: qq.include?(key), merge: merge)
                   elsif p.include?(key) && path
-                    target << quote_option(key, path + val, merge: merge)
+                    add quote_option(key, path + val, merge: merge)
                   elsif b.include?(key) || numcheck.call(key, val)
-                    target << basic_option(key, val, merge: merge)
+                    add basic_option(key, val, merge: merge)
                   elsif merge
-                    target << basic_option(key, val, merge: true)
+                    add basic_option(key, val, merge: true)
                   else
-                    @extras << opt
+                    push opt
                   end
                   opt = key
                 else
-                  @extras << opt
+                  push opt
                   skip = true if args
                 end
                 skip = true if first&.any? { |s| s.is_a?(Regexp) ? opt.match?(s) : !opt.include?(s) }
@@ -231,7 +245,42 @@ module Squared
               args = items[0...i] + args + items[i..-1]
               target.clear
             end
-            merge(args)
+            merge args
+            self
+          end
+
+          def add_path(*args, **kwargs)
+            add shell_quote(path ? path.join(*args) : File.join(*args), **kwargs)
+            self
+          end
+
+          def add_quote(*args, **kwargs)
+            merge(args.map { |val| shell_quote(val, **kwargs) })
+            self
+          end
+
+          def splice(*exclude, quote: true, delim: true, path: false, pattern: false, &blk)
+            found, other = if block_given?
+                             partition(&blk)
+                           elsif exclude.first.is_a?(Symbol)
+                             partition(&exclude.first)
+                           else
+                             partition do |val|
+                               next false if pattern && OptionPartition.pattern?(val)
+
+                               exclude.none? { |pat| val.match?(Regexp.new(pat)) }
+                             end
+                           end
+            unless found.empty?
+              add '--' if delim
+              extras.clear
+              extras.concat(other)
+              if path
+                found.each { |val| add_path(val) }
+              else
+                merge(quote ? found.map! { |val| shell_quote(val) } : found)
+              end
+            end
             self
           end
 

data/lib/squared/workspace/repo.rb

@@ -113,35 +113,17 @@ module Squared
       def __repo__(**kwargs)
         kwargs.delete(:parallel) if env('REPO_SYNC', ignore: '0')
 
-        namespace(name = task_name('repo')) do |repo|
+        namespace(task_name('repo')) do |ns|
+          path = ns.scope.path
           branch = env('REPO_MANIFEST') || Repo.read_manifest(root)
           target = branch || manifest
+          cmd = nil
           stage = nil
-          failfast = true
-          cmd = []
           newline = ARGV.index { |val| val.start_with?('repo:') }.to_i > 0
-          parse_opts = lambda do |args|
-            args.to_a.each do |val|
-              case val
-              when 'no-fail'
-                failfast = false
-              when 'force'
-                cmd << '--force-checkout'
-              when 'rebase'
-                cmd << '--rebase'
-              when 'detach'
-                cmd << '--detach'
-              when 'gc'
-                cmd << '--auto-gc'
-              when 'no-update'
-                cmd << '--no-manifest-update'
-              end
-            end
-          end
           desc = lambda do |val, alt = nil|
             if (ver = branch || alt)
-              val = val.sub('{0}', 'opts*=force,rebase,detach,gc,no-update,no-fail')
-              task_desc(task_name('repo'), val, ver)
+              val = val.sub('{0}', 'opts*=force,rebase,detach,fail,no-update,gc')
+              task_desc(path, val, ver)
             else
               task_desc 'inactive'
             end
@@ -149,20 +131,22 @@ module Squared
 
           desc.call('all[{0}]')
           task 'all', [:opts] do |_, args|
-            parse_opts.call(args)
+            cmd ||= repo_opts args
             stage ||= 'all'
-            repo['sync'].invoke
-            next if env('REPO_DRYRUN', equals: '2')
+            ns['sync'].invoke
+            next if env('REPO_STAGE', equals: '1')
 
             @project.select do |_, proj|
               next unless proj.enabled?(proj.workspace.baseref)
 
               proj.depend(sync: true) if proj.depend?
-              proj.build? unless env('REPO_DRYRUN', ignore: '0')
+              next if env('REPO_STAGE', equals: '2')
+
+              proj.build?
             end
             .each_value do |proj|
               proj.build(sync: true)
-              next unless proj.dev? && proj.copy?
+              next unless proj.dev? && proj.copy? && !env('REPO_STAGE', equals: '3')
 
               if (ws = proj.workspace).task_defined?(target = task_join(proj.name, 'copy'))
                 task_invoke(target, **ws.invokeargs)
@@ -174,38 +158,37 @@ module Squared
 
           desc.call("init[manifest?=#{target},{0}]", target)
           task 'init', [:manifest, :opts] do |_, args|
-            parse_opts.call(args)
+            cmd = repo_opts args
             stage = 'init'
             puts if newline
             Common::System.shell("repo init -u #{env('REPO_URL') || manifest_url} -m #{args.manifest || target}.xml",
                                  chdir: root)
-            repo['all'].invoke
+            next if env('REPO_STAGE', equals: '0')
+
+            ns['all'].invoke
           end
 
           desc.call('sync[{0}]')
-          task 'sync', [:opts] do |_, args|
-            unless branch || stage == 'init'
-              raise_error('repo not initialized', hint: task_name('repo:init'), kind: LoadError)
-            end
-            parse_opts.call(args)
+          task 'sync', [:opts] do |t, args|
+            raise_error 'repo not initialized' unless branch || stage == 'init'
+            cmd ||= repo_opts args
             cmd << "-j#{ENV.fetch('REPO_JOBS', Rake::CpuCounter.count)}"
-            cmd << '--fail-fast' if failfast
-            puts if newline && stage != 'init'
+            puts unless !newline || stage == 'init'
             begin
-              Common::System.shell("repo sync #{cmd.join(' ')}", chdir: root, exception: failfast)
+              Common::System.shell("repo sync #{cmd.join(' ')}", chdir: root, exception: cmd.include?('--fail-fast'))
             rescue Errno::ENOENT => e
               emphasize(e, title: root)
               raise
             rescue StandardError => e
-              emphasize(e, title: "rake stash #{task_name(task_join('repo', stage || 'sync'))}")
+              emphasize(e, title: "rake stash #{t.name}")
               raise
             end
           end
 
           series.sync.push(
-            task_join(name, 'all'),
-            task_join(name, 'init'),
-            task_join(name, 'sync')
+            task_join(path, 'all'),
+            task_join(path, 'init'),
+            task_join(path, 'sync')
           )
         end
       end
@@ -221,6 +204,27 @@ module Squared
         )
       end
 
+      def repo_opts(args)
+        ret = []
+        args.to_a.each do |val|
+          case val
+          when 'force'
+            ret << '--force-checkout'
+          when 'rebase'
+            ret << '--rebase'
+          when 'detach'
+            ret << '--detach'
+          when 'fail'
+            ret << '--fail-fast'
+          when 'no-update'
+            ret << '--no-manifest-update'
+          when 'gc'
+            ret << '--auto-gc'
+          end
+        end
+        ret
+      end
+
       def repo?
         !manifest_url.nil? && (repo_install? || @repo_override == true)
       end

data/lib/squared/workspace/series.rb

@@ -10,9 +10,9 @@ module Squared
 
       TASK_BASE = []
       TASK_BATCH = {}
-      TASK_EXTEND = Workspace.hashlist
+      TASK_EXTEND = Support.hashlist
       TASK_KEYS = []
-      TASK_ALIAS = Workspace.hashobj
+      TASK_ALIAS = Support.hashobj
       TASK_NAME = {}
       private_constant :TASK_BASE, :TASK_BATCH, :TASK_EXTEND, :TASK_KEYS, :TASK_ALIAS, :TASK_NAME
 
@@ -79,8 +79,8 @@ module Squared
         @chain = {}
         @exclude = exclude.freeze
         @session = {
-          group: Workspace.hashlist,
-          parent: Workspace.hashlist,
+          group: Support.hashlist,
+          parent: Support.hashlist,
           id: []
         }
         @data = {}

data/lib/squared/workspace/support/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Squared
+  module Workspace
+    module Support
+      class << self
+        def hashobj
+          Hash.new { |data, key| data[key] = {} }
+        end
+
+        def hashlist
+          Hash.new { |data, key| data[key] = [] }
+        end
+      end
+    end
+  end
+end

data/lib/squared/workspace/support.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
+require_relative 'support/base'
 require_relative 'support/data'