squared 0.0.1 → 0.0.2

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

@@ -1,29 +1,34 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require 'date'
 
 module Squared
   module Repo
     module Project
       class Base
-        include Common
+        include Common::System
         include Shell
-        include System
         include Task
         include ::Rake::DSL
         extend Forwardable
 
         class << self
+          include Common::Task
+          include ::Rake::DSL
+
           def tasks
             [].freeze
           end
 
+          def populate(*); end
+
           def to_s
-            to_sym.to_s.capitalize
+            /[^:]+$/.match(super.to_s)[0]
           end
 
           def to_sym
-            :base
+            to_s.downcase.to_sym
           end
         end
 
@@ -34,60 +39,86 @@ module Squared
 
         protected :logger
 
-        def_delegators :logger, :log, :level=, :<<, :debug, :info, :warn, :error, :fatal, :unknown
+        def_delegators :logger, :log, :<<, :debug, :info, :warn, :error, :fatal, :unknown
 
         def initialize(name, project, workspace, **kwargs)
           @name = name.to_s
           @path = workspace.root_path(project.to_s)
           @project = @path.basename.to_s
           @workspace = workspace
+          @group = kwargs[:group]&.to_s
           @depend = kwargs[:depend]
           @doc = kwargs[:doc]
-          @group = kwargs[:group]&.to_s
-          run = kwargs[:run]
-          opts = env('BUILD', strict: true)
-          raise ArgumentError, message("BUILD_#{name.to_s.upcase}", opts) if opts && run.is_a?(::Array)
-
-          @output = [run, opts]
+          @test = kwargs[:test]
+          @output = [kwargs[:run], nil]
           @copy = kwargs[:copy]
           @clean = kwargs[:clean]
           log = kwargs[:log]
           log = { file: log } unless log.is_a?(::Hash)
           if (logfile = env('LOG_FILE')).nil? && (auto = env('LOG_AUTO'))
-            require 'date'
             logfile = case auto
                       when 'y', 'year'
-                        "#{name}-#{Date.today.year}.log"
+                        "#{@name}-#{Date.today.year}.log"
                       when 'm', 'month'
-                        "#{name}-#{Date.today.strftime('%Y-%m')}.log"
+                        "#{@name}-#{Date.today.strftime('%Y-%m')}.log"
                       when 'd', 'day', '1'
-                        "#{name}-#{Date.today}.log"
-                      else
-                        log[:file]
+                        "#{@name}-#{Date.today}.log"
                       end
-          else
-            logfile = log[:file]
           end
-          if (dir = env('LOG_DIR'))
-            logfile &&= Pathname.new(dir).join(logfile)
+          if logfile ||= log[:file]
+            logfile = Date.today.strftime(logfile)
+            logfile = (dir = env('LOG_DIR')) ? Pathname.new(dir).join(logfile) : Pathname.new(logfile)
+            begin
+              logfile.realdirpath
+            rescue StandardError => e
+              logfile = nil
+              Warning.warn e
+            end
           end
-          @logger = Logger.new(logfile, level: env('LOG_LEVEL') || log[:level] || Logger::INFO)
-          @logger.progname = name
-          @session = nil
+          @logger = Logger.new(logfile, progname: @name, level: env('LOG_LEVEL') || log[:level] || Logger::INFO)
+        end
+
+        def initialize_build(ref, **kwargs)
+          initialize_script(ref)
+          if (val = env('BUILD', strict: true))
+            @output[0] = val
+          elsif @script && @output[0] != false
+            @output[0] ||= @script[:run]
+          end
+          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
+          end
+        end
+
+        def initialize_script(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?
+          @script = script
         end
 
         def populate(*)
-          namespace @name do
-            @workspace.series.each_key do |key|
+          namespace name do
+            workspace.series.each_key do |key|
               case key
-              when :build, :refresh, :depend, :outdated, :doc, :copy, :clean
+              when :build, :refresh, :depend, :outdated, :doc, :test, :copy, :clean
                 next unless has?(key)
               else
-                next unless @workspace.task_defined?(self, key)
+                next unless workspace.task_defined?(self, key)
               end
-              desc message(@name, key)
+              desc message(name, key)
               task key do
-                send(key)
+                __send__(key)
               end
             end
           end
@@ -114,12 +145,12 @@ 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)
         end
 
         def refresh(*)
           build
-          key = "#{@name}:copy"
+          key = "#{name}:copy"
           if ::Rake::Task.task_defined?(key)
             invoke key
           else
@@ -128,36 +159,43 @@ module Squared
         end
 
         def depend(*)
-          run(@depend, exception: @workspace.exception) if @depend
+          run(@depend, exception: workspace.exception) if @depend
         end
 
         def doc
           build @doc if @doc
         end
 
+        def test
+          build @test if @test
+        end
+
         def copy(*)
           run_s @copy
         end
 
         def clean
-          return run_s @clean if @clean.is_a?(::String)
-
-          @clean&.each do |path|
-            path = path.to_s
-            if %r{[\\/]$}.match?(path)
-              dir = Pathname.new(path)
-              dir = base_path(dir) unless dir.absolute?
-              next unless dir.directory?
+          return unless @clean
 
-              warn "rm -rf #{dir}"
-              dir.rmtree(verbose: true)
-            else
-              files = path.include?('*') ? Dir[base_path(path)] : [base_path(path)]
-              files.each do |val|
-                begin
-                  File.delete(val) if File.file?(val)
-                rescue StandardError => e
-                  warn e
+          if @clean.is_a?(::String)
+            run_s @clean
+          else
+            @clean.each do |val|
+              if (val = val.to_s).match?(%r{[\\/]$})
+                dir = Pathname.new(val)
+                dir = base_path(dir) unless dir.absolute?
+                next unless dir.directory?
+
+                warn "rm -rf #{dir}"
+                dir.rmtree(verbose: true)
+              else
+                files = val.include?('*') ? Dir[base_path(val)] : [base_path(val)]
+                files.each do |file|
+                  begin
+                    File.delete(file) if File.file?(file)
+                  rescue StandardError => e
+                    warn e
+                  end
                 end
               end
             end
@@ -165,45 +203,51 @@ module Squared
         end
 
         def styles
-          @workspace.styles
+          workspace.styles
         end
 
         def base_path(*args)
-          @path.join(*args)
+          path.join(*args)
+        end
+
+        def inspect
+          "#<#{self.class}: #{name} => #{self}>"
         end
 
         def to_s
-          @path.to_s
+          path.to_s
         end
 
         def to_sym
-          @name.to_sym
+          name.to_sym
         end
 
         def enabled?
-          @path.directory? && !@path.empty?
+          path.directory? && !path.empty?
         end
 
         def has?(method)
-          respond_to?(m = :"#{method}?") && send(m)
+          respond_to?(m = :"#{method}?") && __send__(m)
         end
 
         def build?
-          return false if @output[0] == false
-
-          !doc? || !@output[0].nil?
+          !!@output[0]
         end
 
         def refresh?
-          build?
+          build? && (copy? || ::Rake::Task.task_defined?("#{name}:copy"))
         end
 
         def depend?
-          !@depend.nil?
+          !!@depend
         end
 
         def doc?
-          !@doc.nil?
+          !!@doc
+        end
+
+        def test?
+          !!@test
         end
 
         def copy?
@@ -211,11 +255,7 @@ module Squared
         end
 
         def clean?
-          !@clean.nil?
-        end
-
-        def verbose?
-          @workspace.verbose && !pipe?
+          !!@clean
         end
 
         protected
@@ -227,7 +267,7 @@ module Squared
           info cmd
           print_item format_banner(cmd, banner: banner)
           begin
-            shell(cmd, chdir: @path, exception: exception)
+            shell(cmd, chdir: path, exception: exception)
           rescue StandardError => e
             error e
             raise
@@ -235,37 +275,33 @@ module Squared
         end
 
         def run_s(cmd)
-          run(cmd, exception: @workspace.exception, banner: verbose?) if cmd.is_a?(::String)
+          run(cmd, exception: workspace.exception, banner: verbose?) if cmd.is_a?(::String)
         end
 
         def env(key, suffix: nil, equals: nil, strict: false)
-          val = "#{key}_#{@name.upcase}"
+          alt = "#{key}_#{name.upcase}"
           ret = if suffix
-                  ENV.fetch(([val] + as_a(suffix)).join('_'), '')
+                  ENV.fetch(([alt] + as_a(suffix)).join('_'), '')
                 else
-                  ENV.fetch(val, strict ? '' : ENV[key]).to_s
+                  ENV.fetch(alt, strict ? '' : ENV[key]).to_s
                 end
-          return ret == equals.to_s unless equals.nil?
-
-          ret unless ret.empty? || ret == '0'
+          if !equals.nil?
+            ret == equals.to_s
+          elsif !ret.empty? && ret != '0'
+            ret
+          end
         end
 
         def session(*cmd, options: nil)
           if (val = ENV["#{(options || cmd.first).upcase}_OPTIONS"])
-            split_escape(val).each do |opt|
-              cmd << (if opt.start_with?('-')
-                        shell_escape(opt).sub('\\=', '=')
-                      else
-                        opt.size == 1 || /^[a-z]\d+$/i.match?(opt) ? "-#{opt}" : "--#{opt}"
-                      end)
-            end
+            split_escape(val).each { |opt| cmd << fill_option(opt) }
           end
           @session = JoinSet.new(cmd)
         end
 
         def close_session(cmd)
           return cmd unless cmd.respond_to?(:done)
-          raise ArgumentError, message('none were provided', hint: @name) if cmd.empty?
+          raise ArgumentError, message('none were provided', hint: name) if cmd.empty?
 
           @session = nil if cmd == @session
           cmd.done
@@ -277,9 +313,35 @@ module Squared
           puts val unless val.empty? || (val.size == 1 && val.first.nil?)
         end
 
+        def print_banner(*lines, styles: nil, pad: 0, first: false)
+          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)
+              sub_style(val, *styles)
+            else
+              val
+            end
+          end
+          out << ('-' * n)
+          out.join("\n")
+        end
+
+        def print_footer(*lines)
+          n = max_width(lines)
+          ['-' * n, *lines.map { |val| val.ljust(n) }].join("\n")
+        end
+
         def format_desc(action, flag, opts = nil, req: 'opts*')
           opts = "#{req}=#{opts.join(',')}" if opts.is_a?(::Array)
-          message(@name, action, opts ? "#{flag}[#{opts}]" : flag)
+          if !flag
+            flag = action
+            action = ''
+          end
+          message(name, action, opts ? "#{flag}[#{opts}]" : flag)
         end
 
         def format_banner(cmd, banner: true, multitask: false)
@@ -294,9 +356,9 @@ module Squared
                 args = [:bold] + args
               end
             end
-            Project.banner(cmd.sub(/^\S+/, &:upcase), @path.to_s, styles: args, pad: pad, first: pad == 0)
-          elsif multitask && @workspace.multitask?
-            "## #{@path} ##"
+            print_banner(cmd.sub(/^\S+/, &:upcase), path.to_s, styles: args, pad: pad, first: pad == 0)
+          elsif multitask && workspace.multitask?
+            "## #{path} ##"
           end
         end
 
@@ -310,7 +372,7 @@ module Squared
 
         def guard_params(action, flag, args: nil, key: nil, pat: nil)
           if args && key
-            return unless (val = args[key]).nil? || (pat && !pat.match?(val))
+            return unless (val = args[key]).nil? || (pat && !val.match?(pat))
 
             @session = nil
             raise ArgumentError, message(action, "#{flag}[#{key}]", hint: val.nil? ? 'missing' : 'invalid')
@@ -326,12 +388,16 @@ module Squared
           raise ArgumentError, message('parameter', flag, hint: 'missing')
         end
 
+        def verbose?
+          workspace.verbose
+        end
+
         def pipe?
-          @workspace.pipe?
+          workspace.pipe
         end
 
         def invoked_sync?(action)
-          return true if invoked?(group = "#{action}:sync")
+          return true if invoked?(sync = "#{action}:sync")
 
           missing = ->(val) { ::Rake::Task.tasks.none? { |item| item.name == val } }
           check = lambda do |val|
@@ -341,15 +407,21 @@ module Squared
               true
             end
           end
-          if @group
-            ret = check.("#{action}:#{@group}")
+          if group
+            ret = check.("#{action}:#{group}")
             return ret unless ret.nil?
           end
-          if (base = @workspace.find_base(self))
+          if (base = workspace.find_base(self))
             ret = check.("#{action}:#{base.to_sym}")
             return ret unless ret.nil?
           end
-          invoked?("#{@name}:#{action}") && (!invoked?(action) || missing.(group))
+          invoked?("#{name}:#{action}") && (!invoked?(action) || missing.(sync))
+        end
+
+        private
+
+        def max_width(lines)
+          [lines.max_by(&:size).size, Project.line_width].max
         end
       end
     end