squared 0.0.7 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45b563863fb21461ec7c629dc01a197485c15c8a26239db170a91970a6cade9a
-  data.tar.gz: f7051ae9101dbced194185f5731c6bd028ccd3e56dfbbab047a7370c220412de
+  metadata.gz: 90258e1d46b51b15fcb414cddf85407968d227b5032797e76ead83befa5d302b
+  data.tar.gz: a01b153f7c26b7f15a24cc66a159e47e42bc117e7b0810d7146c6ca3766f3cd0
 SHA512:
-  metadata.gz: 74adde082a170b07b65ccc258b94681826c9fdbda9120a39128f9236d4215c904a7dac32451428e92cdfbabd354e6dce810447df03660169b34783d02a808978
-  data.tar.gz: c50ee1d27e5be607e84fd82bd4d15e4d3ec8e4d12acd4619ef1421d2206e313205e8aaf849965e6140d6e5873848001d2c55d00f0335f8274ef6c95213ec7990
+  metadata.gz: 484c0af12a637957f3ed9ddc43b6f08bee1f3dbcba50a2acdfdd0dcb7bb929b83b64d40fd8bbf17ceddc5d8177a27773e4193198cbc80f2991651bf55366b2c8
+  data.tar.gz: a9617a969c41e971235b98bc730fd440f6c913a2ce21b9e8acb1907ae170ac72da1bb5d72df8650c1833827599fb0d95ab4aae19e5c75249dac07c0096efe077

data/README.ruby.md

@@ -34,12 +34,14 @@ Projects from any accessible folder can be added either relative to `REPO_ROOT`
 require "squared"
 require "squared/workspace/repo" # Repo (optional)
 
+# NODE_ENV  = production
 # REPO_ROOT = /workspaces
 # REPO_HOME = /workspaces/squared
 # rake      = /workspaces/squared/Rakefile
 
 Workspace::Application
-  .new("squared") # REPO_HOME
+  .new(main: "squared") # Dir.pwd? (main? is implicitly basename)
+  .banner("group", "project", styles: %i[yellow black], border: "bold") # name | project | path | ref | group?
   .repo("https://github.com/anpham6/squared-repo", "nightly", run: "build", ref: :node) # Repo (optional)
   .run("rake install", ref: :ruby)
   .depend(false, group: "default")
@@ -48,11 +50,11 @@ Workspace::Application
   .add("pathname", run: "rake compile", copy: "rake install", test: "rake test", group: "default", ref: :ruby) # Ruby (with C extensions)
   .add("optparse", doc: "rake rdoc", group: "default") # Uses bundler/gem_tasks (without C extensions)
   .add("logger", copy: { from: "lib", glob: "**/*.rb", gemdir: "~/.rvm/gems/ruby-3.3.5/gems/logger-1.6.1" }, clean: ["tmp/"]) # autodetect: true
-  .add("android", "android-docs", run: false, doc: "make html", ref: :python) # Python
   .add("emc", "e-mc", copy: { from: "publish", into: "@e-mc", also: [:pir, "squared-express/"] }, ref: :node) # Node
   .add("pir", "pi-r", copy: { from: "publish", into: "@pi-r" }, clean: ["publish/**/*.js", "tmp/"]) # Trailing slash required for directories
   .add("squared", log: { file: "tmp/%Y-%m-%d.log", level: "debug" }, group: "app") # Copy target (main)
-  .style(:banner, 255.255) # 256 colors (fg | fg.bg | -0.bg)
+  .add("sqd", "squared/sqd", script: ["build:sqd", "prod:sqd"], depend: false, clean: ["build/sqd/"], exclude: :git) # NPM workspaces
+  .style("banner", 255.255) # 256 colors (fg | fg.bg | -0.bg)
   .build(default: "status", parallel: ["pull", "fetch", "rebase", "copy", "clean"]) do |workspace|
     workspace
       .enable_aixterm
@@ -64,21 +66,33 @@ Workspace::Application
 # pathname  = /workspaces/pathname
 # optparse  = /workspaces/optparse
 # log       = /workspaces/logger
-# android   = /workspaces/android-docs
 # emc       = /workspaces/e-mc
 # pir       = /workspaces/pi-r
 # squared   = /workspaces/squared
 
 Workspace::Application
-  .new("squared")
-  .group("default", "ruby", run: "rake build", copy: "rake install", clean: "rake clean", override: {
-    pathname: { run: "rake compile" }
+  .new(ENV["SQUARED_DIR"], prefix: "rb", common: false) # Local styles
+  .group("default", "ruby/", run: "rake build", copy: "rake install", clean: "rake clean", ref: :ruby, override: {
+    pathname: {
+      run: "rake compile"                               # rake rb:pathname:build
+    }
   })
+  .with(:python) do                                     # ref=Symbol  | group=String
+    banner("path", command: false, styles: "yellow")    # 
+    doc("make html")                                    # rake rb:doc:python
+    run(false)                                          # rake rb:build:python (disabled)
+    exclude(%i[base git])                               # Project::Git.ref (superclass)
+    add("android", "android-docs")                      # rake rb:android:doc
+    add("chrome", "chrome-docs")                        # rake rb:chrome:doc
+  end                                                   #
+  .style("inline", "bold")
   .build
 # default   = /workspaces/ruby/*
 # pathname  = /workspaces/ruby/pathname
 # optparse  = /workspaces/ruby/optparse
 # logger    = /workspaces/ruby/logger
+# android   = /workspaces/android-docs
+# chrome    = /workspaces/chrome-docs
 ```
 
 **NOTE**: The use of "**ref**" (class name) is only necessary when running `repo:init` for the first time into an empty directory.
@@ -124,6 +138,7 @@ rake clean:node     # none + ["publish/**/*.js", "tmp/"] + ["build/"]
 * header
 * active
 * inline
+* major
 
 ## LICENSE
 

data/lib/squared/common/base.rb

@@ -26,7 +26,8 @@ module Squared
         workspace: {
           header: %i[bold],
           active: %i[bold],
-          inline: %i[bold]
+          inline: %i[bold],
+          major: %i[bold]
         },
         project: {},
         viewer: {
@@ -82,16 +83,16 @@ module Squared
       args.reject(&:empty?).join(' => ') + (hint ? " (#{hint})" : '')
     end
 
-    def as_a(obj, flat: nil)
-      if obj.nil?
-        []
-      elsif !obj.is_a?(::Array)
-        [obj]
+    def as_a(obj, meth = nil, flat: nil, compact: false)
+      return [] if obj.nil?
+
+      if !obj.is_a?(::Array)
+        obj = [obj]
       elsif flat
-        obj.flatten(flat == true ? nil : flat)
-      else
-        obj
+        obj = obj.flatten(flat == true ? nil : flat)
       end
+      obj = obj.map(&meth) if meth
+      compact ? obj.compact : obj
     end
   end
 end

data/lib/squared/common/format.rb

@@ -109,7 +109,7 @@ module Squared
       def check_style(*args, empty: true)
         ret = []
         colors = __get__(:colors)
-        as_a(args, flat: true).each do |val|
+        as_a(args, flat: true, compact: true).each do |val|
           if !val.is_a?(Numeric)
             val = val.to_sym
             ret << val if colors.key?(val) || TEXT_STYLE.include?(val)
@@ -201,7 +201,7 @@ module Squared
           "| #{s} |"
         end
         out << bord
-        out.push(pr.(title), bord) if title
+        out << pr.(title) << bord if title
         lines.each { |line| out << pr.(line) }
         out << bord
         if block_given?

data/lib/squared/common/task.rb

@@ -7,12 +7,13 @@ module Squared
     module Task
       module_function
 
-      def invoke(name, *args, exception: true)
-        ::Rake::Task[name].invoke(*args)
+      def invoke(series, *args, exception: true, warning: true)
+        series = [series] unless series.is_a?(::Array)
+        series.each { |name| ::Rake::Task[name].invoke(*args) }
       rescue StandardError => e
         raise if exception
 
-        warn e
+        warn e if warning
       end
 
       def invoked?(name)

data/lib/squared/config.rb

@@ -17,14 +17,15 @@ module Squared
         end
       end
 
-      attr_reader :name, :main, :project, :theme
+      attr_reader :main, :name, :project, :theme
 
-      def initialize(main, name = nil, project: nil, dump: nil, opts: {}, auto: true, common: true)
+      def initialize(main, name = nil, project: nil, prefix: nil, dump: nil, opts: {}, auto: true, common: true)
         if project
           main = @project.base_path(main).to_s if (@project = __get__(:project)[project.to_sym])
           @required = true
         end
         @name = name&.to_s || @project&.name
+        @prefix = prefix
         @ext = File.extname(main)
         @dump = dump
         @mime = {}
@@ -59,18 +60,18 @@ module Squared
 
         params = ->(args) { exist? ? [realpath, [args.keys] + args.extras] : [args.keys, args.extras] }
 
-        namespace name do
+        namespace(ns = task_name(name)) do
           view = @command && @command != name ? @command : 'view'
           namespace view do
-            if @mime['json'] && (exist? || !::Rake::Task.task_defined?("#{name}:#{view}:json"))
-              desc format_desc(view, %w[json])
+            if @mime['json'] && (exist? || !::Rake::Task.task_defined?("#{ns}:#{view}:json"))
+              desc format_desc(view, 'json')
               task 'json', [:keys] do |_, args|
                 read_keys(JSON, 'json', *params.(args))
               end
             end
 
-            if @mime['yaml'] && (exist? || !::Rake::Task.task_defined?("#{name}:#{view}:yaml"))
-              desc format_desc(view, %w[yaml yml])
+            if @mime['yaml'] && (exist? || !::Rake::Task.task_defined?("#{ns}:#{view}:yaml"))
+              desc format_desc(view, 'yaml', 'yml')
               task 'yaml', [:keys] do |_, args|
                 require 'yaml'
                 read_keys(YAML, 'yaml', *params.(args), ext: %w[yml yaml])
@@ -91,8 +92,9 @@ module Squared
           obj = eval(parse)
           ext << type if (ext = as_a(ext)).empty?
           file = realpath if file.nil? && exist?
-          namespace name do
-            desc format_desc(command, ext, exist: exist)
+
+          namespace task_name(name) do
+            desc format_desc(command, *ext, exist: exist)
             namespace command do
               task type, [:keys] do |_, args|
                 if file
@@ -158,7 +160,7 @@ module Squared
         !@required || (!project.nil? && project.enabled?)
       end
 
-      protected
+      private
 
       def read_keys(reader, type, file, keys, ext: [type])
         if (mime = mime_type(file)) && base_path(file).exist?
@@ -188,19 +190,16 @@ module Squared
                         .realpath
                         .to_s
                         .sub(Regexp.new("^#{Regexp.escape(File.join(Dir.pwd, ''))}"), '')
-        sub = if pipe?
-                nil
-              else
-                styles = theme
+        sub = if !pipe?
                 [
-                  { pat: /^((?:[^:]|(?<! ):(?! ))+)$/, styles: styles[:banner] },
-                  { pat: /^(.*?)(<[^>]+>)(.+)$/m, styles: styles[:undefined], index: 2 },
-                  { pat: /^(.+)( : (?!undefined).+)$/m, styles: styles[:key] },
-                  { pat: /^(.+ : )(-?[\d.]+)(\s*)$/m, styles: styles[:number], index: 2 },
-                  { pat: /^(.+ : ")(.+)("\s*)$/m, styles: styles[:string], index: 2 },
-                  { pat: /^(.+ : \{)(.+)(\}\s*)$/m, styles: styles[:hash], index: 2 },
-                  { pat: /^(.+ : \[)(.+)(\]\s*)$/m, styles: styles[:array], index: 2 },
-                  { pat: /^(.+ : (?!undefined))([^"\[{].*)$/m, styles: styles[:value], index: 2 }
+                  { pat: /^((?:[^:]|(?<! ):(?! ))+)$/, styles: theme[:banner] },
+                  { pat: /^(.*?)(<[^>]+>)(.+)$/m, styles: theme[:undefined], index: 2 },
+                  { pat: /^(.+)( : (?!undefined).+)$/m, styles: theme[:key] },
+                  { pat: /^(.+ : )(-?[\d.]+)(\s*)$/m, styles: theme[:number], index: 2 },
+                  { pat: /^(.+ : ")(.+)("\s*)$/m, styles: theme[:string], index: 2 },
+                  { pat: /^(.+ : \{)(.+)(\}\s*)$/m, styles: theme[:hash], index: 2 },
+                  { pat: /^(.+ : \[)(.+)(\]\s*)$/m, styles: theme[:array], index: 2 },
+                  { pat: /^(.+ : (?!undefined))([^"\[{].*)$/m, styles: theme[:value], index: 2 }
                 ]
               end
         emphasize(lines, title: title, sub: sub)
@@ -224,7 +223,7 @@ module Squared
               end
             end
           rescue StandardError
-            project&.log&.warn "#{Viewer}(#{type}) => #{file ? "#{file} " : ''}{#{key}: undefined}"
+            project&.log&.warn "#{Viewer}(#{type}) => #{file && "#{file} "}{#{key}: undefined}"
             val = Regexp.escape($!.message)
             key = key.sub(/(#{val})\.|\.(#{val})|(#{val})/) do
               s = "<#{$3 || $2 || $1}>"
@@ -251,6 +250,10 @@ module Squared
         project ? project.base_path(file) : Pathname.new(file).realdirpath
       end
 
+      def task_name(val)
+        @prefix ? "#{@prefix}:#{val}" : val.to_s
+      end
+
       def mime_type(file)
         case (ret = File.extname(file).sub('.', '').downcase)
         when 'yml'
@@ -262,8 +265,9 @@ module Squared
         end
       end
 
-      def format_desc(command, ext, exist: exist?)
-        message(name, command, "#{ext.first}[#{exist ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys*]")
+      def format_desc(command, *ext, exist: exist?)
+        message(@prefix || '', *name.split(':'), command,
+                "#{ext.first}[#{exist ? '' : "file?=#{File.basename(main)}.#{ext.last},"}keys*]")
       end
 
       def realpath
@@ -283,7 +287,7 @@ module Squared
       end
 
       def warning?
-        project && defined?(project.warning) == 'method' ? project.warning : true
+        project ? project.workspace.warning : true
       end
     end
   end

data/lib/squared/version.rb

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

data/lib/squared/workspace/application.rb

@@ -7,58 +7,45 @@ module Squared
       include Format
       include ::Rake::DSL
 
-      TASK_BASE = {
-        build: [],
-        refresh: [],
-        depend: [],
-        outdated: [],
-        doc: [],
-        test: [],
-        copy: [],
-        clean: []
-      }
-      TASK_EXTEND = {}
-      WORKSPACE_KEYS = TASK_BASE.keys.freeze
-      private_constant :TASK_BASE, :TASK_EXTEND
-
       class << self
         def implement(*objs)
           objs.each do |obj|
-            next unless obj < Project::Base
-
-            project_kind.unshift(obj)
-            obj.tasks&.each do |val|
-              TASK_BASE[val] ||= []
-              (TASK_EXTEND[val] ||= []).push(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
             end
           end
         end
 
-        def find(path: nil, ref: nil)
-          if ref.is_a?(::Symbol) || ref.is_a?(::String)
-            ret = project_kind.find { |proj| proj.ref == ref.to_sym }
-            return ret if ret
+        def find(ref = nil, path: nil)
+          if ref && (ret = impl_project.find { |proj| proj.ref == ref.to_sym })
+            ret
+          elsif path
+            impl_project.find { |proj| proj.is_a?(path) }
           end
-          project_kind.find { |proj| proj.is_a?(path) } if path
         end
 
         def to_s
           super.to_s.match(/[^:]+$/)[0]
         end
 
-        attr_reader :project_kind
+        attr_reader :impl_project, :impl_series
       end
 
-      @project_kind = []
+      @impl_project = []
+      @impl_series = Workspace::Series
 
-      attr_reader :main, :root, :home, :series, :theme
+      attr_reader :root, :home, :main, :prefix, :series, :theme
       attr_accessor :exception, :warning, :pipe, :verbose
 
-      def initialize(main, *, exception: false, pipe: false, verbose: nil, **kwargs)
-        @main = main.to_s
-        @home = Pathname.pwd
+      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
         @root = @home.parent
-        @series = Series.new(TASK_BASE)
+        @prefix = prefix
+        @series = Application.impl_series.new(self)
         @project = {}
         @extensions = []
         @script = {
@@ -66,42 +53,57 @@ module Squared
           ref: {},
           build: nil,
           dev: nil,
-          prod: nil
+          prod: nil,
+          env: false
         }
-        @theme = kwargs.key?(:common) && !kwargs[:common] ? {} : __get__(:theme)[:workspace]
         @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
-        __set__(:no_color, true) if @pipe
+        if kwargs.fetch(:common, true)
+          @theme = __get__(:theme)[:workspace]
+          __set__(:no_color, true) if @pipe
+        else
+          @theme = {}
+        end
+        @banner = {}
       end
 
       def build(**kwargs)
+        kwargs[:parallel] = kwargs.fetch(:parallel, []).map(&:to_s)
         return unless enabled?
 
         @project.each_value do |proj|
           next unless proj.enabled?
 
           proj.populate(**kwargs)
-          series.populate(proj)
+          series.__populate__(proj)
         end
 
-        Application.project_kind.each { |obj| obj.populate(self, **kwargs) }
+        Application.impl_project.each { |obj| obj.populate(self, **kwargs) }
         @extensions.each { |ext| __send__(ext, **kwargs) }
 
+        series.__build__(**kwargs)
         __build__(**kwargs)
-        series.build(**kwargs)
 
         yield self if block_given?
       end
 
-      def with(group: nil, ref: nil)
+      def with(val, &blk)
         @group = nil
         @ref = nil
-        if group
-          @group = group
-        elsif ref
-          @ref = ref
+        if val.is_a?(::String)
+          @group = val
+          if block_given?
+            instance_eval(&blk)
+            @group = nil
+          end
+        elsif val.is_a?(::Symbol)
+          @ref = val
+          if block_given?
+            instance_eval(&blk)
+            @ref = nil
+          end
         end
         self
       end
@@ -126,6 +128,10 @@ module Squared
         script_command :test, 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)
         ref = if kwargs.key?(:ref)
                 kwargs.delete(:ref)
@@ -135,10 +141,10 @@ module Squared
         kwargs[:group] = @group if !kwargs.key?(:group) && !@group.is_a?(::Array)
         path = root_path(path || name.to_s)
         proj = ((if !ref.is_a?(::Class)
-                   Application.find(path: path, ref: ref)
+                   Application.find(ref, path: path)
                  elsif ref < Project::Base
                    ref
-                 end) || Project::Base).new(name, path, self, **kwargs)
+                 end) || Project::Base).new(task_name(name), path, self, **kwargs)
         @project[name = name.to_sym] = proj
         __get__(:project)[name] = proj unless kwargs[:private]
         self
@@ -165,7 +171,7 @@ module Squared
       end
 
       def compose(name, &blk)
-        namespace(name, &blk)
+        namespace(task_name(name), &blk)
         self
       end
 
@@ -177,31 +183,54 @@ module Squared
       def style(name, *args, target: nil, empty: false)
         data = nil
         if target
-          as_a(target).each_with_index do |val, i|
+          as_a(target).each_with_index do |key, i|
             if i == 0
-              break unless (data = __get__(:theme)[val.to_sym])
+              break unless (data = __get__(:theme)[key.to_sym])
             else
-              data = data[val.to_sym] ||= {}
+              data = data[key.to_sym] ||= {}
             end
           end
-          return unless data
         end
-        apply_style(data || theme, name, *args, empty: empty)
+        apply_style(data || theme, name, *args, empty: empty) unless target && !data
         self
       end
 
-      def script(group: nil, ref: nil)
+      def banner(*order, command: true, styles: [], border: [], group: nil, ref: nil)
+        return (group && @banner[group.to_sym]) || @banner[:"_#{ref || ''}"] if order.empty?
+
+        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?
+        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
-          @script[:build]
+          []
         end
       end
 
       def env(key, default = nil, equals: nil, ignore: nil)
-        ret = ENV.fetch("#{key}_#{main.gsub(/[^\w]+/, '_').upcase}", ENV[key]).to_s
+        @env ||= main.gsub(/[^\w]+/, '_').upcase
+        ret = ENV.fetch("#{key}_#{@env}", ENV[key]).to_s
         return ret == equals.to_s unless equals.nil?
 
         ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
@@ -216,7 +245,19 @@ module Squared
       end
 
       def find_base(obj)
-        Application.project_kind.find { |proj| obj.instance_of?(proj) }
+        Application.impl_project.find { |proj| obj.instance_of?(proj) }
+      end
+
+      def task_name(val, desc: false)
+        ret = @prefix ? "#{@prefix}:#{val}" : val.to_s
+        desc ? ret.split(':').join(' => ') : ret
+      end
+
+      def task_namespace(val, first: false)
+        return nil unless (val = val.to_s).include?(':')
+
+        ret = val.split(':')
+        first ? ret.first : ret[0..-2].join(':')
       end
 
       def to_s
@@ -231,17 +272,11 @@ module Squared
         !@extensions.empty? || @project.any? { |_, proj| proj.enabled? }
       end
 
-      def task_base?(key, val)
-        return val if task_defined?(key)
-
-        val if key == :refresh && series[:build].include?(val = "#{val.split(':').first}:build")
+      def task_extend?(obj, key)
+        series.extend?(obj, key)
       end
 
-      def task_include?(obj, key)
-        TASK_EXTEND.fetch(key, []).any? { |item| obj.is_a?(item) }
-      end
-
-      def task_defined?(key)
+      def task_defined?(key, *)
         ::Rake::Task.task_defined?(key)
       end
 
@@ -258,44 +293,49 @@ module Squared
       private
 
       def __build__(**kwargs)
-        if !task_defined?('default') && (default = kwargs[:default]) && !series.has?(default)
-          task default: default
-        end
-        return unless series.has?('build')
-
-        if (refresh = series[:refresh]).all? { |val| val.end_with?(':build') }
-          refresh.clear
+        if !task_defined?('default') && (target = kwargs[:default]) && task_defined?(target = task_name(target))
+          task 'default' => target
         end
-        init = ['depend', dev? && series.has?('refresh') ? 'refresh' : 'build']
+        return unless series.some?(:build)
 
-        task default: init[1] unless task_defined?('default')
+        init = [task_name('depend'), task_name(dev? && series.some?(:refresh) ? 'refresh' : 'build')]
 
-        return if task_defined?('init') || !series.has?(init[0])
+        task 'default' => init[1] unless task_defined?('default')
+        return unless series.some?(:depend) && !task_defined?(key = task_name('init'))
 
-        desc 'init'
-        task init: init
+        desc key
+        task key => init
       end
 
       def script_command(task, val, group, ref)
         if group
           label = :group
-          items = as_a(group)
+          items = as_a(group, :to_sym)
         else
           label = :ref
-          items = as_a(ref)
+          items = as_a(ref, :to_sym)
         end
-        items.each { |name| (@script[label][name.to_sym] ||= {})[task] = val }
+        items.each { |name| (@script[label][name] ||= {})[task] = val }
         self
       end
 
       def script?(state, script: nil, pat: nil, ref: nil, group: nil, global: false)
-        gr = @script[:ref][:_]
-        gg = @script[:group][:_]
-        if global && ((!ref && !group) || (!gr && !gg) || (ref && ref == gr) || (group && group == gg))
+        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
-        pat.is_a?(::Regexp) ? pat.match?(script) : pat == true
+        if pat.is_a?(::Regexp)
+          script = script[state == :prod ? 1 : 0] if script.is_a?(::Array)
+          pat.match?(script)
+        else
+          pat == true
+        end
+      end
+
+      def contains?(data, val)
+        as_a(data).any? { |item| item.to_s == val.to_s }
       end
     end
   end