squared 0.0.9 → 0.0.10

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'date'
 require 'logger'
 
@@ -12,9 +13,13 @@ module Squared
         include System
         include Shell
         include Task
+        include Utils
         include ::Rake::DSL
 
-        SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+))?/.freeze
+        SEM_VER = /(\d+)(?:(\.)(\d+))?(?:(\.)(\d+)(\S+)?)?/.freeze
+
+        VAR_SET = %i[parent global envname theme run script env depend doc test copy clean].freeze
+        private_constant :VAR_SET
 
         class << self
           def populate(*); end
@@ -44,9 +49,12 @@ module Squared
         @@print_order = 0
         @@tasks = {}
 
-        attr_reader :name, :project, :workspace, :group, :path, :theme
+        attr_reader :name, :project, :workspace, :group, :path, :theme, :parent
+        attr_accessor :exception, :pipe, :verbose
 
-        def initialize(name, path, workspace, *, group: nil, **kwargs)
+        def initialize(name, path, workspace, *,
+                       group: nil, verbose: nil, pass: nil, exclude: nil,
+                       common: Common::KEY[:COMMON], pipe: Common::KEY[:PIPE], **kwargs)
           @name = name.to_s
           @path = path
           @project = @path.basename.to_s
@@ -55,23 +63,82 @@ module Squared
           @depend = kwargs[:depend]
           @doc = kwargs[:doc]
           @test = kwargs[:test]
-          @output = [kwargs[:run], nil]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
-          @theme = if !workspace.verbose
+          @exception = workspace.exception
+          @pipe = env_pipe(pipe, workspace.pipe)
+          @verbose = verbose.nil? ? workspace.verbose : verbose
+          @theme = if !@verbose
                      {}
-                   elsif kwargs.fetch(:common, true)
+                   elsif common
                      workspace.theme
                    else
                      __get__(:theme)[:project][to_sym] ||= {}
                    end
+          @output = []
           @ref = []
-          @exclude = as_a(kwargs[:exclude], :to_sym).freeze
+          @children = []
+          @pass = (pass ? as_a(pass, :to_sym) : []).freeze
+          @exclude = (exclude ? as_a(exclude, :to_sym) : []).freeze
+          @envname = @name.gsub(/[^\w]+/, '_').upcase
+          @desc = @name.split(':').join(' => ')
+          @global = false
+          run_set kwargs[:run], kwargs[:env]
           initialize_ref(Base.ref)
+        end
+
+        def initialize_ref(ref)
+          @ref << ref unless @exclude.include?(ref)
+        end
+
+        def initialize_build(ref, **kwargs)
+          initialize_ref(ref)
+          if (@script = @workspace.script(group: @group, ref: ref))
+            if @script[:log] && !kwargs.key?(:log)
+              kwargs[:log] = @script[:log]
+              @log = nil
+            end
+            @depend = @script[:depend] if @depend.nil?
+            @doc = @script[:doc] if @doc.nil?
+            @test = @script[:test] if @test.nil?
+            @clean = @script[:clean] if @clean.nil?
+            @exclude = @script[:exclude] if @exclude.empty? && @script.key?(:exclude)
+          end
           initialize_logger(**kwargs)
+          return if @output[0] == false
+
+          data = @workspace.script(*@ref, @group)
+          if @output[0].nil?
+            if (scr = data[:script])
+              @global = true
+              script_set(scr, prod: kwargs[:prod])
+            elsif (run = data[:run])
+              @global = true
+              run_set run
+            end
+            unless data[:env]
+              if (scr = kwargs[:script])
+                @global = false
+                script_set scr
+              elsif @script && !data[:global]
+                if (scr = @script[:script])
+                  @global = false
+                  script_set scr
+                elsif (run = @script[:run])
+                  @global = false
+                  run_set run
+                end
+              end
+            end
+          elsif data[:env] && data[:run]
+            @global = true
+            run_set data[:run]
+          end
         end
 
         def initialize_logger(log: nil, **)
+          return if @log
+
           log = log.is_a?(::Hash) ? log.dup : { file: log }
           if (file = env('LOG_FILE')).nil? && (auto = env('LOG_AUTO'))
             file = case auto
@@ -89,49 +156,41 @@ module Squared
             begin
               file = file.realdirpath
             rescue StandardError => e
-              raise if @workspace.exception
+              raise if @exception
 
               file = nil
-              warn e if @workspace.warning
+              warn log_message(::Logger::WARN, e) if warning?
             end
           end
-          log[:progname] = @name
-          log[:level] = env('LOG_LEVEL', log[:level] || Logger::INFO, ignore: nil)
+          log[:progname] ||= @name
+          if (val = env('LOG_LEVEL', ignore: nil))
+            log[:level] = val
+          end
           log.delete(:file)
           @log = [file, log]
         end
 
-        def initialize_build(ref, **kwargs)
-          initialize_script(ref, **kwargs)
-          if (val = env('BUILD', strict: true))
-            @output[0] = val
-          elsif @script && @output[0] != false
-            @output[0] ||= @script[:run]
-          end
-          @dev = kwargs.delete(:dev)
-          if env('BUILD', suffix: 'DEV', equals: '0')
-            @dev = false
-          elsif env('BUILD', suffix: 'DEV')
-            @dev = true
-          elsif @dev.nil?
-            @dev = !group.nil? && workspace.dev?(group: group, global: true)
+        def initialize_env(dev: nil, prod: nil, **)
+          prefix = "BUILD_#{@envname}"
+          @dev = env_match("#{prefix}_DEV", dev)
+          @prod = env_match("#{prefix}_PROD", prod)
+          if (val = env('BUILD', suffix: 'ENV'))
+            begin
+              data = JSON.parse(val)
+              raise_error('invalid JSON object', val, hint: "#{prefix}_ENV") unless data.is_a?(::Hash)
+              @output[2] = data
+            rescue StandardError => e
+              log.warn e
+            end
           end
-        end
+          return unless (val = env('BUILD', strict: true))
 
-        def initialize_script(ref, **)
-          initialize_ref(ref)
-          return unless (script = workspace.script(group: group, ref: ref))
-
-          @depend = script[:depend] if @depend.nil?
-          @doc = script[:doc] if @doc.nil?
-          @test = script[:test] if @test.nil?
-          @clean = script[:clean] if @clean.nil?
-          @exclude = script[:exclude] if @exclude.empty? && script.key?(:exclude)
-          @script = script
-        end
-
-        def initialize_ref(ref)
-          @ref << ref unless @exclude.include?(ref)
+          @global = false
+          if script?
+            script_set val
+          else
+            run_set(val, opts: false)
+          end
         end
 
         def ref
@@ -139,28 +198,51 @@ module Squared
         end
 
         def populate(*)
-          valid = ref?(Base.ref)
-          series = workspace.series
+          check = lambda do |proj, key|
+            workspace.series.include?(key) ? proj.has?(key, Base.ref) : workspace.task_extend?(proj, key)
+          end
 
           namespace name do
-            series.each_key do |key|
-              next unless series.include?(key) ? has?(key) && valid : workspace.task_extend?(self, key)
+            workspace.series.each_key do |key|
+              next unless check.(self, key)
 
-              desc message(*name.split(':'), key)
-              task key do
-                __send__(key)
+              unless workspace.task_defined?("#{name}:#{key}")
+                desc message(@desc, key)
+                task key do
+                  __send__(key)
+                end
               end
+              next if (items = @children.select { |item| check.(item, key) }).empty?
+
+              desc message(@desc, key, 'workspace')
+              task "#{key}:workspace" => items.map { |item| "#{item.name}:#{key}" }
             end
           end
         end
 
+        def add(path, name = nil, **kwargs, &blk)
+          return self unless source_path?(path = base_path(path))
+
+          kwargs[:group] = group unless kwargs.key?(:group)
+          kwargs[:ref] = ref unless kwargs.key?(:ref)
+          parent = self
+          proj = nil
+          workspace.add(path, name || path.basename.to_s, **kwargs) do
+            variable_set :parent, parent
+            proj = self
+          end
+          @children << proj
+          proj.instance_eval(&blk) if block_given?
+          self
+        end
+
         def build(*args, sync: true)
           if args.empty?
-            cmd, opts = @output
-            opts &&= shell_escape(opts)
+            cmd, opts, var = @output
+            opts &&= shell_split(opts, join: true)
           else
             cmd = args.shift
-            opts = sanitize_args(*args)
+            opts = args.map { |val| shell_quote(val, force: false) }.join(' ')
           end
           if cmd
             if opts
@@ -168,24 +250,21 @@ module Squared
             elsif cmd.is_a?(::Array)
               cmd = cmd.join(' && ')
             end
-            banner = verbose?
+            banner = verbose != false
           else
             return unless respond_to?(:compose)
 
             cmd = compose(opts)
-            banner = env('REPO_BUILD') == 'verbose'
+            banner = verbose == 1
           end
-          run(cmd, banner: banner, sync: sync)
+          run(cmd, var, banner: banner, sync: sync)
         end
 
         def refresh(*)
-          build(sync: invoked_sync?('depend'))
-          key = "#{name}:copy"
-          if workspace.task_defined?(key)
-            invoke(key, exception: workspace.exception, warning: workspace.warning)
-          else
-            copy
-          end
+          build(sync: invoked_sync?('refresh') || invoked_sync?('build'))
+          return if run_task "#{name}:copy"
+
+          copy if copy?
         end
 
         def depend(*)
@@ -205,14 +284,12 @@ module Squared
         end
 
         def clean
-          return unless @clean
-
-          if @clean.is_a?(::String)
+          case @clean
+          when ::String
             run_s(@clean, sync: invoked_sync?('clean'))
-          else
-            @clean.each do |val|
-              val = val.to_s
-              if val =~ %r{[\\/]$}
+          when ::Enumerable
+            as_a(@clean).each do |val|
+              if (val = val.to_s) =~ %r{[\\/]$}
                 dir = Pathname.new(val)
                 dir = base_path(dir) unless dir.absolute?
                 next unless dir.directory?
@@ -234,15 +311,43 @@ module Squared
         end
 
         def log
-          return @log unless @log.is_a?(::Array)
-
-          @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
+          if @log.is_a?(::Array)
+            @log = Logger.new(enabled? ? @log[0] : nil, **@log[1])
+          else
+            @log
+          end
         end
 
         def base_path(*args)
           path.join(*args)
         end
 
+        def color(val)
+          ret = theme[val]
+          ret && !ret.empty? ? ret : [val]
+        end
+
+        def variable_set(key, *val, **kwargs)
+          if variable_all.include?(key)
+            case key
+            when :run
+              run_set(*val, opts: false, **kwargs)
+            when :script
+              script_set(*val, **kwargs)
+            when :env
+              run_set(output[0], *val, opts: false, **kwargs)
+            else
+              instance_variable_set :"@#{key}", val.first
+            end
+          else
+            log.warn "variable_set: @#{key} (not defined)"
+          end
+        end
+
+        def variable_all
+          VAR_SET
+        end
+
         def inspect
           "#<#{self.class}: #{name} => #{self}>"
         end
@@ -255,12 +360,16 @@ module Squared
           name.to_sym
         end
 
-        def enabled?
+        def enabled?(ref = nil)
+          return false if ref && !ref?(ref)
+
           path.directory? && !path.empty?
         end
 
-        def has?(method)
-          respond_to?(m = :"#{method}?") && __send__(m)
+        def has?(meth, ref = nil)
+          return false if ref && !ref?(ref)
+
+          respond_to?(meth = :"#{meth}?") && __send__(meth)
         end
 
         def ref?(val)
@@ -268,11 +377,15 @@ module Squared
         end
 
         def build?
-          !!@output[0]
+          !!@output[0] || script?
+        end
+
+        def script?
+          @output[0].nil? && !!@output[1] && respond_to?(:compose)
         end
 
         def refresh?
-          build? && (copy? || workspace.task_defined?("#{name}:copy"))
+          build? && copy?
         end
 
         def depend?
@@ -288,20 +401,24 @@ module Squared
         end
 
         def copy?
-          @copy.is_a?(::String)
+          runnable?(@copy) || workspace.task_defined?("#{name}:copy")
         end
 
         def clean?
-          !!@clean
+          runnable?(@clean) || workspace.task_defined?("#{name}:clean")
         end
 
         def dev?
-          !!@dev
+          @dev != false && workspace.dev?(pat: @dev, **scriptargs)
+        end
+
+        def prod?
+          @prod != false && workspace.prod?(pat: @prod, **scriptargs)
         end
 
         private
 
-        def run(cmd = @session, exception: workspace.exception, banner: true, sync: true, req: nil, **)
+        def run(cmd = @session, var = nil, exception: @exception, banner: true, sync: true, req: nil, **)
           if req && !base_path(req).exist?
             log.warn "#{req} (not found)"
             return
@@ -311,10 +428,12 @@ module Squared
           begin
             if cmd =~ /^\S+:(\S+:?)+$/ && workspace.task_defined?(cmd)
               print_item if sync
-              invoke(cmd, exception: exception, warning: workspace.warning)
+              log.warn "ENV was discarded: #{var}" if var
+              invoke(cmd, exception: exception, warning: warning?)
             else
               print_item format_banner(cmd, banner: banner) if sync
-              shell(cmd, chdir: path, exception: exception)
+              args = var.is_a?(::Hash) ? [var, cmd] : [cmd]
+              shell(*args, chdir: path, exception: exception)
             end
           rescue StandardError => e
             log.error e
@@ -323,15 +442,21 @@ module Squared
         end
 
         def run_s(cmd, **kwargs)
-          run(cmd, banner: verbose?, **kwargs) if cmd.is_a?(::String)
+          as_a(cmd).each { |val| run(val, banner: !!verbose, **kwargs) if val.is_a?(::String) }
+        end
+
+        def run_task(key)
+          return false unless workspace.task_defined?(key)
+
+          invoke(key, exception: exception, warning: warning?)
+          true
         end
 
         def env(key, default = nil, equals: nil, ignore: ['0'].freeze, suffix: nil, strict: false)
-          @env ||= name.gsub(/[^\w]+/, '_').upcase
-          a = "#{key}_#{@env}"
+          a = "#{key}_#{@envname}"
           b = ''
           if suffix
-            a = [a, suffix].flatten.join('_')
+            a = "#{a}_#{suffix}"
           elsif !strict
             b = ENV.fetch(key, '')
           end
@@ -341,8 +466,12 @@ module Squared
           ret.empty? || as_a(ignore).any? { |val| ret == val.to_s } ? default : ret
         end
 
-        def session(*cmd, options: nil)
-          if (val = ENV["#{(options || cmd.first).upcase}_OPTIONS"])
+        def puts(*args)
+          pipe == 2 ? $stderr.puts(*args) : $stdout.puts(*args)
+        end
+
+        def session(*cmd, prefix: nil)
+          if (val = ENV["#{(prefix || cmd.first).upcase}_OPTIONS"])
             split_escape(val).each { |opt| cmd << fill_option(opt) }
           end
           @session = JoinSet.new(cmd)
@@ -351,13 +480,13 @@ module Squared
         def close_session(cmd)
           return cmd unless cmd.respond_to?(:done)
 
-          raise_error('none were provided', hint: name) if cmd.empty?
+          raise_error('no args were added', hint: cmd.first || name) unless cmd.size > 1
           @session = nil if cmd == @session
           cmd.done
         end
 
         def print_item(*val)
-          puts unless @@print_order == 0 || pipe?
+          puts unless @@print_order == 0 || stdin?
           @@print_order += 1
           puts val unless val.empty? || (val.size == 1 && val.first.nil?)
         end
@@ -407,7 +536,7 @@ module Squared
             action = ''
           end
           req = opts ? "#{req}," : "[#{req}]" unless req.to_s.empty?
-          message(*name.split(':'), action, opts ? "#{flag}[#{req}#{opts}]" : flag.to_s + req)
+          message(@desc, action, opts ? "#{flag}[#{req}#{opts}]" : flag.to_s + req)
         end
 
         def format_banner(cmd, banner: true, multiple: false)
@@ -418,7 +547,7 @@ module Squared
           else
             data = { command: true, order: %i[path], styles: theme[:banner], border: theme[:border] }
           end
-          if verbose?
+          if verbose
             out = []
             out << cmd.sub(/^\S+/, &:upcase) if data[:command]
             data[:order].each { |val| out << val.to_s if (val = __send__(val)) }
@@ -432,8 +561,16 @@ module Squared
           "#{msg}#{!always && (!obj || obj == 0 || obj.to_s.empty?) ? '' : message(hint: message(title, obj.to_s))}"
         end
 
+        def append_repeat(flag, opts)
+          opts.each { |val| @session << "--#{flag}=#{shell_escape(val, quote: true)}" }
+        end
+
+        def append_value(opts)
+          opts.each { |val| @session << val }
+        end
+
         def append_nocolor
-          @session << (!ENV.fetch('NO_COLOR', '').empty? || pipe? ? '--no-color' : '')
+          @session << (!ENV.fetch('NO_COLOR', '').empty? || stdin? ? '--no-color' : '')
         end
 
         def guard_params(action, flag, args: nil, key: nil, pat: nil)
@@ -450,12 +587,26 @@ module Squared
           end
         end
 
-        def store_pwd(done = nil)
-          if @pwd
+        def pwd_set(done = nil, &blk)
+          pwd = Pathname.pwd
+          if block_given?
+            if path == pwd
+              instance_eval(&blk)
+            else
+              Dir.chdir(path)
+              instance_eval(&blk)
+              Dir.chdir(pwd)
+            end
+          elsif @pwd == pwd
+            @pwd = nil
+            pwd unless done
+          elsif @pwd
+            return unless path == pwd
+
             Dir.chdir(@pwd)
             @pwd = nil
-          elsif !done && Dir.pwd != path.to_s
-            @pwd = Dir.pwd
+          elsif !done && path != pwd
+            @pwd = pwd
             Dir.chdir(path)
             @pwd
           end
@@ -474,37 +625,72 @@ module Squared
         end
 
         def semmajor(cur, want)
-          cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]
+          (cur[0] == '0' && want[0] == '0' ? cur[2] != want[2] : cur[0] != want[0]) && !want[5]
         end
 
-        def verbose?
-          workspace.verbose
+        def scriptargs
+          { target: script? ? @output[1] : @output[0], ref: ref, group: group, global: @global }
         end
 
-        def pipe?
-          workspace.pipe
+        def run_set(cmd, val = nil, *, opts: true, **)
+          @output[0] = cmd
+          @output[1] = if cmd && opts
+                         env('BUILD', opts.is_a?(::String) ? opts : nil, suffix: 'OPTS')
+                       end
+          if val.is_a?(::Hash)
+            @output[2] = val
+          elsif val == false
+            @output[2] = nil
+          end
         end
 
-        def invoked_sync?(action, flag = nil)
-          action = workspace.task_name(action)
-          return true if !flag.nil? || workspace.series.sync?("#{action}:sync")
+        def script_set(cmd, *, prod: nil, **)
+          @output[0] = nil
+          @output[1] = if @global && cmd.is_a?(::Array)
+                         cmd[prod == true ? 1 : 0]
+                       else
+                         cmd
+                       end
+        end
 
-          check = lambda do |val|
-            if invoked?(val)
-              !workspace.task_defined?("#{val}:sync")
-            elsif workspace.series.sync?("#{val}:sync")
-              true
-            end
-          end
-          if group
-            ret = check.("#{action}:#{group}")
-            return ret unless ret.nil?
+        def source_path?(val)
+          Pathname.new(val).absolute? ? val.to_s.start_with?(File.join(path, '')) : !val.to_s.match?(%r{^\.\.[/\\]})
+        end
+
+        def warning?
+          workspace.warning
+        end
+
+        def stdin?
+          pipe == 0
+        end
+
+        def runnable?(val)
+          case val
+          when ::String
+            true
+          when ::Enumerable
+            !val.is_a?(::Hash)
+          else
+            false
           end
-          if (base = workspace.find_base(self))
-            ret = check.("#{action}:#{base.ref}")
-            return ret unless ret.nil?
+        end
+
+        def from_sync?(val)
+          if invoked?(val)
+            !workspace.task_defined?("#{val}:sync")
+          elsif workspace.series.sync?("#{val}:sync")
+            true
           end
-          invoked?("#{name}:#{action}") && (!invoked?(action) || !workspace.task_defined?("#{action}:sync"))
+        end
+
+        def invoked_sync?(action, val = nil)
+          return true if !val.nil? || from_sync?(ac = workspace.task_name(action))
+
+          return val if group && !(val = from_sync?("#{ac}:#{group}")).nil?
+          return val if (base = workspace.find_base(self)) && !(val = from_sync?("#{ac}:#{base.ref}")).nil?
+
+          invoked?("#{name}:#{ac}") && (!invoked?(ac) || !workspace.task_defined?("#{ac}:sync"))
         end
       end
     end