squared 0.0.4 → 0.0.6

data/lib/squared/workspace/application.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+module Squared
+  module Workspace
+    class Application
+      include Common
+      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)
+            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
+          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
+      end
+
+      @project_kind = []
+
+      attr_reader :main, :root, :home, :series, :theme, :warning
+      attr_accessor :exception, :pipe, :verbose
+
+      def initialize(main, *, common: true, exception: false, pipe: false, verbose: nil, **)
+        @main = main.to_s
+        @home = Pathname.pwd
+        @root = @home.parent
+        @series = Series.new(TASK_BASE, self)
+        @project = {}
+        @extensions = []
+        @script = {
+          group: {},
+          ref: {},
+          build: nil,
+          dev: nil,
+          prod: nil
+        }
+        @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
+      end
+
+      def build(**kwargs)
+        return unless enabled?
+
+        @project.each_value do |proj|
+          next unless proj.enabled?
+
+          series.populate(proj)
+          proj.populate(**kwargs)
+        end
+
+        Application.project_kind.each { |obj| obj.populate(self, **kwargs) }
+        @extensions.each { |ext| __send__(ext, **kwargs) }
+
+        series[:refresh].clear if series[:refresh].all? { |val| val.end_with?(':build') }
+
+        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')
+
+          if series.has?(init[0]) && !task_defined?('init')
+            desc 'init'
+            task init: init
+          end
+        end
+        series.finalize!(kwargs.fetch(:parallel, []))
+
+        yield self if block_given?
+      end
+
+      def run(script, group: nil, ref: nil)
+        script_command :run, script, group, ref
+      end
+
+      def depend(script, group: nil, ref: nil)
+        script_command :depend, script, group, ref
+      end
+
+      def clean(script, group: nil, ref: nil)
+        script_command :clean, script, group, ref
+      end
+
+      def doc(script, group: nil, ref: nil)
+        script_command :doc, script, group, ref
+      end
+
+      def test(script, group: nil, ref: nil)
+        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]
+        self
+      end
+
+      def group(name, path, **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]
+        end
+        .each do |basename, dir, override|
+          opts = kwargs.dup
+          opts.merge!(override) if override
+          add(basename, dir, group: name, **opts)
+        end
+        self
+      end
+
+      def compose(name, &blk)
+        namespace(name, &blk)
+        self
+      end
+
+      def apply(&blk)
+        instance_eval(&blk)
+        self
+      end
+
+      def style(name, *args, target: nil, empty: false)
+        data = nil
+        if target
+          as_a(target).each_with_index do |val, i|
+            if i == 0
+              break unless (data = __get__(:theme)[val.to_sym])
+            else
+              data = data[val.to_sym] ||= {}
+            end
+          end
+          return unless data
+        end
+        apply_style(data || theme, name, *args, empty: empty)
+        self
+      end
+
+      def script(group: nil, ref: nil)
+        if group || ref
+          (group && @script[:group][group.to_sym]) || (ref && @script[:ref][ref.to_sym])
+        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
+        return ret == equals.to_s unless equals.nil?
+
+        ret.empty? || (ignore && as_a(ignore).any? { |val| ret == val.to_s }) ? default : ret
+      end
+
+      def root_path(*args)
+        root.join(*args)
+      end
+
+      def home_path(*args)
+        home.join(*args)
+      end
+
+      def find_base(obj)
+        Application.project_kind.find { |proj| obj.instance_of?(proj) }
+      end
+
+      def to_s
+        root.to_s
+      end
+
+      def inspect
+        "#<#{self.class}: #{main} => #{self}>"
+      end
+
+      def enabled?
+        !@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")
+      end
+
+      def task_include?(obj, key)
+        TASK_EXTEND.fetch(key, []).any? { |item| obj.is_a?(item) }
+      end
+
+      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?))
+      end
+
+      def prod?(script: nil, pat: nil, global: false)
+        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
+      end
+
+      private
+
+      def script_command(task, val, group, ref)
+        if group
+          label = :group
+          items = as_a(group)
+        else
+          label = :ref
+          items = as_a(ref)
+        end
+        items.each { |name| (@script[label][name.to_sym] ||= {})[task] = val }
+        self
+      end
+
+      def with?(state, script: nil, pat: nil, global: false)
+        if global
+          pat = @script[state] if pat.nil?
+          script ||= @script[:build]
+        end
+        pat.is_a?(::Regexp) ? pat.match?(script) : pat == true
+      end
+    end
+  end
+end

data/lib/squared/{repo → workspace}/project/base.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'forwardable'
 require 'date'
+require 'logger'
 
 module Squared
-  module Repo
+  module Workspace
     module Project
       class Base
         include Common
@@ -12,7 +12,8 @@ module Squared
         include Shell
         include Task
         include ::Rake::DSL
-        extend Forwardable
+
+        SEM_VER = /^(\d+)(\.)(\d+)(?:(\.)(\d+))?$/.freeze
 
         class << self
           include Common::Task
@@ -25,13 +26,16 @@ module Squared
           end
 
           def as_path(val)
-            return val if val.is_a?(::Pathname)
-
-            val.is_a?(::String) ? Pathname.new(val) : nil
+            case val
+            when ::Pathname
+              val
+            when ::String
+              Pathname.new(val)
+            end
           end
 
           def to_s
-            /[^:]+$/.match(super.to_s)[0]
+            super.to_s.match(/[^:]+$/)[0]
           end
 
           def to_sym
@@ -42,15 +46,9 @@ module Squared
         @@print_order = 0
         @@tasks = {}
 
-        alias __warn__ warn
-
-        attr_reader :name, :project, :workspace, :group, :path, :logger, :theme
+        attr_reader :name, :project, :workspace, :group, :path, :log, :theme
         attr_accessor :warning
 
-        protected :logger
-
-        def_delegators :logger, :log, :<<, :debug, :info, :warn, :error, :fatal, :unknown
-
         def initialize(name, path, workspace, *, group: nil, log: nil, common: true, **kwargs)
           @name = name.to_s
           @path = workspace.root_path(path.to_s)
@@ -63,12 +61,14 @@ module Squared
           @output = [kwargs[:run], nil]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
-          @theme = if common
+          @warning = workspace.warning
+          @theme = if !workspace.verbose
+                     {}
+                   elsif common
                      workspace.theme
                    else
                      __get__(:theme)[:project][to_sym] ||= {}
                    end
-          @warning = workspace.warning
           log = { file: log } unless log.is_a?(::Hash)
           if (logfile = env('LOG_FILE')).nil? && (auto = env('LOG_AUTO'))
             logfile = case auto
@@ -87,10 +87,10 @@ module Squared
               logfile.realdirpath
             rescue StandardError => e
               logfile = nil
-              __warn__ e if @warning
+              warn e if @warning
             end
           end
-          @logger = Logger.new(logfile, progname: @name, level: env('LOG_LEVEL') || log[:level] || Logger::INFO)
+          @log = Logger.new(logfile, progname: @name, level: env('LOG_LEVEL') || log[:level] || Logger::INFO)
         end
 
         def initialize_build(ref, **kwargs)
@@ -100,15 +100,13 @@ module Squared
           elsif @script && @output[0] != false
             @output[0] ||= @script[:run]
           end
+          @dev = kwargs.delete(:dev)
           if env('BUILD', suffix: 'DEV', equals: '0')
             @dev = false
-          else
-            @dev = kwargs.delete(:dev)
-            if env('BUILD', suffix: 'DEV')
-              @dev = true
-            elsif @dev.nil?
-              @dev = workspace.dev?
-            end
+          elsif env('BUILD', suffix: 'DEV')
+            @dev = true
+          elsif @dev.nil?
+            @dev = workspace.dev?
           end
         end
 
@@ -125,12 +123,8 @@ module Squared
         def populate(*)
           namespace name do
             workspace.series.each_key do |key|
-              case key
-              when :build, :refresh, :depend, :outdated, :doc, :test, :copy, :clean
-                next unless has?(key)
-              else
-                next unless workspace.task_defined?(self, key)
-              end
+              next unless Application::WORKSPACE_KEYS.include?(key) ? has?(key) : workspace.task_include?(self, key)
+
               desc message(name, key)
               task key do
                 __send__(key)
@@ -139,7 +133,7 @@ module Squared
           end
         end
 
-        def build(*args)
+        def build(*args, sync: true)
           if args.empty?
             cmd, opts = @output
             opts &&= shell_escape(opts)
@@ -160,13 +154,13 @@ module Squared
             cmd = compose(opts)
             banner = env('REPO_BUILD') == 'verbose'
           end
-          run(cmd, exception: workspace.exception, banner: banner)
+          run(cmd, exception: workspace.exception, banner: banner, sync: sync)
         end
 
         def refresh(*)
-          build
+          build(sync: invoked_sync?('depend'))
           key = "#{name}:copy"
-          if ::Rake::Task.task_defined?(key)
+          if workspace.task_defined?(key)
             invoke key
           else
             copy
@@ -174,34 +168,35 @@ module Squared
         end
 
         def depend(*)
-          run(@depend, exception: workspace.exception) if @depend
+          run(@depend, exception: workspace.exception, sync: invoked_sync?('depend')) if @depend
         end
 
         def copy(*)
-          run_s @copy
+          run_s(@copy, sync: invoked_sync?('copy'))
         end
 
         def doc
-          build @doc if @doc
+          build(@doc, sync: invoked_sync?('doc')) if @doc
         end
 
         def test
-          build @test if @test
+          build(@test, sync: invoked_sync?('test')) if @test
         end
 
         def clean
           return unless @clean
 
           if @clean.is_a?(::String)
-            run_s @clean
+            run_s(@clean, sync: invoked_sync?('clean'))
           else
             @clean.each do |val|
-              if (val = val.to_s).match?(%r{[\\/]$})
+              val = val.to_s
+              if val =~ %r{[\\/]$}
                 dir = Pathname.new(val)
                 dir = base_path(dir) unless dir.absolute?
                 next unless dir.directory?
 
-                warn "rm -rf #{dir}"
+                log.warn "rm -rf #{dir}"
                 dir.rmtree(verbose: true)
               else
                 files = val.include?('*') ? Dir[base_path(val)] : [base_path(val)]
@@ -209,7 +204,7 @@ module Squared
                   begin
                     File.delete(file) if File.file?(file)
                   rescue StandardError => e
-                    error e
+                    log.error e
                   end
                 end
               end
@@ -246,7 +241,7 @@ module Squared
         end
 
         def refresh?
-          build? && (copy? || ::Rake::Task.task_defined?("#{name}:copy"))
+          build? && (copy? || workspace.task_defined?("#{name}:copy"))
         end
 
         def depend?
@@ -271,36 +266,36 @@ module Squared
 
         protected
 
-        def run(cmd = @session, exception: false, banner: true, req: nil)
+        def run(cmd = @session, exception: false, banner: true, sync: true, req: nil)
           return if req && !base_path(req).exist?
 
           cmd = close_session(cmd)
-          info cmd
-          print_item format_banner(cmd, banner: banner)
+          log.info cmd
+          print_item format_banner(cmd, banner: banner) if sync
           begin
             shell(cmd, chdir: path, exception: exception)
           rescue StandardError => e
-            error e
+            log.error e
             raise
           end
         end
 
-        def run_s(cmd)
-          run(cmd, exception: workspace.exception, banner: verbose?) if cmd.is_a?(::String)
+        def run_s(cmd, **kwargs)
+          run(cmd, exception: workspace.exception, banner: verbose?, **kwargs) if cmd.is_a?(::String)
         end
 
-        def env(key, suffix: nil, equals: nil, strict: false)
-          alt = "#{key}_#{name.upcase}"
-          ret = if suffix
-                  ENV.fetch(([alt] + as_a(suffix)).join('_'), '')
-                else
-                  ENV.fetch(alt, strict ? '' : ENV[key]).to_s
-                end
-          if !equals.nil?
-            ret == equals.to_s
-          elsif !ret.empty? && ret != '0'
-            ret
+        def env(key, equals: nil, ignore: ['0'].freeze, default: nil, suffix: nil, strict: false)
+          a = "#{key}_#{name.upcase}"
+          b = ''
+          if suffix
+            a = [a, suffix].flatten.join('_')
+          elsif !strict
+            b = ENV.fetch(key, '')
           end
+          ret = ENV.fetch(a, b)
+          return ret == equals.to_s unless equals.nil?
+
+          ret.empty? || as_a(ignore).any? { |val| ret == val.to_s } ? default : ret
         end
 
         def session(*cmd, options: nil)
@@ -312,8 +307,8 @@ module Squared
 
         def close_session(cmd)
           return cmd unless cmd.respond_to?(:done)
-          raise ArgumentError, message('none were provided', hint: name) if cmd.empty?
 
+          raise_error('none were provided', hint: name) if cmd.empty?
           @session = nil if cmd == @session
           cmd.done
         end
@@ -324,26 +319,40 @@ module Squared
           puts val unless val.empty? || (val.size == 1 && val.first.nil?)
         end
 
-        def print_banner(*lines, styles: nil, pad: 0, first: false)
+        def print_banner(*lines, styles: theme[:banner], border: theme[:border])
+          pad = 0
+          if styles
+            if styles.any? { |s| s.to_s.end_with?('!') }
+              pad = 1
+            elsif styles.size <= 1
+              styles = [:bold] + styles
+            end
+          end
           n = max_width(lines)
           ch = ' ' * pad
           index = -1
           out = lines.map do |val|
             index += 1
             val = ch + val.ljust(n - (pad * 2)) + ch
-            if styles && (!first || index == 0)
+            if styles && (pad == 1 || index == 0)
               sub_style(val, *styles)
             else
               val
             end
           end
-          out << ('-' * n)
+          out << sub_style('-' * n, styles: border)
           out.join("\n")
         end
 
-        def print_footer(*lines)
+        def print_footer(*lines, sub: nil, border: theme[:border])
           n = max_width(lines)
-          ['-' * n, *lines.map { |val| val.ljust(n) }].join("\n")
+          sub = as_a(sub)
+          lines.map! do |val|
+            s = val.ljust(n)
+            sub.each { |h| s = sub_style(s, **h) }
+            s
+          end
+          [sub_style('-' * n, styles: border), *lines].join("\n")
         end
 
         def format_desc(action, flag, opts = nil, req: 'opts*')
@@ -355,20 +364,12 @@ module Squared
           message(name, action, opts ? "#{flag}[#{opts}]" : flag)
         end
 
-        def format_banner(cmd, banner: true, multitask: false)
+        def format_banner(cmd, banner: true, multiple: false)
           return unless banner
 
           if verbose?
-            pad = 0
-            if (args = theme[:banner])
-              if args.any? { |s| s.to_s.end_with?('!') }
-                pad = 1
-              elsif args.size <= 1
-                args = [:bold] + args
-              end
-            end
-            print_banner(cmd.sub(/^\S+/, &:upcase), path.to_s, styles: args, pad: pad, first: pad == 0)
-          elsif multitask && workspace.multitask?
+            print_banner(cmd.sub(/^\S+/, &:upcase), path.to_s)
+          elsif multiple && workspace.series.multiple?
             "## #{path} ##"
           end
         end
@@ -386,17 +387,17 @@ module Squared
             return unless (val = args[key]).nil? || (pat && !val.match?(pat))
 
             @session = nil
-            raise ArgumentError, message(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
+            raise_error(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
           elsif args.is_a?(::Array)
             return unless args.empty?
 
             @session = nil
-            raise ArgumentError, message(action, "#{flag}[]", hint: 'empty')
+            raise_error(action, "#{flag}[]", hint: 'empty')
           end
           return unless action.to_s.empty?
 
           @session = nil
-          raise ArgumentError, message('parameter', flag, hint: 'missing')
+          raise_error('parameter', flag, hint: 'missing')
         end
 
         def verbose?
@@ -408,13 +409,12 @@ module Squared
         end
 
         def invoked_sync?(action)
-          return true if invoked?(sync = "#{action}:sync")
+          return true if workspace.series.sync?("#{action}:sync")
 
-          missing = ->(val) { ::Rake::Task.tasks.none? { |item| item.name == val } }
           check = lambda do |val|
             if invoked?(val)
-              missing.("#{val}:sync")
-            elsif invoked?("#{val}:sync")
+              !workspace.task_defined?("#{val}:sync")
+            elsif workspace.series.sync?("#{val}:sync")
               true
             end
           end
@@ -426,7 +426,7 @@ module Squared
             ret = check.("#{action}:#{base.to_sym}")
             return ret unless ret.nil?
           end
-          invoked?("#{name}:#{action}") && (!invoked?(action) || missing.(sync))
+          invoked?("#{name}:#{action}") && (!invoked?(action) || !workspace.task_defined?("#{action}:sync"))
         end
 
         private