squared 0.0.9 → 0.0.11

data/lib/squared/workspace/application.rb

@@ -7,14 +7,28 @@ module Squared
       include Format
       include ::Rake::DSL
 
+      SCRIPT_OBJ = {
+        run: nil,
+        script: nil,
+        dev: nil,
+        prod: nil,
+        global: false,
+        env: false
+      }.freeze
+      private_constant :SCRIPT_OBJ
+
       class << self
         def implement(*objs)
           objs.each do |obj|
-            if obj < Project::Base
-              @impl_project.unshift(obj)
-              obj.tasks&.each { |task| @impl_series.add(task, obj) }
-            elsif obj < Workspace::Series
-              @impl_series = obj
+            next unless obj < base_project
+
+            impl_project.unshift(obj)
+            obj.tasks&.each { |task| impl_series.add(task, obj) }
+            if (args = obj.batchargs)
+              impl_series.batch(*args)
+            end
+            if (args = obj.aliasargs)
+              impl_series.alias(*args)
             end
           end
         end
@@ -23,87 +37,109 @@ module Squared
           if ref && (ret = impl_project.find { |proj| proj.ref == ref.to_sym })
             ret
           elsif path
-            impl_project.find { |proj| proj.is_a?(path) }
+            impl_project.find { |proj| proj.config?(path) }
           end
         end
 
+        def baseref
+          base_project.ref
+        end
+
         def to_s
           super.to_s.match(/[^:]+$/)[0]
         end
 
-        attr_reader :impl_project, :impl_series
+        attr_reader :impl_project, :attr_banner
+        attr_accessor :impl_series, :base_project
       end
 
       @impl_project = []
-      @impl_series = Workspace::Series
+      @attr_banner = SymSet.new(%i[name project path ref group parent version])
 
-      attr_reader :root, :home, :main, :prefix, :series, :theme
-      attr_accessor :exception, :warning, :pipe, :verbose
+      attr_reader :root, :home, :main, :prefix, :exception, :warning, :pipe, :verbose, :theme, :series, :closed
 
-      def initialize(home = Dir.pwd, *, main: nil, prefix: nil, exception: false, pipe: false, verbose: nil, **kwargs)
-        @home = (home = Pathname.new(home)).realdirpath
-        @main = (main || home.basename).to_s
+      def initialize(home = Dir.pwd, *, main: nil, prefix: nil, verbose: nil,
+                     common: ARG[:COMMON], pipe: ARG[:PIPE], exception: ARG[:FAIL], **)
+        @home = Pathname.new(home).realdirpath
         @root = @home.parent
+        @main = (main || @home.basename).to_s.freeze
         @prefix = prefix
         @series = Application.impl_series.new(self)
         @project = {}
         @extensions = []
-        @script = {
-          group: {},
-          ref: {},
-          build: nil,
-          dev: nil,
-          prod: nil,
-          env: false
-        }
-        @exception = exception.is_a?(String) ? !env(exception, ignore: '0').nil? : exception
-        @pipe = pipe.is_a?(String) ? !env(pipe, ignore: '0').nil? : pipe
-        @verbose = verbose.nil? ? !@pipe : verbose
-        @warning = @verbose
-        if kwargs.fetch(:common, true)
+        @pipe = env_pipe(pipe, (ARG[:OUT] && env(ARG[:OUT])) || 1, root: @home)
+        @exception = env_bool(exception)
+        @verbose = verbose.nil? ? @pipe != 0 : verbose
+        @warning = @verbose != false
+        @closed = false
+        if common
           @theme = __get__(:theme)[:workspace]
-          __set__(:no_color, true) if @pipe
+          ARG[:COLOR] = false if @pipe == 0 || @pipe.is_a?(::Pathname)
         else
           @theme = {}
         end
-        @banner = {}
+        @script = {
+          group: {},
+          ref: {},
+          group!: {},
+          ref!: {}
+        }.freeze
+        @banner = {
+          group: {},
+          ref: {}
+        }.freeze
+        initialize_session
       end
 
-      def build(**kwargs)
-        kwargs[:parallel] = kwargs.fetch(:parallel, []).map(&:to_s)
-        return unless enabled?
+      def initialize_session
+        @envname = @main.gsub(/[^\w]+/, '_').upcase.freeze
+        return unless @pipe.is_a?(::Pathname)
+
+        bord = '#' * Project.line_width
+        puts bord, format('Session started on %s by %s', Time.now.to_s, @main), bord
+      end
+
+      def build(parallel: [], **kwargs)
+        kwargs[:parallel] = parallel.map(&:to_s)
+        return if @closed || !enabled?
 
         @project.each_value do |proj|
           next unless proj.enabled?
 
           proj.populate(**kwargs)
-          series.__populate__(proj)
+          series.populate(proj)
         end
 
         Application.impl_project.each { |obj| obj.populate(self, **kwargs) }
         @extensions.each { |ext| __send__(ext, **kwargs) }
 
-        series.__build__(**kwargs)
+        series.build(**kwargs)
         __build__(**kwargs)
 
         yield self if block_given?
+        @closed = true
       end
 
-      def with(val, &blk)
+      def with(*val, group: nil, **kwargs, &blk)
         @group = nil
         @ref = nil
-        if val.is_a?(::String)
+        @withargs = kwargs.empty? ? nil : kwargs
+        val = [group || kwargs[:ref]].compact.flatten if val.empty?
+        kind = val.first
+        val = kind if val.size == 1
+        case kind
+        when ::String
           @group = val
-          if block_given?
-            instance_eval(&blk)
-            @group = nil
-          end
-        elsif val.is_a?(::Symbol)
+        when ::Symbol
           @ref = val
-          if block_given?
-            instance_eval(&blk)
-            @ref = nil
-          end
+        else
+          raise_error('group{Symbol} | ref{String}', hint: 'missing') if block_given?
+        end
+        if block_given?
+          instance_eval(&blk)
+          @group = nil
+          @ref = nil
+          @withargs = nil
         end
         self
       end
@@ -128,50 +164,105 @@ module Squared
         script_command :test, script, group, ref
       end
 
+      def log(script, group: @group, ref: @ref)
+        script_command :log, script, group, ref
+      end
+
       def exclude(base, group: @group, ref: @ref)
         script_command :exclude, as_a(base, :to_sym).freeze, group, ref
       end
 
-      def add(name, path = nil, **kwargs)
+      def banner(*args, command: true, styles: nil, border: nil, group: @group, ref: @ref)
+        data = { command: command, order: [], styles: check_style(styles, empty: false), border: check_style(border) }
+        args.each do |meth|
+          if meth.is_a?(::Array)
+            found = false
+            meth = meth.select do |val|
+              case val
+              when ::Symbol
+                found = true
+                Application.attr_banner.include?(val)
+              when ::String
+                true
+              else
+                false
+              end
+            end
+            if !found
+              next
+            elsif meth.size == 1
+              meth = meth.first
+            end
+          elsif !Application.attr_banner.include?(meth = meth.to_sym)
+            next
+          end
+          data[:order] << meth
+        end
+        unless !command && data[:order].empty?
+          if group
+            label = :group
+            items = as_a(group)
+          else
+            label = :ref
+            items = ref ? as_a(ref) : %i[_]
+          end
+          items.each { |val| @banner[label][val.to_sym] = data }
+        end
+        self
+      end
+
+      def add(path, val = nil, **kwargs, &blk)
+        if @withargs
+          data = @withargs.dup
+          data.merge!(kwargs)
+          kwargs = data
+        end
         ref = if kwargs.key?(:ref)
+                kwargs = kwargs.dup unless @withargs
                 kwargs.delete(:ref)
-              elsif !@ref.is_a?(::Array)
+              elsif @ref.is_a?(::Symbol)
                 @ref
               end
-        kwargs[:group] = @group if !kwargs.key?(:group) && !@group.is_a?(::Array)
-        path = root_path(path || name.to_s)
+        if @group.is_a?(::String) && !kwargs.key?(:group)
+          kwargs = kwargs.dup unless @withargs
+          kwargs[:group] = @group
+        end
+        path = root_path(path)
+        val = (val || path.basename).to_s
+        name = val.to_sym
+        index = 0
+        while @project[name]
+          index += 1
+          name = :"#{val}-#{index}"
+        end
         proj = ((if !ref.is_a?(::Class)
                    Application.find(ref, path: path)
                  elsif ref < Project::Base
                    ref
-                 end) || Project::Base).new(task_name(name), path, self, **kwargs)
-        @project[name = name.to_sym] = proj
+                 end) || Project::Base).new(self, path, task_name(name), **kwargs)
+        @project[name] = proj
         __get__(:project)[name] = proj unless kwargs[:private]
+        proj.instance_eval(&blk) if block_given?
         self
       end
 
-      def group(name, path, override: {}, **kwargs)
-        root_path(path).children.map do |ent|
-          next unless (dir = Pathname.new(ent)).directory?
+      def group(path, val, override: {}, **kwargs, &blk)
+        root_path(path).children.map do |dir|
+          next unless dir.directory?
 
-          index = 0
           basename = dir.basename.to_s.to_sym
-          while @project[basename]
-            index += 1
-            basename = :"#{basename}-#{index}"
-          end
-          [basename, dir, override[basename]]
+          [dir, basename, override[basename]]
         end
-        .each do |basename, dir, opts|
+        .each do |dir, basename, opts|
           args = kwargs.dup
           args.merge!(opts) if opts
-          add(basename, dir, group: name, **args)
+          add(dir, basename, group: val, **args, &blk)
         end
         self
       end
 
       def compose(name, &blk)
-        namespace(task_name(name), &blk)
+        namespace(task_name(name), &blk) if block_given?
         self
       end
 
@@ -191,49 +282,77 @@ module Squared
             end
           end
         end
-        apply_style(data || theme, name, *args, empty: empty) unless target && !data
+        apply_style(data || theme, name, args, empty: empty) unless target && !data
         self
       end
 
-      def banner(*order, command: true, styles: [], border: [], group: nil, ref: nil)
-        return (group && @banner[group.to_sym]) || @banner[:"_#{ref || ''}"] if order.empty?
+      def find(path = nil, name: nil)
+        path = root_path(path) if path
+        ret = @project.find { |_, item| (path && item.path == path) || (name && item.name == name.to_s) }&.last
+        return ret unless block_given?
 
-        key = if group ||= @group
-                group.to_sym
-              else
-                :"_#{ref || @ref || ''}"
-              end
-        data = { command: command, order: [], styles: check_style(styles, empty: false), border: check_style(border) }
-        order.flatten.each do |val|
-          case (val = val.to_sym)
-          when :name, :project, :path, :ref, :group
-            data[:order] << val
-          end
-        end
-        @banner[key] = data if command || !data[:order].empty?
+        yield ret if ret
         self
       end
 
-      def script(*args, group: nil, ref: nil)
-        if group
-          @script[:group][group.to_sym]
-        elsif ref
-          @script[:ref][ref.to_sym]
-        elsif (val = @script[:build])
-          r = @script[:ref][:_]
-          g = @script[:group][:_]
-          args.empty? || (!r && !g) || (r && args.include?(r)) || (g && args.include?(g)) ? [val, @script[:env]] : []
-        else
-          []
-        end
+      def find_base(obj)
+        Application.impl_project.find { |proj| obj.instance_of?(proj) }
       end
 
-      def env(key, default = nil, equals: nil, ignore: nil)
-        @env ||= main.gsub(/[^\w]+/, '_').upcase
-        ret = ENV.fetch("#{key}_#{@env}", ENV[key]).to_s
-        return ret == equals.to_s unless equals.nil?
+      def task_name(val, desc: false)
+        ret = @prefix ? task_join(@prefix, val) : val.to_s
+        desc ? ret.split(':').join(ARG[:SPACE]) : ret
+      end
+
+      def task_namespace(val, first: false)
+        return nil unless (ret = val.to_s.split(':')).size > 1
 
-        ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
+        first ? ret.first : task_join(*ret[0..-2])
+      end
+
+      def task_join(*val)
+        val.join(':')
+      end
+
+      def task_resolve(obj, key)
+        tasks = []
+        if (base = task_base?(key))
+          tasks << key if obj.has?(key, baseref)
+        elsif (batch = series.batch_get(key))
+          obj.allref.each do |ref|
+            next unless (data = batch[ref])
+
+            data.each do |val|
+              if (items = task_resolve(obj, val)).empty?
+                tasks.clear
+                break
+              end
+              tasks += items
+            end
+            return tasks unless tasks.empty?
+          end
+        elsif task_extend?(obj, key)
+          tasks << key
+        end
+        ret = []
+        if tasks.empty?
+          return [] if (base && !obj.ref?(baseref)) || !(data = series.alias_get(key))
+
+          obj.allref.each do |ref|
+            next unless (alt = data[ref])
+
+            ret = task_resolve(obj, alt)
+            break unless ret.empty?
+          end
+        else
+          tasks.each do |val|
+            target = task_join(obj.name, series.name_get(val))
+            return [] unless task_defined?(target)
+
+            ret << target
+          end
+        end
+        ret
       end
 
       def root_path(*args)
@@ -244,24 +363,33 @@ module Squared
         home.join(*args)
       end
 
-      def find_base(obj)
-        Application.impl_project.find { |proj| obj.instance_of?(proj) }
+      def script_find(*args)
+        args.reverse_each do |val|
+          next unless val && (ret = val.is_a?(::Symbol) ? @script[:ref!][val] : @script[:group!][val.to_sym])
+
+          return ret
+        end
+        @script[:ref!][:_] || SCRIPT_OBJ
       end
 
-      def task_name(val, desc: false)
-        ret = @prefix ? "#{@prefix}:#{val}" : val.to_s
-        desc ? ret.split(':').join(' => ') : ret
+      def script_get(group: nil, ref: nil)
+        if group
+          @script[:group][group.to_sym]
+        elsif ref
+          @script[:ref][ref]
+        end
       end
 
-      def task_namespace(val, first: false)
-        return nil unless (val = val.to_s).include?(':')
+      def banner_get(*ref, group: nil)
+        ret = nil
+        return ret if group && (ret = @banner[:group][group.to_sym])
 
-        ret = val.split(':')
-        first ? ret.first : ret[0..-2].join(':')
+        ref.reverse_each { |val| return ret if (ret = @banner[:ref][val]) }
+        @banner[:ref][:_]
       end
 
       def to_s
-        root.to_s
+        (home? ? home : root).to_s
       end
 
       def inspect
@@ -269,42 +397,55 @@ module Squared
       end
 
       def enabled?
-        !@extensions.empty? || @project.any? { |_, proj| proj.enabled? }
+        !@extensions.empty? || @project.values.any?(&:enabled?)
+      end
+
+      def task_base?(key)
+        series.base?(key)
       end
 
       def task_extend?(obj, key)
         series.extend?(obj, key)
       end
 
-      def task_defined?(key, *)
-        ::Rake::Task.task_defined?(key)
+      def task_include?(obj, key, ref = nil)
+        task_base?(key) ? obj.has?(key, ref || baseref) : task_extend?(obj, key)
       end
 
-      def dev?(global: nil, **kwargs)
-        script?(:dev, global: global.nil? ? kwargs[:pat].nil? : global, **kwargs)
+      def task_defined?(*key)
+        ::Rake::Task.task_defined?(key.size == 1 ? key.first : task_join(*key))
       end
 
-      def prod?(global: false, **kwargs)
-        return false if global && (@script[:dev] == true || !@script[:prod])
+      def dev?(**kwargs)
+        script?(:dev, **kwargs)
+      end
 
-        script?(:prod, global: global, **kwargs)
+      def prod?(**kwargs)
+        script?(:prod, **kwargs)
       end
 
-      private
+      def home?
+        !(proj = find(home)).nil? && proj.enabled?
+      end
 
-      def __build__(**kwargs)
-        if !task_defined?('default') && (target = kwargs[:default]) && task_defined?(target = task_name(target))
-          task 'default' => target
-        end
-        return unless series.some?(:build)
+      def baseref
+        Application.baseref
+      end
 
-        init = [task_name('depend'), task_name(dev? && series.some?(:refresh) ? 'refresh' : 'build')]
+      def invokeargs
+        { exception: exception, warning: warning }
+      end
+
+      private
 
-        task 'default' => init[1] unless task_defined?('default')
-        return unless series.some?(:depend) && !task_defined?(key = task_name('init'))
+      def __build__(default: nil, **)
+        if default && task_defined?(t = task_name(default)) && !task_defined?(n = ::Rake.application.default_task_name)
+          task n => t
+        end
+      end
 
-        desc key
-        task key => init
+      def puts(*args)
+        puts_oe(*args, pipe: pipe)
       end
 
       def script_command(task, val, group, ref)
@@ -319,23 +460,30 @@ module Squared
         self
       end
 
-      def script?(state, script: nil, pat: nil, ref: nil, group: nil, global: false)
-        r = @script[:ref][:_]
-        g = @script[:group][:_]
-        if global && ((!ref && !group) || (!r && !g) || (ref && contains?(r, ref)) || (group && contains?(g, group)))
-          pat = @script[state] if pat.nil?
-          script ||= @script[:build]
-        end
-        if pat.is_a?(::Regexp)
-          script = script[state == :prod ? 1 : 0] if script.is_a?(::Array)
-          pat.match?(script)
+      def script_set(data, group: nil, ref: nil)
+        data.freeze
+        if group
+          as_a(group).each { |val| @script[:group!][val.to_sym] = data }
+        elsif ref
+          as_a(ref).each { |val| @script[:ref!][val.to_sym] = data }
         else
-          pat == true
+          @script[:ref!][:_] = data
         end
       end
 
-      def contains?(data, val)
-        as_a(data).any? { |item| item.to_s == val.to_s }
+      def script_obj
+        SCRIPT_OBJ.dup
+      end
+
+      def script?(state, target: nil, pat: nil, group: nil, ref: baseref, global: false)
+        data = script_find(ref, group)
+        if global
+          target = data[:script] || data[:run] if target.nil?
+          pat = data[state] if pat.nil?
+        end
+        return false if state == :prod && data[:dev] == true && data[:global]
+
+        target && pat.is_a?(::Regexp) ? as_a(target).any? { |val| pat.match?(val) } : pat == true
       end
     end
   end