squared 0.0.10 → 0.0.11

data/lib/squared/config.rb

@@ -2,8 +2,6 @@
 
 require 'json'
 
-require_relative 'common'
-
 module Squared
   module Config
     class Viewer
@@ -21,9 +19,8 @@ module Squared
       attr_reader :main, :name, :project, :theme
       attr_accessor :pipe
 
-      def initialize(main, name = nil,
-                     project: nil, prefix: nil, dump: nil, opts: {}, auto: true,
-                     common: Common::KEY[:COMMON], pipe: Common::KEY[:PIPE], **)
+      def initialize(main, name = nil, project: nil, prefix: nil, dump: nil, opts: {}, auto: true,
+                     common: ARG[:COMMON], pipe: ARG[:PIPE], **)
         if project
           main = @project.base_path(main).to_s if (@project = __get__(:project)[project.to_sym])
           @required = true
@@ -63,10 +60,10 @@ module Squared
       def build
         return unless enabled?
 
-        params = ->(args) { exist? ? [realpath, [args.keys] + args.extras] : [args.keys, args.extras] }
-
         namespace(ns = task_name(name)) do
           view = @command && @command != name ? @command : 'view'
+          params = ->(args) { exist? ? [realpath, [args.keys] + args.extras] : [args.keys, args.extras] }
+
           namespace view do
             if @mime['json'] && (exist? || !::Rake::Task.task_defined?("#{ns}:#{view}:json"))
               desc format_desc(view, 'json')
@@ -96,7 +93,7 @@ module Squared
           require(gem || type)
           obj = eval(parse)
           ext << type if (ext = as_a(ext)).empty?
-          file = realpath if file.nil? && exist?
+          file = realpath if !file && exist?
 
           namespace task_name(name) do
             desc format_desc(command, *ext, exist: exist)
@@ -142,7 +139,7 @@ module Squared
       end
 
       def style(name, *args)
-        apply_style(theme, name, *args)
+        apply_style(theme, name, args)
         self
       end
 
@@ -163,11 +160,15 @@ module Squared
       def enabled?
         return File.exist?(realpath) if exist?
 
-        !@required || (!project.nil? && project.enabled?)
+        !@required || !!project&.enabled?
       end
 
       private
 
+      def puts(*args)
+        puts_oe(*args, pipe: pipe)
+      end
+
       def read_keys(reader, type, file, keys, ext: [type])
         if (mime = mime_type(file)) && base_path(file).exist?
           raise_error(file, mime, hint: 'invalid') unless ext.include?(mime)
@@ -208,7 +209,7 @@ module Squared
                   { pat: /^(.+ : (?!undefined))([^"\[{].*)$/m, styles: theme[:value], index: 2 }
                 ]
               end
-        emphasize(lines, title: title, sub: sub, pipe: pipe == 2 ? $stderr : nil)
+        emphasize(lines, title: title, sub: sub)
       end
 
       def print_keys(type, data, keys, file: nil)
@@ -266,19 +267,20 @@ module Squared
           'yaml'
         when 'js'
           'json'
+        when ''
+          nil
         else
-          ret.empty? ? nil : ret
+          ret
         end
       end
 
       def format_desc(command, *ext, exist: exist?)
-        message(@prefix || '', *name.split(':'), command,
-                "#{ext.first}[#{exist ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys*]")
+        val = "#{ext.first}[#{exist ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys+]"
+        message(@prefix, *name.split(':'), command, val, empty: true)
       end
 
       def realpath
-        file = main + @ext
-        Pathname.new(file).realdirpath.to_s rescue file
+        base_path(file = main + @ext).to_s rescue file
       end
 
       def exist?

data/lib/squared/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Squared
-  VERSION = '0.0.10'
+  VERSION = '0.0.11'
 end

data/lib/squared/workspace/application.rb

@@ -20,11 +20,15 @@ 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 < 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
@@ -33,41 +37,44 @@ 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, :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: 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 = []
-        @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 = verbose.nil? ? @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 +88,58 @@ module Squared
           group: {},
           ref: {}
         }.freeze
+        initialize_session
+      end
+
+      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(**kwargs)
-        kwargs[:parallel] = kwargs.fetch(:parallel, []).map(&:to_s)
-        return unless enabled?
+      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
+        @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
         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
@@ -153,48 +172,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, 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?(::Symbol)
                 @ref
               end
-        kwargs[:group] = @group if !kwargs.key?(:group) && @group.is_a?(::String)
+        if @group.is_a?(::String) && !kwargs.key?(:group)
+          kwargs = kwargs.dup unless @withargs
+          kwargs[:group] = @group
+        end
         path = root_path(path)
-        name ||= path.basename.to_s
+        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(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)
+        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
 
@@ -214,52 +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)
-        if order.empty?
-          return (group && @banner[:group][group.to_sym]) || (ref && @banner[:ref][ref]) || @banner[:ref][:_]
-        end
+      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?
 
-        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
+      def find_base(obj)
+        Application.impl_project.find { |proj| obj.instance_of?(proj) }
+      end
 
-        args.reverse_each do |val|
-          next unless val && (ret = val.is_a?(::Symbol) ? @script[:ref!][val] : @script[:group!][val.to_sym])
+      def task_name(val, desc: false)
+        ret = @prefix ? task_join(@prefix, val) : val.to_s
+        desc ? ret.split(':').join(ARG[:SPACE]) : ret
+      end
 
-          return ret
-        end
-        @script[:ref][:_] || SCRIPT_OBJ
+      def task_namespace(val, first: false)
+        return nil unless (ret = val.to_s.split(':')).size > 1
+
+        first ? ret.first : task_join(*ret[0..-2])
+      end
+
+      def task_join(*val)
+        val.join(':')
       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_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])
 
-        ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
+            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)
@@ -270,23 +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 (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 +400,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 +424,28 @@ 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 baseref
+        Application.baseref
+      end
 
-        init = [task_name('depend'), task_name(dev?(global: true) && series.some?(:refresh) ? 'refresh' : 'build')]
+      def invokeargs
+        { exception: exception, warning: warning }
+      end
 
-        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 +467,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 +475,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?