squared 0.6.8 → 0.7.0

data/lib/squared/workspace/series.rb

@@ -8,88 +8,48 @@ module Squared
       include Rake::DSL
       extend Forwardable
 
-      TASK_BASE = []
-      TASK_BATCH = {}
-      TASK_EXTEND = Support.hashlist
-      TASK_METHODS = {}
-      TASK_KEYS = []
-      TASK_ALIAS = Support.hashobj
-      TASK_NAME = {}
-      private_constant :TASK_BASE, :TASK_BATCH, :TASK_EXTEND, :TASK_METHODS, :TASK_KEYS, :TASK_ALIAS, :TASK_NAME
-
-      class << self
-        def add(task, obj)
-          key_set task
-          TASK_EXTEND[task] << obj
-        end
-
-        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) }
-            if data.empty?
-              TASK_KEYS.delete(obj)
-              TASK_BATCH.delete(obj)
-            end
-          end
-        end
-
-        def alias(ref, obj)
-          if obj.is_a?(Hash)
-            obj.each { |key, val| TASK_ALIAS[key][ref] = val }
-          elsif TASK_ALIAS.key?(obj)
-            TASK_ALIAS[obj].delete(ref)
-            TASK_ALIAS.delete(obj) if TASK_ALIAS[obj].empty?
-          end
-        end
-
-        def rename(key, task)
-          TASK_NAME[key.to_sym] = task.to_sym
-        end
-
-        def base_set(obj)
-          TASK_BASE.clear
-          TASK_BASE.concat(obj.tasks.reject { |val| TASK_KEYS.include?(val) })
-        end
-
-        def extend_set(obj)
-          obj.tasks&.each { |task| add(task, obj) }
-          TASK_METHODS[obj] = obj.instance_methods(false)
-        end
-
-        private
-
-        def key_set(val)
-          return if TASK_KEYS.include?(val)
-
-          TASK_KEYS << val
-          TASK_BASE.delete(val)
-        end
-      end
-
       attr_reader :sync, :multiple, :parallel
 
       def_delegators :@data, :[], :each, :each_key, :keys, :key?, :include?, :fetch, :update, :merge!, :any?, :none?,
                      :delete, :delete_if, :find, :find_all, :to_a, :to_s, :inspect
       def_delegators :@workspace, :task_desc, :task_name, :task_namespace, :task_join, :format_desc
 
-      def initialize(workspace, exclude: [])
+      def initialize(workspace, project, exclude: [])
         @workspace = workspace
         @sync = []
         @multiple = []
         @parallel = []
         @chain = {}
         @exclude = exclude.freeze
+        @task = Struct::SeriesData.new(workspace.config_get(:rename))
+        @data = {}
+        project.each_with_index do |obj, index|
+          if index == 0
+            target = @task.base
+            obj.tasks.each do |key|
+              target << key
+              @data[key] = []
+            end
+          else
+            target = @task.project
+            obj.tasks&.each do |key|
+              task_set key
+              target[key] << obj
+            end
+          end
+          if (args = obj.batchargs)
+            batch_set(*args)
+          end
+          if (args = obj.aliasargs)
+            alias_set(*args)
+          end
+        end
+        workspace.config_get(:batch)&.each { |args| batch_set(*args) }
         @session = {
           group: Support.hashlist,
           parent: Support.hashlist,
           id: []
-        }
+        }.freeze
       end
 
       def populate(proj, **)
@@ -150,13 +110,13 @@ module Squared
 
         index = 0
         prereqs = level.map do |tasks|
-          task_join(key, index += 1).tap do |subkey|
-            if sync.include?(tasks) || (tasks.size == 1 && (sync << tasks))
-              task subkey => tasks
-            else
-              multitask subkey => tasks
-            end
+          name = task_join(key, index += 1)
+          if sync.include?(tasks) || (tasks.size == 1 && (sync << tasks))
+            task name => tasks
+          else
+            multitask name => tasks
           end
+          name
         end
         @chain[key] = level.freeze
         parallel << key
@@ -165,24 +125,22 @@ module Squared
         task key => prereqs
       end
 
-      def reset
-        @data = {}
-        (TASK_BASE + TASK_KEYS).each { |key| @data[key] = [] }
-        @data
-      end
-
       def name_get(key)
-        (TASK_NAME[key] || key).to_s
+        return key.to_s unless @task.rename&.key?(key)
+
+        @task.rename[key]
       end
 
       def batch_get(key)
-        TASK_BATCH[key]
+        return unless @task.batch.key?(key)
+
+        @task.batch[key]
       end
 
       def alias_get(key)
-        return unless TASK_ALIAS.key?(key)
+        return unless @task.alias.key?(key)
 
-        TASK_ALIAS[key]
+        @task.alias[key]
       end
 
       def some?(key)
@@ -195,18 +153,18 @@ module Squared
       end
 
       def base?(key)
-        TASK_BASE.include?(key)
+        @task.base.include?(key)
       end
 
       def extend?(obj, key)
-        return false unless TASK_EXTEND.key?(key)
+        return false unless @task.project.key?(key)
 
         ret = false
-        TASK_EXTEND[key].each do |kind|
+        @task.project[key].each do |kind|
           next unless obj.is_a?(kind)
 
           meth = :"#{key}?"
-          if TASK_METHODS[kind].include?(meth)
+          if kind.method_defined?(meth)
             out = obj.__send__(meth)
             return true if out == 1
             return out if obj.ref?(kind.ref)
@@ -223,6 +181,11 @@ module Squared
         data.keys.any? { |ref| obj.ref?(ref) }
       end
 
+      def missing?(obj, key)
+        obj = obj.ref unless obj.is_a?(Symbol)
+        @task.missing.key?(obj) && @task.missing.include?(key)
+      end
+
       def chain?(val)
         @chain.each_value do |tasks|
           tasks.flatten(1).each do |name|
@@ -252,6 +215,48 @@ module Squared
 
       private
 
+      def task_set(key)
+        @data[key] = []
+        @task.base.delete(key)
+        @task.keys << key
+      end
+
+      def batch_set(*args, obj)
+        data = @task.batch
+        if obj.is_a?(Hash)
+          obj.each do |key, val|
+            task_set key
+            if val.first.is_a?(Array)
+              missing = val.last
+              val = val.first
+            end
+            target = data[key]
+            args.each do |ref|
+              (target[ref] ||= []).concat(val)
+              next unless missing == true
+
+              @task.missing[ref] << key
+            end
+          end
+        elsif data.key?(obj)
+          args.each { |ref| data[obj].delete(ref) }
+          if data[obj].empty?
+            @task.keys.delete(obj)
+            data.delete(obj)
+          end
+        end
+      end
+
+      def alias_set(ref, obj)
+        data = @task.alias
+        if obj.is_a?(Hash)
+          obj.each { |key, val| data[key][ref] = val }
+        elsif data.key?(obj)
+          data[obj].delete(ref)
+          data.delete(obj) if data[obj].empty?
+        end
+      end
+
       def invoked_get(name)
         return unless Rake::Task.task_defined?(name) && (ret = Rake::Task[name]).already_invoked
 

data/lib/squared/workspace/support/base.rb

@@ -5,7 +5,21 @@ module Squared
     module Support
       RunData = Struct.new('RunData', :run, :block)
       ChainData = Struct.new('ChainData', :action, :step, :with, :before, :after, :sync)
-      BannerData = Struct.new('BannerData', :command, :order, :styles, :border)
+      BannerData = Struct.new('BannerData', :command, :styles, :border, :order) do
+        def initialize(command = true, styles = nil, border = nil, order = [])
+          super(command, Array(styles), Array(border), order)
+        end
+      end
+      SessionData = Struct.new('SessionData', :group, :ref, :store, :items) do
+        def initialize
+          super(Support.hashobj, Support.hashobj, {}, [])
+        end
+      end
+      SeriesData = Struct.new('SeriesData', :keys, :base, :project, :batch, :missing, :alias, :rename) do
+        def initialize(rename = nil)
+          super(Set.new, [], Support.hashlist, Support.hashobj, Support.hashlist, Support.hashobj, rename)
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.6.8
+  version: 0.7.0
 platform: ruby
 authors:
 - An Pham
@@ -97,6 +97,7 @@ files:
 - lib/squared/workspace/project/ruby.rb
 - lib/squared/workspace/project/support/class.rb
 - lib/squared/workspace/project/support/optionpartition.rb
+- lib/squared/workspace/project/support/utils.rb
 - lib/squared/workspace/repo.rb
 - lib/squared/workspace/series.rb
 - lib/squared/workspace/support.rb
@@ -124,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Rake task generator for managing multi-language workspaces.
 test_files: []