squared 0.0.1 → 0.0.2

data/lib/squared/repo/workspace.rb

@@ -3,8 +3,7 @@
 module Squared
   module Repo
     class Workspace
-      include Common
-      include Format
+      include Common::Format
       include System
       include Task
       include ::Rake::DSL
@@ -16,6 +15,7 @@ module Squared
         outdated: [],
         refresh: [],
         doc: [],
+        test: [],
         clean: []
       }
       TASK_BASE = {}
@@ -42,20 +42,19 @@ module Squared
           project_kind.find { |proj| proj.is_a?(path) } if path
         end
 
+        def to_s
+          /[^:]+$/.match(super.to_s)[0]
+        end
+
         attr_reader :project_kind
       end
 
       @project_kind = []
 
       attr_reader :main, :root, :home, :series
-      attr_accessor :script, :manifest, :manifest_url, :exception, :styles, :verbose
+      attr_accessor :manifest, :manifest_url, :exception, :styles, :pipe, :verbose
 
       def initialize(main)
-        prompt = lambda do |path|
-          return false unless path.directory?
-
-          confirm "#{log_title(:warn)} \"#{sub_style(path, :bold)}\" is not empty. Continue with installation? [y/N] "
-        end
         @main = main.to_s
         @home = if (val = env('REPO_HOME'))
                   home = Pathname.new(val)
@@ -66,7 +65,7 @@ module Squared
                     elsif !@root.exist?
                       @root.mkpath
                     elsif !empty?(@root)
-                      if prompt.(@root)
+                      if repo_prompt(@root)
                         @override = true
                       else
                         @root = nil
@@ -81,7 +80,7 @@ module Squared
                   if !@root.exist?
                     @root.mkpath
                   elsif !empty?(@root)
-                    raise ArgumentError, message('REPO_ROOT', val, hint: 'exist') unless prompt.(@root)
+                    raise ArgumentError, message('REPO_ROOT', val, hint: 'exist') unless repo_prompt(@root)
 
                     @override = true
                   end
@@ -93,58 +92,34 @@ module Squared
         @series = TASK_NAME.dup
         @styles = {}
         @project = {}
+        @script = {
+          group: {},
+          ref: {},
+          build: nil,
+          dev: nil,
+          prod: nil
+        }
         @exception = !env('PIPE_FAIL', ignore: '0').nil?
         @pipe = !env('PIPE_OUT', ignore: '0').nil?
-        @verbose = true
+        @verbose = !@pipe
       end
 
-      def repo(url, manifest = 'latest')
-        @manifest_url = url
-        @manifest = manifest
-        self
-      end
-
-      def run(script, **kwargs)
-        @script = case (val = env('REPO_BUILD'))
-                  when 'verbose'
-                    "#{script}:verbose"
-                  when 'silent'
-                    @verbose = false
-                    script
-                  else
-                    val || script
-                  end
-        @dev = bool_match(env('REPO_DEV'), kwargs[:dev])
-        @prod = bool_match(env('REPO_PROD'), kwargs[:prod])
-        self
-      end
+      def build(**kwargs)
+        default = kwargs[:default]
+        parallel = env('REPO_SYNC', ignore: '0') ? [] : (kwargs[:parallel] || []).map!(&:to_sym)
 
-      def add(name, dir = nil, **kwargs)
-        path = (dir || name).to_s
-        ref = kwargs[:ref]
-        project = if !ref.is_a?(::Class)
-                    Workspace.find(path: root_path(path), ref: ref)
-                  elsif ref < Project::Base
-                    ref
-                  end
-        instance = (project || Project::Base).new(name, path, self, **kwargs)
-        @project[n = name.to_sym] = instance
-        get(:project)[n] = instance
-        self
-      end
-
-      def build(default: nil, parallel: [])
         group = {}
         parent = {}
-        incl = Set.new
+        incl = []
         @project.each do |name, proj|
           next unless proj.enabled?
 
-          @series.each do |key, items|
+          series.each do |key, items|
             target = "#{name}:#{key}"
             case key
-            when :build, :refresh, :depend, :outdated, :doc, :copy, :clean
-              next unless proj.has?(key) || ::Rake::Task.task_defined?(target)
+            when :build, :refresh, :depend, :copy, :outdated, :doc, :test, :clean
+              valid = proj.has?(key) || ::Rake::Task.task_defined?(target)
+              next unless valid || (key == :refresh && series[:build].include?(target = "#{name}:build"))
             else
               next unless task_defined?(proj, key)
             end
@@ -156,19 +131,20 @@ module Squared
             end
             next unless (base = find_base(proj))
 
-            id = base.to_sym.to_s
-            next if id == proj.group
-
-            incl << id
-            (parent[:"#{key}:#{id}"] ||= []).push(target)
+            unless (id = base.to_sym.to_s) == proj.group
+              incl << id
+              (parent[:"#{key}:#{id}"] ||= []).push(target)
+            end
           end
-          proj.populate
+          proj.populate(**kwargs)
         end
-        @series.merge!(parent) if incl.size > 1
-        @series.merge!(group)
-        if @manifest_url && (empty?(@root) || @override)
+        series.merge!(parent) if incl.uniq.size > 1
+        series.merge!(group)
+        series[:refresh].clear if series[:refresh].all? { |target| target.to_s.end_with?(':build') }
+
+        if manifest_url && (empty?(root) || @override)
           branch = env('REPO_MANIFEST') || read_manifest
-          target = branch || @manifest
+          target = branch || manifest
           stage = nil
           failfast = true
           cmd = []
@@ -217,7 +193,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
 
@@ -230,48 +206,36 @@ module Squared
               cmd << '--fail-fast' if failfast
               puts if newline && stage != :init
               begin
-                shell("repo sync #{cmd.join(' ')}", chdir: @root, exception: failfast)
+                shell("repo sync #{cmd.join(' ')}", chdir: root, exception: failfast)
               rescue StandardError => e
-                emphasize(e, title: "rake stash repo:#{stage || :sync}")
+                emphasize(e, title: "rake stash repo:#{stage || 'sync'}")
                 raise
               end
             end
           end
         end
-        return unless enabled?
-
-        multi = env('REPO_SYNC', ignore: '0') ? [] : parallel.map(&:to_sym)
-        output = dev? ? :refresh : :build
-
-        task default: default || output
-
-        desc 'all[git?=rebase|stash]'
-        task :all, [:git] do |_, args|
-          sync = ->(key) { multi.include?(key) ? :"#{key}:sync" : key }
-          pull = case args.git
-                 when 'rebase'
-                   sync.(:rebase)
-                 when 'stash'
-                   invoke sync.(:stash)
-                   sync.(:pull)
-                 else
-                   sync.(:pull)
-                 end
-          invoke(pull, exception: @exception)
-          invoke(output, exception: @exception)
-        end
 
-        desc 'init'
-        task init: [:depend, output]
+        Workspace.project_kind.each { |obj| obj.populate(self, **kwargs) }
+
+        if !series[:build].empty?
+          init = [:depend, dev? && !series[:refresh].empty? ? :refresh : :build]
 
-        @series.each do |key, items|
+          task default: default || init[1]
+
+          desc 'init'
+          task init: init
+        elsif default && !series[default].empty?
+          task default: default
+        end
+
+        series.each do |key, items|
           next if items.empty?
 
-          unless (valid = multi.include?(key))
+          unless (valid = parallel.include?(key))
             group = key.to_s
-            valid = multi.include?(group.split(':').first.to_sym) if group.include?(':')
+            valid = parallel.include?(group.split(':').first.to_sym) if group.include?(':')
           end
-          if valid
+          if valid && items.size > 1
             desc "#{key} (thread)"
             multitask key => items
 
@@ -282,20 +246,77 @@ module Squared
             task key => items
           end
         end
+
+        yield self if block_given?
+      end
+
+      def repo(url, manifest = 'latest')
+        @manifest_url = url
+        @manifest = manifest
+        self
+      end
+
+      def run(script, group: nil, ref: nil, **kwargs)
+        if group || ref
+          script_command :run, script, group, ref
+        else
+          @script[:build] = case (val = env('REPO_BUILD'))
+                            when 'verbose'
+                              "#{script}:verbose"
+                            when 'silent'
+                              @verbose = false
+                              script
+                            else
+                              val || script
+                            end
+          @script[:dev] = bool_match(env('REPO_DEV'), kwargs[:dev])
+          @script[:prod] = bool_match(env('REPO_PROD'), kwargs[:prod])
+          self
+        end
+      end
+
+      def depend(script, group: nil, ref: nil)
+        script_command :depend, script, group, ref
+      end
+
+      def clean(script, group: nil, ref: nil)
+        script_command :clean, script, group, ref
       end
 
-      def compose(name, &block)
-        namespace(name, &block)
+      def doc(script, group: nil, ref: nil)
+        script_command :doc, script, group, ref
+      end
+
+      def test(script, group: nil, ref: nil)
+        script_command :test, script, group, ref
+      end
+
+      def add(name, dir = nil, **kwargs)
+        path = (dir || name).to_s
+        ref = kwargs[:ref]
+        project = if !ref.is_a?(::Class)
+                    Workspace.find(path: root_path(path), ref: ref)
+                  elsif ref < Project::Base
+                    ref
+                  end
+        instance = (project || Project::Base).new(name, path, self, **kwargs)
+        @project[n = name.to_sym] = instance
+        get!(:project)[n] = instance
         self
       end
 
-      def apply(&block)
-        instance_eval(&block)
+      def compose(name, &blk)
+        namespace(name, &blk)
+        self
+      end
+
+      def apply(&blk)
+        instance_eval(&blk)
         self
       end
 
       def style(name, *args)
-        set = ->(k, v) { @styles[k.to_sym] = check_style(v, empty: false) }
+        set = ->(k, v) { styles[k.to_sym] = check_style(v, empty: false) }
         if name.is_a?(Hash)
           name.each { |k, v| set.(k, v || args.flatten) }
         else
@@ -304,8 +325,16 @@ module Squared
         self
       end
 
+      def script(group: nil, ref: nil)
+        if group || ref
+          (group && @script[:group][group.to_sym]) || (ref && @script[:ref][ref.to_sym])
+        else
+          @script[:build]
+        end
+      end
+
       def env(key, equals: nil, ignore: nil)
-        ret = ENV.fetch("#{key}_#{@main.gsub(/[^\w]/, '_').upcase}", ENV[key]).to_s
+        ret = ENV.fetch("#{key}_#{main.gsub(/[^\w]/, '_').upcase}", ENV[key]).to_s
         return ret == equals.to_s if equals
 
         ret.empty? || as_a(ignore).any? { |val| ret == val.to_s } ? nil : ret
@@ -321,11 +350,11 @@ module Squared
       end
 
       def root_path(*args)
-        @root.join(*args)
+        root.join(*args)
       end
 
       def home_path(*args)
-        @home.join(*args)
+        home.join(*args)
       end
 
       def find_base(obj)
@@ -345,19 +374,23 @@ module Squared
         end
       end
 
+      def to_s
+        root.to_s
+      end
+
+      def inspect
+        "#<#{self.class}: #{main} => #{self}>"
+      end
+
       def empty?(dir)
         return true if dir.empty? || dir.join('.repo').directory?
         return true if dir.children.size == 1 && dir.join(dir.children.first).to_s == __FILE__
 
-        dir == @root && !env('REPO_ROOT').nil? && @root.children.none? do |path|
-          path.directory? && !path.basename.to_s.start_with?('.') && path.to_s != @home.to_s
+        dir == root && !env('REPO_ROOT').nil? && root.children.none? do |path|
+          path.directory? && !path.basename.to_s.start_with?('.') && path.to_s != home.to_s
         end
       end
 
-      def enabled?
-        !@series[:build].empty? || !@series[:doc].empty?
-      end
-
       def multitask?
         ::Rake::Task.tasks.any? do |item|
           next unless item.already_invoked
@@ -370,18 +403,14 @@ module Squared
         obj.is_a?(TASK_BASE[key])
       end
 
-      def dev?(pat = nil, script: nil)
-        with?(pat, script: script, state: @dev)
+      def dev?(script: nil, pat: nil, global: nil)
+        with?(:dev, script: script, pat: pat, global: (pat.nil? && global.nil?) || global)
       end
 
-      def prod?(pat = nil, script: nil)
-        return false if @dev == true || !@prod
+      def prod?(script: nil, pat: nil, global: false)
+        return false if global && (@script[:dev] == true || !@script[:prod])
 
-        with?(pat, script: script, state: @prod)
-      end
-
-      def pipe?
-        @pipe
+        with?(:prod, script: script, pat: pat, global: global)
       end
 
       protected
@@ -414,11 +443,30 @@ module Squared
 
       private
 
-      def with?(pat, script: nil, state: nil)
-        pat = state if pat.nil?
+      def script_command(task, val, group, ref)
+        if group
+          label = :group
+          items = as_a(group)
+        else
+          label = :ref
+          items = as_a(ref)
+        end
+        items.each { |name| (@script[label][name.to_sym] ||= {})[task] = val }
+        self
+      end
+
+      def repo_prompt(path)
+        return false unless path.directory?
+
+        confirm "#{log_title(:warn)} \"#{sub_style(path, :bold)}\" is not empty. Continue with installation? [y/N] "
+      end
+
+      def with?(state, script: nil, pat: nil, global: false)
+        pat = @script[state] if pat.nil? && global
         return pat == true unless pat.is_a?(::Regexp)
+        return false if !script && !global
 
-        pat.match?(script || @script)
+        pat.match?(script || @script[:build])
       end
     end
   end

data/lib/squared/repo.rb

@@ -9,7 +9,7 @@ module Squared
             project id
           else
             (id = Pathname.new(id).realdirpath.to_s) rescue nil if id.is_a?(::String)
-            get(:project).find { |_, val| val.path.to_s == id.to_s }
+            get!(:project).find { |_, val| val.path.to_s == id.to_s }
           end
         end
         ret.size == 1 ? ret.first : ret
@@ -29,7 +29,7 @@ module Squared
       private
 
       def project(name)
-        get(:project)[name.to_sym]
+        get!(:project)[name.to_sym]
       end
     end
   end

data/lib/squared/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - An Pham
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-29 00:00:00.000000000 Z
+date: 2024-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake