squared 0.0.10 → 0.0.12

data/lib/squared/workspace/repo.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
+require 'rexml/document'
+
 module Squared
   module Workspace
     module Repo
-      include Common
-      include Format
-      include System
-      include Utils
+      include Common::Format
 
       class << self
         def read_manifest(path)
-          require 'rexml/document'
           return unless (file = path.join('.repo/manifest.xml')).exist?
 
           doc = REXML::Document.new(file.read)
@@ -22,6 +20,8 @@ module Squared
         end
       end
 
+      attr_reader :manifest_url, :manifest
+
       def repo(url, manifest = 'latest', run: nil, script: nil, dev: nil, prod: nil, ref: @ref, group: @group)
         @home = if (val = env('REPO_HOME'))
                   home = Pathname.new(val)
@@ -59,10 +59,10 @@ module Squared
                               when 'verbose'
                                 @verbose = 1
                                 if script.is_a?(::Array)
-                                  script[0] = "#{script[0]}:verbose"
+                                  script[0] = task_join(script[0], 'verbose')
                                   script
                                 else
-                                  "#{script}:verbose"
+                                  task_join(script, 'verbose')
                                 end
                               when 'silent'
                                 @verbose = false
@@ -114,7 +114,7 @@ module Squared
         kwargs.delete(:parallel) if env('REPO_SYNC', ignore: '0')
 
         branch = env('REPO_MANIFEST') || Repo.read_manifest(root)
-        target = branch || @manifest
+        target = branch || manifest
         stage = nil
         failfast = true
         cmd = []
@@ -140,22 +140,31 @@ module Squared
         status = lambda do |val, alt = nil|
           return 'inactive' unless (ver = branch || alt)
 
-          message(@prefix || '', 'repo', val.sub('{0}', 'opts*=force,rebase,detach,gc,no-update,no-fail'), ver)
+          message(@prefix, 'repo', val.sub('{0}', 'opts*=force,rebase,detach,gc,no-update,no-fail'), ver, empty: true)
         end
 
-        namespace task_name('repo') do |repo|
+        namespace(name = task_name('repo')) do |repo|
           desc status.('all[{0}]')
           task 'all', [:opts] do |_, args|
             parse_opts.(args)
             stage ||= 'all'
             repo['sync'].invoke
             @project.select do |_, proj|
-              next unless proj.enabled?(Project::Base.ref)
+              next unless proj.enabled?(proj.workspace.baseref)
 
-              proj.depend if proj.depend?
+              proj.depend(sync: true) if proj.depend?
               proj.build?
             end
-            .each_value { |proj| proj.has?('dev') ? proj.refresh : proj.build }
+            .each_value do |proj|
+              proj.build(sync: true)
+              next unless proj.dev? && proj.copy?
+
+              if (ws = proj.workspace).task_defined?(target = ws.task_name(task_join(proj.name, 'copy')))
+                task_invoke(target, **ws.invokeargs)
+              else
+                proj.copy(sync: true)
+              end
+            end
           end
 
           desc status.("init[manifest?=#{target},{0}]", target)
@@ -163,7 +172,7 @@ module Squared
             parse_opts.(args)
             stage = 'init'
             puts if newline
-            system("repo init -u #{@manifest_url} -m #{args.manifest || target}.xml", chdir: root)
+            system("repo init -u #{manifest_url} -m #{args.manifest || target}.xml", chdir: root)
             repo['all'].invoke
           end
 
@@ -177,20 +186,25 @@ module Squared
             cmd << '--fail-fast' if failfast
             puts if newline && stage != 'init'
             begin
-              shell("repo sync #{cmd.join(' ')}", chdir: root, exception: failfast)
+              Common::System.shell("repo sync #{cmd.join(' ')}", chdir: root, exception: failfast)
             rescue StandardError => e
-              emphasize(e, title: "rake stash #{task_name("repo:#{stage || 'sync'}")}")
+              emphasize(e, title: "rake stash #{task_name(task_join('repo', stage || 'sync'))}")
               raise
             end
           end
         end
+        series.sync.push(
+          task_join(name, 'all'),
+          task_join(name, 'init'),
+          task_join(name, 'sync')
+        )
       end
 
       def repo_confirm
         return false unless root.directory?
 
         path = sub_style(root, styles: theme[:inline])
-        @override = confirm(
+        @repo_override = Common::Prompt.confirm(
           "#{log_title(:warn)} \"#{path}\" is not empty. Continue with installation? [y/N] ",
           'N',
           timeout: env('REPO_TIMEOUT', 15, ignore: '0')
@@ -198,7 +212,7 @@ module Squared
       end
 
       def repo?
-        !@manifest_url.nil? && (repo_install? || !!@override)
+        !manifest_url.nil? && (repo_install? || @repo_override == true)
       end
 
       def repo_install?(dir = root, parent: false)

data/lib/squared/workspace/series.rb

@@ -8,22 +8,52 @@ module Squared
       include ::Rake::DSL
       extend Forwardable
 
-      TASK_BASE = %i[build refresh depend outdated doc test copy clean].freeze
-      TASK_ALIAS = {
-        refresh: :build
-      }
-      TASK_KEYS = TASK_BASE.dup
+      TASK_BASE = %i[build depend graph doc test copy clean]
+      TASK_BATCH = {}
       TASK_EXTEND = {}
-      private_constant :TASK_BASE, :TASK_ALIAS, :TASK_KEYS, :TASK_EXTEND
+      TASK_KEYS = TASK_BASE.dup + TASK_BATCH.keys
+      TASK_ALIAS = {}
+      TASK_NAME = {}
+      private_constant :TASK_BASE, :TASK_BATCH, :TASK_KEYS, :TASK_NAME, :TASK_EXTEND
 
       class << self
         def add(task, obj)
-          TASK_KEYS << task unless TASK_KEYS.include?(task)
+          key_set task
           (TASK_EXTEND[task] ||= []).push(obj)
         end
 
-        def alias(key, task)
-          TASK_ALIAS[key.to_sym] = task.to_sym
+        def batch(*args, obj)
+          if obj.is_a?(::Hash)
+            obj.each do |key, val|
+              key_set key
+              data = TASK_BATCH[key] ||= {}
+              args.each { |ref| (data[ref] ||= []).concat(val) }
+            end
+          elsif (data = TASK_BATCH[obj])
+            args.each { |ref| data.delete(ref) }
+            TASK_KEYS.delete(obj) if data.empty?
+          end
+        end
+
+        def alias(ref, obj)
+          if obj.is_a?(::Hash)
+            obj.each { |key, val| (TASK_ALIAS[key] ||= {})[ref] = val }
+          else
+            TASK_ALIAS[obj]&.delete(ref)
+          end
+        end
+
+        def rename(key, task)
+          TASK_NAME[key.to_sym] = task.to_sym
+        end
+
+        private
+
+        def key_set(val)
+          return if TASK_KEYS.include?(val)
+
+          TASK_KEYS << val
+          TASK_BASE.delete(val)
         end
       end
 
@@ -45,57 +75,48 @@ module Squared
         TASK_KEYS.each { |key| @data[key] = [] }
       end
 
-      def __set__(key)
-        @data[key.to_sym] ||= []
-      end
-
-      def __populate__(proj)
-        return unless @session
-
+      def populate(proj)
         group, parent, id = @session.values
         ws = proj.workspace
-        ref = Project::Base.ref
         @data.each do |key, items|
-          task = "#{proj.name}:#{key}"
-          unless (base = include?(key)) ? proj.has?(key, ref) : ws.task_extend?(proj, key)
-            next if (base && !proj.ref?(ref)) || (alt = TASK_ALIAS[key]).nil?
-
-            task = "#{proj.name}:#{alt}"
-          end
-          next unless ws.task_defined?(task)
+          next if (tasks = ws.task_resolve(proj, key)).empty?
 
           if (g = proj.group)
             id << g
-            (group[:"#{key}:#{g}"] ||= []).push(task)
+            (group[:"#{key}:#{g}"] ||= []).concat(tasks)
           else
-            items << task
+            items.concat(tasks)
+          end
+          if tasks.size > 1 && (data = batch_get(key)) && data.keys.any? { |ref| proj.ref?(ref) }
+            desc ws.task_name(t = ws.task_join(proj.name, key), desc: true)
+            task ws.task_name(t) => tasks
           end
-          next unless (b = ws.find_base(proj)) && (name = b.ref.to_s) != g
+          next unless (b = ws.find_base(proj)) && (n = b.ref.to_s) != g
 
-          id << name
-          (parent[:"#{key}:#{name}"] ||= []).push(task)
+          id << n
+          (parent[:"#{key}:#{n}"] ||= []).concat(tasks)
         end
       end
 
-      def __build__(parallel: [], **)
-        group, parent, id = @session.values
-        @data.merge!(parent) if id.uniq.size > 1
-        @data.merge!(group)
+      def build(parallel: [], **)
+        @data.merge!(@session[:parent]) if @session[:id].uniq.size > 1
+        @data.merge!(@session[:group])
         @data.each do |key, items|
           next if items.empty?
 
-          key = @workspace.task_name(name = key.to_s)
-          val = @workspace.task_name(name, desc: true)
+          key = @workspace.task_name(t = name_get(key))
+          val = @workspace.task_name(t, desc: true)
           if items.size > 1
             @multiple << key
-            if parallel.include?(name) || ((ns = @workspace.task_namespace(name)) && parallel.include?(ns))
+            if parallel.include?(t) || ((ns = @workspace.task_namespace(t)) && parallel.include?(ns))
               desc "#{val} (thread)"
               multitask key => items
               @parallel << key
 
+              s = @workspace.task_join(key, 'sync')
               desc "#{val} (sync)"
-              task "#{key}:sync" => items
-              @sync << "#{key}:sync"
+              task s => items
+              @sync << s
               next
             end
           end
@@ -103,19 +124,31 @@ module Squared
           desc val
           task key => items
         end
-        TASK_ALIAS.each_key do |key|
-          suf = ":#{key}"
-          @data[key].clear unless @data[key].any? { |val| val.end_with?(suf) }
-        end
         @multiple += sync
-        @session = nil
+      end
+
+      def name_get(key)
+        (TASK_NAME[key] || key).to_s
+      end
+
+      def batch_get(key)
+        TASK_BATCH[key]
+      end
+
+      def alias_get(key)
+        TASK_ALIAS[key]
       end
 
       def some?(key)
-        @data.key?(key) && !@data[key].empty?
+        return @data.key?(key) && !@data[key].empty? unless (batch = batch_get(key))
+
+        batch.each_value do |items|
+          return true if items.all? { |val| some?(val) || alias_get(val)&.any? { |_, alt| some?(alt) } }
+        end
+        false
       end
 
-      def include?(key)
+      def base?(key)
         TASK_BASE.include?(key)
       end
 
@@ -137,17 +170,13 @@ module Squared
 
       private
 
-      def method_missing(key, *)
-        raise NoMethodError, key unless @data.key?(key)
-
-        @data[key]
-      end
-
       def already_invoked?(list, val)
-        return list.include?(val) && Common::Task.invoked?(val) if val
+        return false if val && !list.include?(val)
 
-        ::Rake::Task.tasks.any? { |obj| obj.already_invoked && list.include?(obj.name) }
+        ::Rake::Task.tasks.any? { |obj| obj.already_invoked && (val ? val == obj.name : list.include?(obj.name)) }
       end
     end
+
+    Application.impl_series = Series
   end
 end

data/lib/squared/workspace.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'common'
-
 module Squared
   module Workspace
     class << self
@@ -23,7 +21,7 @@ module Squared
         ret = project(name)
         return ret if ret&.path&.directory?
 
-        raise NoMethodError, message('project is not initialized', hint: name)
+        raise NoMethodError, "project is not initialized (#{name})"
       end
 
       def dirpath(val, absolute: true)
@@ -39,12 +37,15 @@ module Squared
       private
 
       def project(name)
-        __get__(:project)[name.to_sym]
+        __get__(:project)[name.to_s]
       end
     end
   end
 end
 
-require_relative 'workspace/series'
 require_relative 'workspace/application'
+require_relative 'workspace/series'
 require_relative 'workspace/project'
+
+Workspace = Squared::Workspace
+Project = Squared::Workspace::Project

data/lib/squared.rb

@@ -1,14 +1,4 @@
 # frozen_string_literal: true
 
 require_relative 'squared/version'
-require_relative 'squared/workspace'
-
-Workspace = Squared::Workspace
-Project = Squared::Workspace::Project
-
-Workspace::Application.implement(
-  Project::Git,
-  Project::Node,
-  Project::Python,
-  Project::Ruby
-)
+require_relative 'squared/common'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.12
 platform: ruby
 authors:
 - An Pham
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-21 00:00:00.000000000 Z
+date: 2024-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -63,13 +63,14 @@ files:
 - README.md
 - README.ruby.md
 - lib/squared.rb
+- lib/squared/app.rb
 - lib/squared/common.rb
 - lib/squared/common/base.rb
 - lib/squared/common/class.rb
 - lib/squared/common/format.rb
+- lib/squared/common/prompt.rb
 - lib/squared/common/shell.rb
 - lib/squared/common/system.rb
-- lib/squared/common/task.rb
 - lib/squared/common/utils.rb
 - lib/squared/config.rb
 - lib/squared/version.rb

data/lib/squared/common/task.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'rake'
-
-module Squared
-  module Common
-    module Task
-      module_function
-
-      def invoke(series, *args, exception: true, warning: true)
-        series = [series] unless series.is_a?(::Array)
-        series.each { |name| ::Rake::Task[name].invoke(*args) }
-      rescue StandardError => e
-        raise if exception
-
-        warn e if warning
-      end
-
-      def invoked?(name)
-        ::Rake::Task.tasks.any? { |obj| obj.already_invoked && obj.name == name.to_s }
-      end
-    end
-  end
-end