squared 0.0.6 → 0.0.8

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.to_sym == 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, :warning
-      attr_accessor :exception, :pipe, :verbose
+      attr_reader :root, :home, :main, :prefix, :series, :theme
+      attr_accessor :exception, :warning, :pipe, :verbose
 
-      def initialize(main, *, common: true, exception: false, pipe: false, verbose: nil, **)
-        @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, self)
+        @prefix = prefix
+        @series = Application.impl_series.new(prefix)
         @project = {}
         @extensions = []
         @script = {
@@ -66,97 +53,118 @@ module Squared
           ref: {},
           build: nil,
           dev: nil,
-          prod: nil
+          prod: nil,
+          env: false
         }
-        @theme = common && @verbose ? __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 = true
+        @warning = @verbose
+        if kwargs.fetch(:common, true)
+          @theme = __get__(:theme)[:workspace]
+          __set__(:no_color, true) if @pipe
+        else
+          @theme = {}
+        end
       end
 
       def build(**kwargs)
+        kwargs[:parallel] = kwargs.fetch(:parallel, []).map(&:to_s)
         return unless enabled?
 
         @project.each_value do |proj|
           next unless proj.enabled?
 
-          series.populate(proj)
           proj.populate(**kwargs)
+          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[:refresh].clear if series[:refresh].all? { |val| val.end_with?(':build') }
+        series.__build__(**kwargs)
+        __build__(**kwargs)
 
-        task default: kwargs[:default] if series.has?(kwargs[:default]) && !task_defined?('default')
-
-        if series.has?('build')
-          init = ['depend', dev? && series.has?('refresh') ? 'refresh' : 'build']
-
-          task default: init[1] unless task_defined?('default')
+        yield self if block_given?
+      end
 
-          if series.has?(init[0]) && !task_defined?('init')
-            desc 'init'
-            task init: init
+      def with(group: nil, ref: nil, &blk)
+        @group = nil
+        @ref = nil
+        if group
+          @group = group
+          if block_given?
+            instance_eval(&blk)
+            @group = nil
+          end
+        elsif ref
+          @ref = ref
+          if block_given?
+            instance_eval(&blk)
+            @ref = nil
           end
         end
-        series.finalize!(kwargs.fetch(:parallel, []))
-
-        yield self if block_given?
+        self
       end
 
-      def run(script, group: nil, ref: nil)
+      def run(script, group: @group, ref: @ref)
         script_command :run, script, group, ref
       end
 
-      def depend(script, group: nil, ref: nil)
+      def depend(script, group: @group, ref: @ref)
         script_command :depend, script, group, ref
       end
 
-      def clean(script, group: nil, ref: nil)
+      def clean(script, group: @group, ref: @ref)
         script_command :clean, script, group, ref
       end
 
-      def doc(script, group: nil, ref: nil)
+      def doc(script, group: @group, ref: @ref)
         script_command :doc, script, group, ref
       end
 
-      def test(script, group: nil, ref: nil)
+      def test(script, group: @group, ref: @ref)
         script_command :test, script, group, ref
       end
 
-      def add(name, path = nil, ref: nil, **kwargs)
-        path = root_path((path || name).to_s)
-        project = if !ref.is_a?(::Class)
-                    Application.find(path: path, ref: ref)
-                  elsif ref < Project::Base
-                    ref
-                  end
-        instance = (project || Project::Base).new(name, path, self, **kwargs)
-        @project[n = name.to_sym] = instance
-        __get__(:project)[n] = instance unless kwargs[:private]
+      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)
+              elsif !@ref.is_a?(::Array)
+                @ref
+              end
+        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(ref, path: path)
+                 elsif ref < Project::Base
+                   ref
+                 end) || Project::Base).new(prefix ? "#{prefix}:#{name}" : name, path, self, **kwargs)
+        @project[name = name.to_sym] = proj
+        __get__(:project)[name] = proj unless kwargs[:private]
         self
       end
 
-      def group(name, path, **kwargs)
+      def group(name, path, override: {}, **kwargs)
         root_path(path).children.map do |ent|
           next unless (dir = Pathname.new(ent)).directory?
 
           index = 0
           basename = dir.basename.to_s.to_sym
-          override = kwargs.delete(basename)
           while @project[basename]
             index += 1
             basename = :"#{basename}-#{index}"
           end
-          [basename, dir, override]
+          [basename, dir, override[basename]]
         end
-        .each do |basename, dir, override|
-          opts = kwargs.dup
-          opts.merge!(override) if override
-          add(basename, dir, group: name, **opts)
+        .each do |basename, dir, opts|
+          args = kwargs.dup
+          args.merge!(opts) if opts
+          add(basename, dir, group: name, **args)
         end
         self
       end
@@ -174,29 +182,35 @@ 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)
-        if group || ref
-          (group && @script[:group][group.to_sym]) || (ref && @script[:ref][ref.to_sym])
+      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, equals: nil, ignore: nil, default: nil)
-        ret = ENV.fetch("#{key}_#{main.gsub(/[^\w]/, '_').upcase}", ENV[key]).to_s
+      def env(key, default = nil, equals: nil, ignore: nil)
+        @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
@@ -211,7 +225,7 @@ 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 to_s
@@ -229,78 +243,72 @@ module Squared
       def task_base?(key, val)
         return val if task_defined?(key)
 
-        val if key == :refresh && series[:build].include?(val = "#{val.split(':').first}:build")
+        val if key == :refresh && series.build.include?(val = "#{val.split(':').first}:build")
       end
 
-      def task_include?(obj, key)
-        TASK_EXTEND.fetch(key, []).any? { |item| obj.is_a?(item) }
+      def task_extend?(obj, key)
+        series.extend?(obj, key)
       end
 
-      def task_defined?(key)
+      def task_defined?(key, *)
         ::Rake::Task.task_defined?(key)
       end
 
-      def dev?(script: nil, pat: nil, global: nil)
-        with?(:dev, script: script, pat: pat, global: global || (pat.nil? && global.nil?))
+      def dev?(global: nil, **kwargs)
+        script?(:dev, global: global.nil? ? kwargs[:pat].nil? : global, **kwargs)
       end
 
-      def prod?(script: nil, pat: nil, global: false)
+      def prod?(global: false, **kwargs)
         return false if global && (@script[:dev] == true || !@script[:prod])
 
-        with?(:prod, script: script, pat: pat, global: global)
-      end
-
-      protected
-
-      def confirm(msg, agree: 'Y', cancel: 'N', default: nil, attempts: 5, timeout: 15)
-        require 'readline'
-        require 'timeout'
-        agree = /^#{agree}$/i if agree.is_a?(String)
-        cancel = /^#{cancel}$/i if cancel.is_a?(String)
-        Timeout.timeout(timeout) do
-          begin
-            while (ch = Readline.readline(msg, true))
-              ch = ch.chomp
-              ch = default if ch.empty?
-              case ch
-              when agree
-                return true
-              when cancel
-                return false
-              end
-              attempts -= 1
-              exit 1 unless attempts >= 0
-            end
-          rescue Interrupt
-            puts
-            exit 0
-          else
-            false
-          end
-        end
+        script?(:prod, global: global, **kwargs)
       end
 
       private
 
+      def __build__(**kwargs)
+        if !task_defined?('default') && (default = kwargs[:default]) && series.has?(default)
+          task 'default' => default
+        end
+        return unless series.has?(:build)
+
+        series.refresh.clear unless series.refresh.any? { |val| val.end_with?(':refresh') }
+
+        init = [:depend, dev? && series.has?(:refresh) ? :refresh : :build]
+
+        task 'default' => init[1] unless task_defined?('default')
+
+        return if task_defined?('init') || !series.has?(init[0])
+
+        desc 'init'
+        task 'init' => 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 with?(state, script: nil, pat: nil, global: false)
-        if global
+      def script?(state, script: nil, pat: nil, ref: nil, group: nil, global: false)
+        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
       end
+
+      def contains?(data, val)
+        as_a(data).any? { |item| item.to_s == val.to_s }
+      end
     end
   end
 end