squared 0.0.6 → 0.0.8

data/lib/squared/workspace/series.rb

@@ -8,19 +8,22 @@ module Squared
       include ::Rake::DSL
       extend Forwardable
 
-      attr_reader :workspace, :sync, :multiple, :parallel
+      TASK_BASE = %i[build refresh depend outdated doc test copy clean].freeze
+      TASK_KEYS = TASK_BASE.dup
+      TASK_EXTEND = {}
+      private_constant :TASK_BASE, :TASK_KEYS, :TASK_EXTEND
+
+      def self.add(task, obj)
+        TASK_KEYS << task unless TASK_KEYS.include?(task)
+        (TASK_EXTEND[task] ||= []).push(obj)
+      end
 
-      def_delegators :@data, :[], :each, :each_key, :keys, :fetch, :to_a, :to_s, :inspect, :merge!, :key?, :has_key?
+      attr_reader :sync, :multiple, :parallel
 
-      def initialize(tasks, workspace, keys: Workspace::Application::WORKSPACE_KEYS)
-        if tasks.is_a?(Array)
-          @data = {}
-          tasks.each { |key| __set__ key }
-        else
-          @data = tasks.dup
-        end
-        @workspace = workspace
-        @keys = keys
+      def_delegators :@data, :[], :each, :each_key, :keys, :fetch, :to_a, :to_s, :inspect, :merge!, :key?
+
+      def initialize(prefix = nil)
+        @prefix = prefix
         @sync = []
         @multiple = []
         @parallel = []
@@ -29,67 +32,65 @@ module Squared
           parent: {},
           id: []
         }
+        @data = {}
+        TASK_KEYS.each { |key| @data[key] = [] }
       end
 
       def __set__(key)
         self[key.to_sym] ||= []
       end
 
-      def populate(proj)
+      def __populate__(proj)
         return unless @session
 
         group, parent, id = @session.values
+        ws = proj.workspace
         each do |key, items|
-          target = "#{proj.name}:#{key}"
-          if @keys.include?(key)
-            next unless proj.has?(key) || (target = workspace.task_base?(key, target))
-          else
-            next unless workspace.task_include?(proj, key)
-          end
+          task = "#{proj.name}:#{key}"
+          next if include?(key) ? !proj.has?(key) && !(task = ws.task_base?(key, task)) : !ws.task_extend?(proj, key)
+          next unless ws.task_defined?(task)
+
           if (g = proj.group)
             id << g
-            (group[:"#{key}:#{g}"] ||= []).push(target)
+            (group[:"#{key}:#{g}"] ||= []).push(task)
           else
-            items << target
+            items << task
           end
-          next unless (b = find_base(proj)) && (name = b.to_sym.to_s) != g
+          next unless (b = ws.find_base(proj)) && (name = b.ref.to_s) != g
 
           id << name
-          (parent[:"#{key}:#{name}"] ||= []).push(target)
+          (parent[:"#{key}:#{name}"] ||= []).push(task)
         end
       end
 
-      def method_missing(key, *)
-        self[key]
-      end
-
-      def finalize!(thread = [])
-        thread.map!(&:to_s)
+      def __build__(parallel: [], **)
         group, parent, id = @session.values
         merge!(parent) if id.uniq.size > 1
         merge!(group)
         each do |key, items|
           next if items.empty?
 
-          key = key.to_s
+          name = key.to_s
+          key = @prefix ? "#{@prefix}:#{name}" : name
+          val = key.split(':').join(' => ')
           if items.size > 1
-            multiple << key
-            if thread.include?(key) || (key.include?(':') && thread.include?(key.split(':').first.to_sym))
-              desc "#{key} (thread)"
+            @multiple << key
+            if parallel.include?(name) || (name.include?(':') && parallel.include?(name.split(':').first.to_sym))
+              desc "#{val} (thread)"
               multitask key => items
-              parallel << key
+              @parallel << key
 
-              desc "#{key} (sync)"
-              task "#{key}:sync": items
-              sync << "#{key}:sync"
-              multiple << "#{key}:sync"
+              desc "#{val} (sync)"
+              task "#{key}:sync" => items
+              @sync << "#{key}:sync"
               next
             end
           end
 
-          desc key
+          desc val
           task key => items
         end
+        @multiple += sync
         @session = nil
       end
 
@@ -97,6 +98,14 @@ module Squared
         !key.nil? && key?(key = key.to_sym) && !self[key].empty?
       end
 
+      def include?(key)
+        TASK_BASE.include?(key)
+      end
+
+      def extend?(obj, key)
+        TASK_EXTEND.fetch(key, []).any? { |kind| obj.is_a?(kind) && obj.ref?(kind.ref) }
+      end
+
       def multiple?(val = nil)
         already_invoked?(multiple, val)
       end
@@ -109,14 +118,16 @@ module Squared
         already_invoked?(parallel, val)
       end
 
-      def respond_to_missing?(key, *)
-        key?(key)
-      end
-
       private
 
+      def method_missing(key, *)
+        raise NoMethodError, key unless key?(key)
+
+        self[key]
+      end
+
       def already_invoked?(list, val)
-        return list.include?(val) && invoked?(val) if val
+        return list.include?(val) && Common::Task.invoked?(val) if val
 
         ::Rake::Task.tasks.any? { |item| item.already_invoked && list.include?(item.name) }
       end

data/lib/squared/workspace.rb

@@ -5,12 +5,14 @@ require_relative 'common'
 module Squared
   module Workspace
     class << self
+      include Common
+
       def resolve(*args)
         ret = args.map do |id|
           if id.is_a?(::Symbol)
             project id
           else
-            (id = Pathname.new(id).realdirpath.to_s) rescue nil if id.is_a?(::String)
+            id = dirpath(id) if id.is_a?(::String)
             __get__(:project).find { |_, val| val.path.to_s == id.to_s }
           end
         end
@@ -21,7 +23,13 @@ module Squared
         ret = project(name)
         return ret if ret&.path&.directory?
 
-        raise NoMethodError, "project is not initialized (#{name})"
+        raise NoMethodError, message('project is not initialized', hint: name)
+      end
+
+      def dirpath(val, absolute: true)
+        Pathname.new(val).realdirpath
+      rescue StandardError
+        absolute ? Pathname.pwd.join(val) : Pathname.new(val)
       end
 
       def project?(name)
@@ -37,6 +45,6 @@ module Squared
   end
 end
 
-require_relative 'workspace/application'
 require_relative 'workspace/series'
+require_relative 'workspace/application'
 require_relative 'workspace/project'

data/squared.gemspec

@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "rake"
   spec.add_dependency "logger"
+  spec.add_dependency "rexml"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - An Pham
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-10 00:00:00.000000000 Z
+date: 2024-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rake task generator for managing multi-language workspaces.
 email:
 - anpham6@gmail.com