squared 0.0.9 → 0.0.11

data/lib/squared/workspace/repo.rb

@@ -1,13 +1,32 @@
 # frozen_string_literal: true
 
+require 'rexml/document'
+
 module Squared
   module Workspace
     module Repo
       include Common
       include Format
+      include Prompt
       include System
+      include Utils
+
+      class << self
+        def read_manifest(path)
+          return unless (file = path.join('.repo/manifest.xml')).exist?
+
+          doc = REXML::Document.new(file.read)
+          doc.elements['manifest/include'].attributes['name']&.sub('.xml', '')
+        end
+
+        def empty?(dir)
+          dir.empty? || (dir.children.size == 1 && dir.join(dir.children.first).to_s == __FILE__)
+        end
+      end
+
+      attr_reader :manifest_url, :manifest
 
-      def repo(url, manifest = 'latest', run: nil, dev: nil, prod: nil, ref: @ref, group: @group)
+      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)
                   if main == home.basename.to_s
@@ -16,71 +35,79 @@ module Squared
                       @root = nil unless home.directory?
                     elsif !@root.exist?
                       @root.mkpath
-                    elsif !install?
-                      @root = nil unless confirm_install
+                    elsif !repo_install?
+                      @root = nil unless repo_confirm
                     end
                   end
                   raise_error('REPO_HOME', val, hint: 'invalid') unless @root
-
                   home.realdirpath
                 elsif (val = env('REPO_ROOT'))
                   @root = Pathname.new(val).realdirpath
                   if !@root.exist?
                     @root.mkpath
-                  elsif !install?
-                    raise_error('REPO_ROOT', val, hint: 'exist') unless confirm_install
+                  elsif !repo_install?(parent: true)
+                    raise_error('REPO_ROOT', val, hint: 'exist') unless repo_confirm
                   end
                   @root.join(main).realdirpath
                 else
-                  install?(pwd = @home) ? pwd.join(main) : pwd
+                  repo_install?(@home) ? @home.join(main) : @home
                 end
         @root = @home.parent
         @manifest_url = url
         @manifest = manifest
-        set_ref = lambda do
-          if group
-            @script[:group][:_] = group.to_s
-          elsif ref
-            @script[:ref][:_] = ref.to_sym
-          end
-        end
+        data = script_obj
         if repo?
-          @script[:build] = case (val = env('REPO_BUILD'))
-                            when 'verbose'
-                              @verbose = true
-                              run.is_a?(String) ? "#{run}:verbose" : run
-                            when 'silent'
-                              @verbose = false
-                              @warning = false
-                              run
-                            else
-                              val || run
-                            end
-          @script[:dev] = bool_match(env('REPO_DEV'), dev)
-          @script[:prod] = bool_match(env('REPO_PROD'), prod)
-          if (val = env('REPO_GROUP'))
-            @script[:group][:_] = val.to_s
-            @script[:env] = true
-          elsif (val = env('REPO_REF'))
-            @script[:ref][:_] = val.to_sym
-            @script[:env] = true
+          if script
+            if (val = env('REPO_BUILD'))
+              data[:script] = case val
+                              when 'verbose'
+                                @verbose = 1
+                                if script.is_a?(::Array)
+                                  script[0] = task_join(script[0], 'verbose')
+                                  script
+                                else
+                                  task_join(script, 'verbose')
+                                end
+                              when 'silent'
+                                @verbose = false
+                                @warning = false
+                                script
+                              else
+                                val
+                              end
+              data[:env] = true
+            else
+              data[:script] = script
+            end
+          elsif (val = env('REPO_BUILD'))
+            data[:run] = val
+            data[:env] = true
           else
-            set_ref
+            data[:run] = run
+          end
+          data[:global] = true
+          data[:dev] = env_match('REPO_DEV', dev, suffix: @envname)
+          data[:prod] = env_match('REPO_PROD', prod, suffix: @envname)
+          if (val = env('REPO_GROUP'))
+            script_set(data, group: val.split(','))
+            found = true
           end
-          @warning = case env('REPO_WARN')
-                     when '0'
-                       false
-                     when '1'
-                       true
-                     else
-                       @warning && !empty?(@root)
-                     end
+          if (val = env('REPO_REF'))
+            script_set(data, ref: val.split(','))
+            found = true
+          end
+          script_set(data, group: group, ref: ref) unless found
+          @warning = env_match('REPO_WARN', @warning && !Repo.empty?(@root), suffix: @envname) != false
           @extensions << :__repo__
-        else
-          @script[:build] = run
-          @script[:dev] = dev
-          @script[:prod] = prod
-          set_ref
+        elsif script || run
+          if script
+            data[:script] = script
+          else
+            data[:run] = run
+          end
+          data[:dev] = dev
+          data[:prod] = prod
+          script_set(data, group: group, ref: ref)
         end
         self
       end
@@ -90,8 +117,8 @@ module Squared
       def __repo__(**kwargs)
         kwargs.delete(:parallel) if env('REPO_SYNC', ignore: '0')
 
-        branch = env('REPO_MANIFEST') || read_manifest
-        target = branch || @manifest
+        branch = env('REPO_MANIFEST') || Repo.read_manifest(root)
+        target = branch || manifest
         stage = nil
         failfast = true
         cmd = []
@@ -115,12 +142,9 @@ module Squared
           end
         end
         status = lambda do |val, alt = nil|
-          ver = branch || alt
-          if ver
-            message(@prefix || '', 'repo', val.sub('{0}', 'opts*=force,rebase,detach,gc,no-update,no-fail'), ver)
-          else
-            'inactive'
-          end
+          return 'inactive' unless (ver = branch || alt)
+
+          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|
@@ -130,12 +154,21 @@ module Squared
             stage ||= 'all'
             repo['sync'].invoke
             @project.select do |_, proj|
-              next false unless proj.enabled? && proj.ref?(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.has?('dev') && proj.copy?
+
+              if (ws = proj.workspace).task_defined?(target = ws.task_name(proj.name, 'copy'))
+                Common::Task.invoke(target, **ws.invokeargs)
+              else
+                proj.copy(sync: true)
+              end
+            end
           end
 
           desc status.("init[manifest?=#{target},{0}]", target)
@@ -143,7 +176,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
 
@@ -159,58 +192,32 @@ module Squared
             begin
               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
       end
 
-      def read_manifest
-        require 'rexml/document'
-        return unless (file = root_path('.repo/manifest.xml')).exist?
-
-        doc = REXML::Document.new(file.read)
-        doc.elements['manifest/include'].attributes['name']&.sub('.xml', '')
-      end
-
-      def confirm_install
+      def repo_confirm
         return false unless root.directory?
 
         path = sub_style(root, styles: theme[:inline])
-        @override = confirm(
+        @repo_override = confirm(
           "#{log_title(:warn)} \"#{path}\" is not empty. Continue with installation? [y/N] ",
-          default: 'N',
+          'N',
           timeout: env('REPO_TIMEOUT', 15, ignore: '0')
         )
       end
 
-      def bool_match(val, pat)
-        case val
-        when nil, ''
-          pat
-        when '0'
-          false
-        when '1'
-          true
-        else
-          Regexp.new(val)
-        end
-      end
-
       def repo?
-        !@manifest_url.nil? && (install? || !!@override)
-      end
-
-      def empty?(dir)
-        dir.empty? || (dir.children.size == 1 && dir.join(dir.children.first).to_s == __FILE__)
+        !manifest_url.nil? && (repo_install? || @repo_override == true)
       end
 
-      def install?(dir = root)
-        return true if empty?(dir) || dir.join('.repo').directory?
-        return false unless dir == root && env('REPO_HOME').nil? && !env('REPO_ROOT').nil?
+      def repo_install?(dir = root, parent: false)
+        return true if Repo.empty?(dir) || dir.join('.repo').directory?
 
-        root.children.none? { |path| path.directory? && path.basename.to_s[0] != '.' && path.to_s != home.to_s }
+        parent && root.children.none? { |ent| ent.directory? && ent.basename.to_s[0] != '.' && ent.to_s != home.to_s }
       end
     end
 

data/lib/squared/workspace/series.rb

@@ -8,22 +8,51 @@ 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 doc test copy clean]
+      TASK_BATCH = {}
       TASK_EXTEND = {}
-      private_constant :TASK_BASE, :TASK_ALIAS, :TASK_KEYS, :TASK_EXTEND
+      TASK_KEYS = TASK_BASE.dup
+      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(ref, obj)
+          if obj.is_a?(::Hash)
+            obj.each do |key, val|
+              key_set key
+              data = TASK_BATCH[key] ||= {}
+              (data[ref] ||= []).concat(val)
+            end
+          elsif (data = TASK_BATCH[obj]) && data.delete(ref) && data.empty?
+            TASK_KEYS.delete(obj)
+          end
+        end
+
+        def alias(ref, obj)
+          if obj.is_a?(::Hash)
+            obj.each { |key, val| (TASK_ALIAS[key] ||= {})[ref] = val }
+          elsif (data = TASK_ALIAS[obj])
+            data.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,55 +74,48 @@ module Squared
         TASK_KEYS.each { |key| @data[key] = [] }
       end
 
-      def __set__(key)
-        self[key.to_sym] ||= []
-      end
-
-      def __populate__(proj)
-        return unless @session
-
+      def populate(proj)
         group, parent, id = @session.values
-        ws = proj.workspace
-        each do |key, items|
-          task = "#{proj.name}:#{key}"
-          unless include?(key) ? proj.has?(key) || ws.task_defined?(key) : ws.task_extend?(proj, key)
-            alt = TASK_ALIAS[key]
-            next unless alt && (task = "#{proj.name}:#{alt}") && self[alt].include?(task)
-          end
-          next unless ws.task_defined?(task)
+        @data.each do |key, items|
+          ws = proj.workspace
+          next if (tasks = ws.task_resolve(proj, key)).empty?
 
           if (g = proj.group)
             id << g
-            (group[:"#{key}:#{g}"] ||= []).push(task)
+            (group[:"#{key}:#{g}"] ||= []).push(*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
 
           id << name
-          (parent[:"#{key}:#{name}"] ||= []).push(task)
+          (parent[:"#{key}:#{name}"] ||= []).push(*tasks)
         end
       end
 
-      def __build__(parallel: [], **)
-        group, parent, id = @session.values
-        merge!(parent) if id.uniq.size > 1
-        merge!(group)
-        each do |key, items|
+      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
@@ -101,19 +123,31 @@ module Squared
           desc val
           task key => items
         end
-        TASK_ALIAS.each_key do |key|
-          suf = ":#{key}"
-          self[key].clear unless self[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)
-        !key.nil? && key?(key = key.to_sym) && !self[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
 
@@ -135,17 +169,13 @@ module Squared
 
       private
 
-      def method_missing(key, *)
-        raise NoMethodError, key unless key?(key)
-
-        self[key]
-      end
-
       def already_invoked?(list, val)
-        return list.include?(val) && Common::Task.invoked?(val) if val
+        return false unless val && !list.include?(val)
 
-        ::Rake::Task.tasks.any? { |item| item.already_invoked && list.include?(item.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)
@@ -45,6 +43,9 @@ module Squared
   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.9
+  version: 0.0.11
 platform: ruby
 authors:
 - An Pham
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-16 00:00:00.000000000 Z
+date: 2024-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -63,13 +63,16 @@ 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
 - lib/squared/workspace.rb