squared 0.6.8 → 0.7.0

data/lib/squared/workspace/application.rb

@@ -6,35 +6,26 @@ module Squared
       include Enumerable
       include Common::Format
       include Utils
-      include Support::Variables
       include Rake::DSL
 
       TASK_METADATA = Rake::TaskManager.record_task_metadata
       private_constant :TASK_METADATA
 
       class << self
-        def implement(*objs, base: false)
-          return if base && objs.size > 1
-
-          objs.each do |obj|
-            next unless base || obj < impl_project
-
-            if base
-              self.impl_project = obj
-              impl_series.base_set(obj)
-            else
-              kind_project.unshift(obj)
-              impl_series.extend_set(obj)
-            end
-            if (args = obj.batchargs)
-              impl_series.batch(*args)
-            end
-            if (args = obj.aliasargs)
-              impl_series.alias(*args)
-            end
-            if (args = obj.bannerargs)
-              attr_banner.merge(args)
+        def implement(*objs, base: nil)
+          objs.each_with_index do |obj, index|
+            if base && index == 0
+              case base
+              when 0, true
+                @kind_extend[0] = obj
+                next
+              when 1
+                @kind_extend.insert(1, obj)
+              else
+                @kind_extend.push(obj)
+              end
             end
+            kind_project.unshift(obj) if extends(obj)
           end
         end
 
@@ -42,17 +33,14 @@ module Squared
           if ref && (ret = kind_project.find { |proj| proj.ref == ref })
             ret
           elsif path
-            kind_project.find { |proj| proj.config?(path) }
+            (kind_project - @kind_extend).find { |proj| proj.config?(path) } ||
+            @kind_extend.find { |proj| proj.config?(path) }
           end
         end
 
-        def exclude(*args)
-          @task_exclude.merge(args.map!(&:to_sym))
-        end
-
-        def register(app)
+        def register(app, base, exclude: [])
           @session << app
-          impl_series.new(app, exclude: @task_exclude.to_a)
+          impl_series.new(app, (@kind_extend + base).uniq, exclude: exclude.map(&:to_sym))
         end
 
         def load_ref(path, gem: nil)
@@ -65,14 +53,23 @@ module Squared
                 break
               end
             end
-            dir = if gem.match?(/-\d+(?:\.|$)/)
+            dir = if gem.match?(/-\d+(\.|$)/)
                     gem
                   else
                     Dir.glob("#{gem}-*", base: @gemsdir).pop
                   end
             path = File.join(@gemsdir, dir, path) if dir
           end
-          @load_project.unshift(path.cleanpath.to_s) if (path = Pathname.new(path)).absolute? && path.exist?
+          path = Pathname.new(path)
+          @load_project.unshift(path.cleanpath.to_s) if path.absolute? && path.exist?
+        end
+
+        def extends(obj)
+          @kind_extend.any? { |impl| obj < impl }
+        end
+
+        def impl_project
+          @kind_extend.first
         end
 
         def baseref
@@ -83,40 +80,42 @@ module Squared
           super[/[^:]+\z/, 0]
         end
 
-        alias series_wrap register
-
-        attr_reader :kind_project, :load_project, :session
-        attr_accessor :impl_series, :impl_project, :attr_banner
+        attr_reader :kind_project, :load_project, :attr_banner, :session
+        attr_accessor :impl_series
       end
 
       @kind_project = []
       @load_project = [File.expand_path('project', __dir__)]
+      @attr_banner = Set.new
+      @kind_extend = []
       @session = []
-      @task_exclude = Set.new
 
       attr_reader :root, :home, :main, :prefix, :theme, :series, :closed
       attr_accessor :exception, :pipe, :verbose, :warning
 
       def initialize(home = (ARG[:HOME] && ENV[ARG[:HOME]]) || Dir.pwd, *, main: nil, prefix: nil,
                      verbose: ARG[:VERBOSE], common: ARG[:COMMON], pipe: ARG[:PIPE], exception: ARG[:FAIL], **)
-        @home = Pathname.new(home).realdirpath
-        basename = @home.basename.to_s
+        home = Pathname.new(home)
+        basename = home.basename.to_s
         if main
           @main = main.to_s.freeze
-          @home += @main unless @main == basename || (windows? && @main.casecmp?(basename))
+          home += @main unless @main == basename || (windows? && @main.casecmp?(basename))
         else
           @main = basename.freeze
         end
-        @home.mkpath rescue nil
-        @root = @home.parent
         @prefix = prefix
-        @series = Application.register(self)
         @project = {}
-        @kind = hashlist
-        @extensions = []
+        @base = Set.new
+        @kind = Support.hashlist
+        @config = {}
+        @extensions = Set.new
+        @finalize = Set.new([:__chain__])
         @envname = env_key(@main).freeze
+        @closed = false
+        @stage = Support.hashlist
+        self.home = home
         self.exception = env_bool exception
-        self.pipe = $DEBUG ? 2 : env_pipe(pipe, (ARG[:OUT] && env(ARG[:OUT])) || 1, root: @home)
+        self.pipe = $DEBUG ? 2 : env_pipe(pipe, (ARG[:OUT] && env(ARG[:OUT])) || 1, root: home)
         self.verbose = if $VERBOSE.nil?
                          false
                        elsif verbose.nil?
@@ -125,85 +124,93 @@ module Squared
                          env_bool(verbose, verbose.is_a?(String) ? @pipe != 0 : verbose, index: true)
                        end
         self.warning = @verbose != false
-        @closed = false
-        @theme = if common
-                   ARG[:COLOR] = false if @pipe == 0 || @pipe.is_a?(Pathname)
-                   __get__(:theme)[:workspace]
-                 else
-                   {}
-                 end
-        @chain = hashlist
-        @script = {
-          group: hashobj,
-          ref: hashobj,
-          group!: {},
-          ref!: {}
-        }.freeze
-        @events = {
-          group: hashobj,
-          ref: hashobj
-        }.freeze
-        @pass = {
-          group: hashobj,
-          ref: hashobj,
-          global: {},
-          pattern: []
-        }.freeze
-        @banner = {
-          group: {},
-          ref: {}
-        }.freeze
+        @theme = common ? __get__(:theme)[:workspace] : {}
+        @chain = Support.hashlist
+        @script = Struct::SessionData.new
+        @events = Struct::SessionData.new
+        @pass = Struct::SessionData.new
+        @banner = Struct::SessionData.new
+        @timeout = Struct::SessionData.new
+        @global = Hash.new do |data, key|
+          data[key] = { group: {}, ref: {}, exclude: [], extras: {}, module: nil, script: nil }
+        end
         initialize_session
       end
 
-      def initialize_session
-        return unless @pipe.is_a?(Pathname)
-
-        msg = "Session started on #{Time.now} by #{@main}"
-        bord = '#' * msg.size
-        puts bord, msg, bord
-      end
-
       def each(&blk)
         return to_enum(:each) unless block_given?
 
         @project.each_value(&blk)
       end
 
-      def build(parallel: [], pass: nil, **kwargs)
+      def build(parallel: [], **kwargs)
         return self unless enabled? && !@closed
 
+        self.closed = 'init'
         kwargs[:parallel] = if kwargs[:pattern].is_a?(Array)
                               parallel.map(&:to_s)
                             else
                               kwargs[:pattern] = []
-                              parallel.reject { |val| kwargs[:pattern] << val if val.is_a?(Regexp) }.map!(&:to_s)
+                              parallel.reject { |val| kwargs[:pattern] << val if val.is_a?(Regexp) }.map(&:to_s)
                             end
-        @pass[:pattern].concat(pass.map { |val| val.is_a?(Regexp) ? val : val.to_s }) if pass
-        series.reset
+        @pass.items.concat(kwargs[:pass].map { |val| val.is_a?(Regexp) ? val : val.to_s }) if kwargs[:pass]
+        @series = Application.register(self, @base.to_a, exclude: kwargs.fetch(:exclude, []))
+        self.closed = 'begin'
+        pb = @stage.key?('project:begin')
+        pe = @stage.key?('project:end')
+        keys = @series.keys
         each do |proj|
+          self.closed = ['project:begin', proj] if pb
           if proj.enabled?
-            proj.populate(series.keys.dup, **kwargs)
+            proj.populate(keys.dup, **kwargs)
           elsif proj.enabled?(base: false)
             proj.generate([], **kwargs)
           else
             next
           end
-          series.populate(proj, **kwargs)
+          @series.populate(proj, **kwargs)
+          self.closed = ['project:end', proj] if pe
         end
-        Application.kind_project.each { |obj| obj.populate(self, **kwargs) }
-        @extensions.uniq.each { |ext| __send__(ext, **kwargs) }
-        series.build(**kwargs)
+        self.closed = 'populate'
+        @base.each { |obj| obj.populate(self, **kwargs) }
+        self.closed = 'extensions'
+        @extensions.each { |ext| __send__(ext, **kwargs) }
+        self.closed = 'series'
+        @series.build(**kwargs)
         __build__(**kwargs)
-        yield self if block_given?
-        __chain__(**kwargs)
+        if block_given?
+          self.closed = 'yield:begin'
+          yield self
+          self.closed = 'yield:end'
+        end
+        self.closed = 'finalize'
+        @finalize.each { |ext| __send__(ext, **kwargs) }
+        self.closed = 'end'
         @closed = true
         self
       end
 
-      def with(*val, pass: false, group: nil, **kwargs, &blk)
-        return self if pass == true || (pass && as_a(pass, :to_s).any? { |s| respond_to?(s) && __send__(s) })
+      def with(*val, hide: false, group: nil, **kwargs, &blk)
+        if hide
+          return self if hide == true
+
+          Array(hide).each do |args|
+            if args.is_a?(Array)
+              if respond_to?(hint = args.first)
+                next unless __send__(*args)
 
+                return self
+              end
+            elsif respond_to?(args)
+              next unless __send__(args)
+
+              return self
+            end
+            raise_error 'method not found'
+          rescue => e
+            warn log_message(Logger::WARN, e, subject: main, hint: hint || args)
+          end
+        end
         @group = nil
         @ref = nil
         @withargs = unless kwargs.empty?
@@ -219,7 +226,7 @@ module Squared
         when Symbol
           @ref = val
         else
-          raise_error ArgumentError, 'missing group or ref' if block_given?
+          raise_error TypeError, "not a group/ref: #{kind || 'nil'}" if block_given?
         end
         if block_given?
           instance_eval(&blk)
@@ -236,18 +243,18 @@ module Squared
 
       def chain(task, *action, project: nil, step: 0, with: nil, before: nil, after: nil, sync: false,
                 group: @group, ref: @ref)
-        if project
-          action.map! { |val| task_join(project.name, val) }
-        elsif (target = group || ref)
-          action.map! { |val| task_name(task_join(val, target)) }
-        else
-          action.map! { |val| task_name(val) }
-          keys = @project.keys unless prefix
-        end
+        tasks = if project
+                  action.map { |val| task_join(project.name, val) }
+                elsif (target = group || ref)
+                  action.map { |val| task_name(task_join(val, target)) }
+                else
+                  keys = @project.keys unless prefix
+                  action.map { |val| task_name(val) }
+                end
         ns = lambda do |val|
           return if (ret = as_a(val, :to_s, flat: true)).empty?
 
-          ret.map! do |arg|
+          ret.map do |arg|
             if arg.include?(':') || (keys && !keys.include?(arg))
               task_name(arg)
             else
@@ -255,7 +262,7 @@ module Squared
             end
           end
         end
-        data = Struct::ChainData.new(action, step, ns.call(with), ns.call(before), ns.call(after), sync)
+        data = Struct::ChainData.new(tasks, step, ns.call(with), ns.call(before), ns.call(after), sync)
         @chain[task_name(task.to_s)] << data
         self
       end
@@ -298,18 +305,18 @@ module Squared
 
       def pass(name, group: @group, ref: @ref, &blk)
         data = if group
-                 @pass[:group][group.to_s]
+                 @pass.group[group.to_s]
                elsif ref
-                 @pass[:ref][ref.to_sym]
+                 @pass.ref[ref.to_sym]
                else
-                 @pass[:global]
+                 @pass.store
                end
         data[name.to_sym] = blk
         self
       end
 
       def banner(*args, command: true, styles: nil, border: nil, group: @group, ref: @ref)
-        data = Struct::BannerData.new(command, [], check_style(styles, empty: false), check_style(border))
+        data = Struct::BannerData.new(command, check_style(styles, empty: false), check_style(border))
         args.each do |meth|
           if meth.is_a?(Array)
             found = false
@@ -317,7 +324,7 @@ module Squared
               case val
               when Symbol
                 found = true
-                Application.attr_banner.include?(val)
+                banner_include?(val)
               when String
                 true
               else
@@ -329,7 +336,7 @@ module Squared
             elsif meth.size == 1
               meth = meth.first
             end
-          elsif !Application.attr_banner.include?(meth = meth.to_sym)
+          elsif !banner_include?(meth = meth.to_sym)
             next
           end
           data.order << meth
@@ -344,8 +351,29 @@ module Squared
         self
       end
 
+      def timeout(data, group: @group, ref: @ref)
+        if group
+          @timeout.group[group.to_s].update(data)
+        elsif ref
+          @timeout.ref[ref.to_sym].update(data)
+        else
+          @timeout.store.update(data)
+        end
+        self
+      end
+
+      def batch(*args)
+        (@config[:batch] ||= []) << args
+        self
+      end
+
+      def rename(task, val)
+        (@config[:rename] ||= {})[task.to_sym] = val.to_s
+        self
+      end
+
       def add(path, project = nil, **kwargs, &blk)
-        kwargs = hashdup(@withargs).update(kwargs) if @withargs
+        kwargs = Support.hashdup(@withargs).update(kwargs) if @withargs
         ref = kwargs.key?(:ref) ? kwargs.delete(:ref) : @ref
         kwargs[:group] = @group if @group && !kwargs.key?(:group)
         path = rootpath path
@@ -356,12 +384,20 @@ module Squared
           index += 1
           name = task_name "#{project}-#{index}"
         end
-        proj = ((if !ref.is_a?(Class)
-                   require_project ref
-                   Application.find(ref, path: path)
-                 elsif ref < Application.impl_project
+        unless ref.is_a?(Symbol) && (proj = @base.find { |item| item.ref == ref })
+          proj = if !ref.is_a?(Class)
+                   require_project(ref) || Application.find(ref, path: path)
+                 elsif Application.extends(ref)
                    ref
-                 end) || @kind[name]&.last || Application.impl_project).new(self, path, name, **kwargs)
+                 end || @kind[name]&.last
+          if proj
+            @base << proj
+            @banner.items.concat(Array(proj.bannerargs))
+          else
+            proj = Application.impl_project
+          end
+        end
+        proj = proj.new(self, path, name, **kwargs)
         proj.__send__(:index_set, size)
         @project[name] = proj
         __get__(:project)[name] = proj unless kwargs[:private]
@@ -370,7 +406,7 @@ module Squared
       end
 
       def group(path, val, override: {}, **kwargs, &blk)
-        rootpath(path).children.map! do |dir|
+        rootpath(path).children.map do |dir|
           next unless dir.directory?
 
           basename = dir.basename.to_s
@@ -394,6 +430,18 @@ module Squared
         self
       end
 
+      def stage(val, first: false, &blk)
+        data = @stage[val]
+        if first == true
+          data.unshift(blk)
+        elsif first.is_a?(Numeric) && first < data.size
+          data.insert(first, blk)
+        else
+          data.push(blk)
+        end
+        self
+      end
+
       def style(obj, *args, target: nil, empty: false)
         data = nil
         if target
@@ -408,7 +456,7 @@ module Squared
         if obj.is_a?(String)
           obj = begin
             JSON.parse(homepath(obj).read, { symbolize_names: true })
-          rescue StandardError => e
+          rescue => e
             warn log_message(Logger::ERROR, e)
           end
         end
@@ -424,7 +472,7 @@ module Squared
         }
         data.each do |key, val|
           key = key.to_s
-          if key.start_with?(/(\\A|\^)/) || key.match?(/(\\z|\$)\z/)
+          if key.start_with?('\A', '^') || key.end_with?('\z', '$')
             @describe[:replace] << [Regexp.new(key), val]
           else
             @describe[val.is_a?(Regexp) ? :pattern : :alias][key] = val
@@ -466,7 +514,7 @@ module Squared
       end
 
       def find_base(obj)
-        Application.kind_project.find { |proj| obj.instance_of?(proj) }
+        @base.find { |proj| obj.instance_of?(proj) }
       end
 
       def task_name(val)
@@ -507,7 +555,7 @@ module Squared
               break
             end
           end
-          args = split_escape(val, char: ':').map! { |s| s.gsub('\\:', ':') } if found
+          args = split_escape(val, char: ':').map { |s| s.gsub('\\:', ':') } if found
         end
         desc message(*args, **kwargs)
       end
@@ -524,7 +572,7 @@ module Squared
           tasks << key if obj.has?(key, baseref)
         elsif (batch = series.batch_get(key))
           obj.allref do |ref|
-            next unless obj.has?(key, ref) && (data = batch[ref])
+            next unless obj.has?(key, ref, missing: series.missing?(ref, key)) && (data = batch[ref])
 
             data.each do |val|
               if (items = task_resolve(obj, val)).empty?
@@ -584,29 +632,55 @@ module Squared
         out ? message(*val) : task_desc(*val)
       end
 
-      def script_find(*args)
+      def script_find(*args, name: nil)
+        target = @global[name || '_']
+        group, ref, exclude = target.fetch_values(:group, :ref, :exclude)
+        ret = nil
         args.reverse_each do |val|
-          if val && (ret = val.is_a?(Symbol) ? @script[:ref!][val] : @script[:group!][val.to_sym])
-            return ret
+          next unless val
+
+          if exclude.include?(val)
+            ret = nil
+            break
+          elsif ret
+            next
+          elsif (ret = val.is_a?(Symbol) ? ref[val] : group[val]) && exclude.empty?
+            break
           end
         end
-        @script[:ref!][:''] ||= scriptobj
+        ret || (target[:script] ||= scriptobj)
       end
 
       def script_get(*args, group: nil, ref: nil)
-        data_get(*args, group: group, ref: ref, target: @script)
+        data_get(*args, target: @script, group: group, ref: ref)
       end
 
       def events_get(*args, group: nil, ref: nil)
-        data_get(*args, group: group, ref: ref, target: @events)
+        data_get(*args, target: @events, group: group, ref: ref)
       end
 
       def banner_get(*ref, group: nil)
-        ret = nil
-        return ret if group && (ret = @banner[:group][group.to_sym])
+        if group && @banner.group.key?(group = group.to_sym)
+          @banner.group[group]
+        else
+          ref.reverse_each do |val|
+            next unless @banner.ref.key?(val)
 
-        ref.reverse_each { |val| return ret if (ret = @banner[:ref][val]) }
-        @banner[:ref][:_]
+            return @banner.ref[val]
+          end
+          @banner.ref[:_] if @banner.ref.key?(:_)
+        end
+      end
+
+      def timeout_get(*ref, group: nil)
+        ret = @timeout.store.dup
+        ref.each { |val| ret.update(@timeout.ref[val]) if @timeout.ref.key?(val) }
+        ret.update(@timeout.group[group]) if group && @timeout.group.key?(group)
+        ret
+      end
+
+      def config_get(key, default = nil, &blk)
+        @config.fetch(key, block_given? ? blk : default)
       end
 
       def enabled?
@@ -629,13 +703,13 @@ module Squared
 
       def task_exclude?(key, obj = nil)
         if obj
-          data = obj.group ? @pass[:group][obj.group] : @pass[:ref][obj.ref]
-          blk = (data && data[key.to_sym]) || @pass[:global][key.to_sym]
+          data = obj.group ? @pass.group[obj.group] : @pass.ref[obj.ref]
+          blk = (data && data[key.to_sym]) || @pass.store[key.to_sym]
           return true if blk && obj.instance_eval(&blk)
 
           key = task_join(task_localname(obj.name), key)
         end
-        @pass[:pattern].any? { |item| item.is_a?(Regexp) ? key.to_s.match?(item) : key == item }
+        @pass.items.any? { |item| item.is_a?(Regexp) ? item.match?(key) : item == key }
       end
 
       def task_defined?(*key)
@@ -722,18 +796,43 @@ module Squared
 
       private
 
-      def __build__(default: nil, **)
-        unless task_defined?('squared:version')
-          task 'squared:version' do
-            puts Squared::VERSION
-          end
-        end
-        if default && task_defined?(out = task_name(default))
-          task Rake.application.default_task_name => out
+      def initialize_session
+        return unless @pipe.is_a?(Pathname)
+
+        msg = "Session started on #{Time.now} by #{@main}"
+        bord = '#' * msg.size
+        puts bord, msg, bord
+      end
+
+      def home=(val)
+        return if @closed
+
+        @home = Pathname.new(val).realdirpath
+        @root = @home.parent
+        @home.mkpath rescue nil
+      end
+
+      def closed=(val)
+        if val.is_a?(Array)
+          val, target = val
+        else
+          target = self
         end
+        @closed = val
+        @stage[val].each { |blk| target.instance_eval(&blk) } if @stage.key?(val)
+      end
+
+      def __build__(*, default: nil, **)
+        self.closed = 'build:begin'
+        task('squared:version') { puts Squared::VERSION } unless task_defined?('squared:version')
+        task Rake.application.default_task_name => task_name(default) if default && task_defined?(task_name(default))
+        self.closed = 'build:end'
       end
 
       def __chain__(*)
+        return if @chain.empty?
+
+        self.closed = 'chain:begin'
         @chain.each do |key, group|
           level = []
           sync = []
@@ -844,6 +943,7 @@ module Squared
             end
           end
         end
+        self.closed = 'chain:end'
       end
 
       def puts(*args, **kwargs)
@@ -869,18 +969,39 @@ module Squared
         self
       end
 
-      def script_set(data, group: nil, ref: nil)
+      def script_set(from, data, name: nil, extras: nil, group: nil, ref: nil)
+        target = @global[name || '_']
+        target[:module] = from
+        target[:extras].update(extras) if extras
         data.freeze
         if group
-          Array(group).each { |val| @script[:group!][val.to_sym] = data }
+          Array(group).each do |val|
+            val = val.to_s
+            if val.start_with?('-')
+              target[:exclude] << val[1..-1]
+            else
+              target[:group][val] = data
+            end
+          end
         elsif ref
-          Array(ref).each { |val| @script[:ref!][val.to_sym] = data }
+          Array(ref).each do |val|
+            val = val.to_s
+            if val.start_with?('-')
+              target[:exclude] << val[1..-1].to_sym
+            else
+              target[:ref][val.to_sym] = data
+            end
+          end
         else
-          @script[:ref!][:''] = data
+          target[:script] = data
         end
       end
 
-      def data_get(*args, group: nil, ref: nil, target: nil)
+      def script_each(from, &blk)
+        @global.select { |_, data| data[:module] == from }.each(&blk)
+      end
+
+      def data_get(*args, target:, group: nil, ref: nil)
         if group && target[:group].key?(key = group.to_sym)
           target[:group][key]
         elsif ref.is_a?(Enumerable)
@@ -897,11 +1018,11 @@ module Squared
       end
 
       def require_project(ref)
-        return unless ref.is_a?(Symbol) && Application.kind_project.none? { |proj| proj.ref == ref }
+        ret = Application.kind_project.find { |proj| proj.ref == ref }
+        return ret if ret
 
-        name = ref.to_s
-        Application.load_project.each do |val|
-          next unless File.exist?("#{rb = File.join(val, name)}.rb")
+        Application.load_project.each do |dir|
+          next unless File.exist?("#{rb = File.join(dir, ref.to_s)}.rb")
 
           require_relative rb
           break
@@ -911,18 +1032,19 @@ module Squared
       def root?(path, pass: [])
         return false unless path.directory?
 
-        path.each_child do |c|
-          name = c.basename.to_s
-          unless c.to_s == __FILE__ || (@main == name && c.directory? && c.empty?) || pass.any? { |val| val == name }
+        path.each_child do |file|
+          s = file.basename.to_s
+          unless file.to_s == __FILE__ || (@main == s && file.directory? && file.empty?) || pass.any? { |val| val == s }
             return false
           end
         end
         true
       end
 
-      def script?(state, target: nil, pat: nil, group: nil, ref: baseref, global: false, script: true)
-        data = script_find ref, group
-        type = script ? :script : :run
+      def script?(state, name: nil, target: nil, pat: nil, group: nil, ref: baseref, type: nil, script: true,
+                  global: false)
+        data = script_find(ref, group, name: name)
+        type ||= script ? :script : :run
         if global
           target = data[type] if target.nil?
           pat = data[state] if pat.nil?
@@ -932,13 +1054,23 @@ module Squared
         target && pat.is_a?(Regexp) ? Array(target).any?(pat) : pat == true
       end
 
+      def banner_include?(val)
+        Application.attr_banner.include?(val) || @banner.items.include?(val)
+      end
+
       def scriptobj
         {
           run: nil,
           script: nil,
           dev: nil,
           prod: nil,
-          global: {},
+          global: {
+            script: false,
+            run: false,
+            doc: false,
+            lint: false,
+            test: false
+          },
           env: {}
         }
       end