squared 0.0.10 → 0.0.12

data/lib/squared/workspace/application.rb

@@ -3,8 +3,8 @@
 module Squared
   module Workspace
     class Application
-      include Common
-      include Format
+      include Common::Format
+      include Utils
       include ::Rake::DSL
 
       SCRIPT_OBJ = {
@@ -20,54 +20,63 @@ module Squared
       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 < impl_project
+
+            kind_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
+            if (args = obj.bannerargs)
+              @attr_banner += args
             end
           end
         end
 
         def find(ref = nil, path: nil)
-          if ref && (ret = impl_project.find { |proj| proj.ref == ref.to_sym })
+          if ref && (ret = kind_project.find { |proj| proj.ref == ref })
             ret
           elsif path
-            impl_project.find { |proj| proj.is_a?(path) }
+            kind_project.find { |proj| proj.config?(path) }
           end
         end
 
+        def baseref
+          impl_project.ref
+        end
+
         def to_s
-          super.to_s.match(/[^:]+$/)[0]
+          super.match(/[^:]+$/)[0]
         end
 
-        attr_reader :impl_project, :impl_series
+        attr_reader :kind_project
+        attr_accessor :impl_series, :impl_project, :attr_banner
       end
 
-      @impl_project = []
-      @impl_series = Workspace::Series
+      @kind_project = []
 
-      attr_reader :root, :home, :main, :prefix, :series, :theme
-      attr_accessor :exception, :pipe, :verbose, :warning
+      attr_reader :root, :home, :main, :prefix, :exception, :warning, :pipe, :verbose, :theme, :series, :closed
 
-      def initialize(home = Dir.pwd, *,
-                     main: nil, prefix: nil, verbose: nil,
-                     common: Common::KEY[:COMMON], pipe: Common::KEY[:PIPE], exception: Common::KEY[:FAIL], **)
-        @home = (home = Pathname.new(home)).realdirpath
-        @main = (main || home.basename).to_s
+      def initialize(home = Dir.pwd, *, main: nil, prefix: nil,
+                     verbose: ARG[:VERBOSE], 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 = []
-        @pipe = env_pipe(pipe)
+        @pipe = env_pipe(pipe, (ARG[:OUT] && env(ARG[:OUT])) || 1, root: @home)
         @exception = env_bool(exception)
-        @verbose = verbose.nil? ? @pipe > 0 : verbose
+        @verbose = env_bool(verbose, verbose.nil? || verbose.is_a?(::String) ? @pipe != 0 : verbose)
         @warning = @verbose != false
-        @envname = @main.gsub(/[^\w]+/, '_').upcase
+        @closed = false
         if common
           @theme = __get__(:theme)[:workspace]
-          __set__(:no_color, true) if @pipe == 0
+          ARG[:COLOR] = false if @pipe == 0 || @pipe.is_a?(::Pathname)
         else
           @theme = {}
         end
@@ -81,46 +90,59 @@ module Squared
           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)
+        return self unless enabled? && !@closed
+
+        kwargs[:parallel] = parallel.map(&:to_s)
         @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) }
+        Application.kind_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
+        self
       end
 
-      def with(*val, &blk)
+      def with(*val, group: nil, **kwargs, &blk)
         @group = nil
         @ref = nil
+        @withargs = kwargs.empty? ? nil : kwargs
+        val = as_a(group || kwargs[:ref], flat: true, compact: true) 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
         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
@@ -133,6 +155,10 @@ module Squared
         script_command :depend, script, group, ref
       end
 
+      def graph(script, group: @group, ref: @ref)
+        script_command :graph, as_a(script, :to_s).freeze, group, ref
+      end
+
       def clean(script, group: @group, ref: @ref)
         script_command :clean, script, group, ref
       end
@@ -153,48 +179,97 @@ module Squared
         script_command :exclude, as_a(base, :to_sym).freeze, group, ref
       end
 
-      def add(path, name = nil, **kwargs, &blk)
+      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, project = 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?(::Symbol)
                 @ref
               end
-        kwargs[:group] = @group if !kwargs.key?(:group) && @group.is_a?(::String)
-        path = root_path(path)
-        name ||= path.basename.to_s
+        if @group.is_a?(::String) && !kwargs.key?(:group)
+          kwargs = kwargs.dup unless @withargs
+          kwargs[:group] = @group
+        end
+        path = rootpath(path)
+        project = (project || path.basename).to_s
+        name = task_name(project)
+        index = 0
+        while @project[name]
+          index += 1
+          name = "#{project}-#{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, name, **kwargs)
+        @project[name] = proj
         __get__(:project)[name] = proj unless kwargs[:private]
         proj.instance_eval(&blk) if block_given?
         self
       end
 
-      def group(path, name, override: {}, **kwargs)
-        root_path(path).children.map do |ent|
-          next unless (dir = Pathname.new(ent)).directory?
+      def group(path, val, override: {}, **kwargs, &blk)
+        rootpath(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]]
+          basename = dir.basename.to_s
+          [dir, basename, override[basename.to_sym]]
         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
 
@@ -203,7 +278,7 @@ module Squared
         self
       end
 
-      def style(name, *args, target: nil, empty: false)
+      def style(obj, *args, target: nil, empty: false)
         data = nil
         if target
           as_a(target).each_with_index do |key, i|
@@ -214,79 +289,103 @@ module Squared
             end
           end
         end
-        apply_style(data || theme, name, *args, empty: empty) unless target && !data
+        apply_style(data || theme, obj, args, empty: empty) unless target && !data
         self
       end
 
-      def banner(*order, command: true, styles: [], border: [], group: nil, ref: nil)
-        if order.empty?
-          return (group && @banner[:group][group.to_sym]) || (ref && @banner[:ref][ref]) || @banner[:ref][:_]
-        end
+      def find(path = nil, name: nil)
+        path &&= rootpath(path)
+        name &&= name.to_s
+        ret = @project.find { |_, item| (path && item.path == path) || (name && item.name == name) }&.last
+        return ret unless block_given?
 
-        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
-        if command || !data[:order].empty?
-          if group ||= @group
-            label = :group
-            items = as_a(group)
-          else
-            label = :ref
-            items = as_a(ref || @ref || :_)
-          end
-          items.each { |val| @banner[label][val.to_sym] = data }
-        end
+        yield ret if ret
         self
       end
 
-      def script(*args, group: nil, ref: nil)
-        return @script[:group][group.to_sym] if group
-        return @script[:ref][ref] if ref
-
-        args.reverse_each do |val|
-          next unless val && (ret = val.is_a?(::Symbol) ? @script[:ref!][val] : @script[:group!][val.to_sym])
+      def find_base(obj)
+        Application.kind_project.find { |proj| obj.instance_of?(proj) }
+      end
 
-          return ret
-        end
-        @script[:ref][:_] || SCRIPT_OBJ
+      def task_name(val, desc: false)
+        ret = @prefix ? task_join(@prefix, val) : val.to_s
+        desc ? ret.split(':').join(ARG[:SPACE]) : ret
       end
 
-      def env(key, default = nil, equals: nil, ignore: nil)
-        ret = (ENV["#{key}_#{@envname}"] || ENV[key]).to_s
-        return ret == equals.to_s unless equals.nil?
+      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 root_path(*args)
-        root.join(*args)
-      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])
 
-      def home_path(*args)
-        home.join(*args)
+            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 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 (ret = val.to_s.split(':')).size > 1
+      def banner_get(*ref, group: nil)
+        ret = nil
+        return ret if group && (ret = @banner[:group][group.to_sym])
 
-        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
@@ -297,12 +396,20 @@ module Squared
         !@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 task_defined?(*key)
+        ::Rake::Task.task_defined?(key.size == 1 ? key.first : task_join(*key))
       end
 
       def dev?(**kwargs)
@@ -313,25 +420,38 @@ module Squared
         script?(:prod, **kwargs)
       end
 
-      private
+      def home?
+        !(proj = find(home)).nil? && proj.enabled?
+      end
 
-      def __build__(default: nil, **)
-        if !task_defined?('default') && default && task_defined?(target = task_name(default))
-          task 'default' => target
-        end
-        return unless series.some?(:build)
+      def rootpath(*args)
+        root.join(*args)
+      end
+
+      def homepath(*args)
+        home.join(*args)
+      end
+
+      def baseref
+        Application.baseref
+      end
+
+      def invokeargs
+        { exception: exception, warning: warning }
+      end
 
-        init = [task_name('depend'), task_name(dev?(global: true) && series.some?(:refresh) ? 'refresh' : 'build')]
+      public :task_join
 
-        task 'default' => init[1] unless default || task_defined?('default')
-        return unless series.some?(:depend) && !task_defined?(key = task_name('init'))
+      private
 
-        desc key
-        task key => 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
 
       def puts(*args)
-        @pipe == 2 ? $stderr.puts(*args) : $stdout.puts(*args)
+        puts_oe(*args, pipe: pipe)
       end
 
       def script_command(task, val, group, ref)
@@ -353,7 +473,7 @@ module Squared
         elsif ref
           as_a(ref).each { |val| @script[:ref!][val.to_sym] = data }
         else
-          @script[:ref][:_] = data
+          @script[:ref!][:_] = data
         end
       end
 
@@ -361,8 +481,8 @@ module Squared
         SCRIPT_OBJ.dup
       end
 
-      def script?(state, target: nil, pat: nil, group: nil, ref: Project::Base.ref, global: false)
-        data = script(ref, group)
+      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?