squared 0.0.1 → 0.0.3

data/lib/squared/repo/workspace.rb

@@ -16,6 +16,7 @@ module Squared
         outdated: [],
         refresh: [],
         doc: [],
+        test: [],
         clean: []
       }
       TASK_BASE = {}
@@ -42,20 +43,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
-
-      def initialize(main)
-        prompt = lambda do |path|
-          return false unless path.directory?
+      attr_reader :main, :root, :home, :series, :theme
+      attr_accessor :manifest, :manifest_url, :exception, :pipe, :verbose, :warning
 
-          confirm "#{log_title(:warn)} \"#{sub_style(path, :bold)}\" is not empty. Continue with installation? [y/N] "
-        end
+      def initialize(main, *, common: true, **)
         @main = main.to_s
         @home = if (val = env('REPO_HOME'))
                   home = Pathname.new(val)
@@ -66,7 +66,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 +81,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
@@ -91,60 +91,39 @@ module Squared
                 end
         @root ||= @home.parent
         @series = TASK_NAME.dup
-        @styles = {}
+        @theme = common ? __get__(:theme)[:workspace] : {}
         @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
-      end
-
-      def repo(url, manifest = 'latest')
-        @manifest_url = url
-        @manifest = manifest
-        self
+        @verbose = !@pipe
+        @warning = !empty?(@root, init: false)
       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)
+        return unless enabled?
 
-      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
+        default = kwargs[:default]
+        parallel = env('REPO_SYNC', ignore: '0') ? [] : (kwargs[:parallel] || []).map!(&:to_sym)
 
-      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 +135,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.end_with?(':build') }
+
+        if repo?
           branch = env('REPO_MANIFEST') || read_manifest
-          target = branch || @manifest
+          target = branch || manifest
           stage = nil
           failfast = true
           cmd = []
@@ -217,7 +197,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 +210,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
+        Workspace.project_kind.each { |obj| obj.populate(self, **kwargs) }
 
-        task default: default || output
+        if !series[:build].empty?
+          init = [:depend, dev? && !series[:refresh].empty? ? :refresh : :build]
 
-        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
+          task default: default || init[1]
 
-        desc 'init'
-        task init: [:depend, output]
+          desc 'init'
+          task init: init
+        elsif default && !series[default].empty?
+          task default: default
+        end
 
-        @series.each do |key, items|
+        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,50 +250,129 @@ module Squared
             task key => items
           end
         end
+
+        yield self if block_given?
+      end
+
+      def repo(url, manifest = 'latest', run: nil, dev: nil, prod: nil)
+        @manifest_url = url
+        @manifest = manifest
+        script = case (val = env('REPO_BUILD'))
+                 when 'verbose'
+                   run ? "#{run}:verbose" : nil
+                 when 'silent'
+                   @verbose = false
+                   @warning = false
+                   run
+                 else
+                   val || run
+                 end
+        case env('REPO_WARN')
+        when '0'
+          @warning = false
+        when '1'
+          @warning = true
+        end
+        script ? run(script, dev: bool_match(env('REPO_DEV'), dev), prod: bool_match(env('REPO_DEV'), prod)) : self
+      end
+
+      def run(script, group: nil, ref: nil, **kwargs)
+        if group || ref
+          script_command :run, script, group, ref
+        else
+          @script[:build] = script
+          @script[:dev] = kwargs[:dev]
+          @script[: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 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 compose(name, &block)
-        namespace(name, &block)
+      def add(name, path = nil, **kwargs)
+        path = root_path((path || name).to_s)
+        ref = kwargs[:ref]
+        project = if !ref.is_a?(::Class)
+                    Workspace.find(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 unless kwargs[:private]
         self
       end
 
-      def apply(&block)
-        instance_eval(&block)
+      def compose(name, &blk)
+        namespace(name, &blk)
         self
       end
 
-      def style(name, *args)
-        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
-          set.(name, args.flatten)
+      def apply(&blk)
+        instance_eval(&blk)
+        self
+      end
+
+      def style(name, *args, target: nil, empty: false)
+        data = nil
+        if target
+          as_a(target).each_with_index do |val, i|
+            if i == 0
+              break unless (data = __get__(:theme)[val.to_sym])
+            else
+              data = data[val.to_sym] ||= {}
+            end
+          end
+          return unless data
         end
+        apply_style(data || theme, name, *args, empty: empty)
         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
       end
 
-      def read_manifest
+      def read_manifest(*)
         require 'rexml/document'
         file = root_path('.repo/manifest.xml')
         return unless file.exist?
 
-        doc = REXML::Document.new(File.read(file))
+        doc = REXML::Document.new(file.read)
         doc.elements['manifest/include'].attributes['name']&.sub('.xml', '')
       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,17 +392,20 @@ module Squared
         end
       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__
+      def to_s
+        root.to_s
+      end
 
-        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
+      def inspect
+        "#<#{self.class}: #{main} => #{self}>"
       end
 
       def enabled?
-        !@series[:build].empty? || !@series[:doc].empty?
+        repo? || @project.any? { |_, proj| proj.enabled? }
+      end
+
+      def repo?
+        !manifest_url.nil? && (empty?(root) || @override)
       end
 
       def multitask?
@@ -366,22 +416,27 @@ module Squared
         end
       end
 
+      def empty?(dir, init: true)
+        return true if dir.empty? || (init && 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
+        end
+      end
+
       def task_defined?(obj, key)
         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
-
-        with?(pat, script: script, state: @prod)
-      end
+      def prod?(script: nil, pat: nil, global: false)
+        return false if global && (@script[:dev] == true || !@script[:prod])
 
-      def pipe?
-        @pipe
+        with?(:prod, script: script, pat: pat, global: global)
       end
 
       protected
@@ -414,11 +469,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
@@ -19,7 +19,7 @@ module Squared
         ret = project(name)
         return ret if ret&.path&.directory?
 
-        raise NoMethodError, message('project is not initialized', name)
+        raise NoMethodError, "project is not initialized (#{name})"
       end
 
       def project?(name)
@@ -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.3'
 end

metadata

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