squared 0.0.1

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

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Squared
+  module Repo
+    module Project
+      class Base
+        include Common
+        include Shell
+        include System
+        include Task
+        include ::Rake::DSL
+        extend Forwardable
+
+        class << self
+          def tasks
+            [].freeze
+          end
+
+          def to_s
+            to_sym.to_s.capitalize
+          end
+
+          def to_sym
+            :base
+          end
+        end
+
+        @@print_order = 0
+        @@tasks = {}
+
+        attr_reader :name, :project, :workspace, :group, :path, :logger
+
+        protected :logger
+
+        def_delegators :logger, :log, :level=, :<<, :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
+          @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]
+          @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"
+                      when 'm', 'month'
+                        "#{name}-#{Date.today.strftime('%Y-%m')}.log"
+                      when 'd', 'day', '1'
+                        "#{name}-#{Date.today}.log"
+                      else
+                        log[:file]
+                      end
+          else
+            logfile = log[:file]
+          end
+          if (dir = env('LOG_DIR'))
+            logfile &&= Pathname.new(dir).join(logfile)
+          end
+          @logger = Logger.new(logfile, level: env('LOG_LEVEL') || log[:level] || Logger::INFO)
+          @logger.progname = name
+          @session = nil
+        end
+
+        def populate(*)
+          namespace @name do
+            @workspace.series.each_key do |key|
+              case key
+              when :build, :refresh, :depend, :outdated, :doc, :copy, :clean
+                next unless has?(key)
+              else
+                next unless @workspace.task_defined?(self, key)
+              end
+              desc message(@name, key)
+              task key do
+                send(key)
+              end
+            end
+          end
+        end
+
+        def build(*args)
+          if args.empty?
+            cmd, opts = @output
+            opts &&= shell_escape(opts)
+          else
+            cmd = args.shift
+            opts = sanitize_args(*args)
+          end
+          if cmd
+            if opts
+              cmd = "#{cmd} #{opts}"
+            elsif cmd.is_a?(::Array)
+              cmd = cmd.join(' && ')
+            end
+            banner = verbose?
+          else
+            return unless respond_to?(:compose)
+
+            cmd = compose(opts)
+            banner = env('REPO_BUILD') == 'verbose'
+          end
+          run(cmd, exception: @workspace.exception, banner: banner)
+        end
+
+        def refresh(*)
+          build
+          key = "#{@name}:copy"
+          if ::Rake::Task.task_defined?(key)
+            invoke key
+          else
+            copy
+          end
+        end
+
+        def depend(*)
+          run(@depend, exception: @workspace.exception) if @depend
+        end
+
+        def doc
+          build @doc if @doc
+        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?
+
+              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
+                end
+              end
+            end
+          end
+        end
+
+        def styles
+          @workspace.styles
+        end
+
+        def base_path(*args)
+          @path.join(*args)
+        end
+
+        def to_s
+          @path.to_s
+        end
+
+        def to_sym
+          @name.to_sym
+        end
+
+        def enabled?
+          @path.directory? && !@path.empty?
+        end
+
+        def has?(method)
+          respond_to?(m = :"#{method}?") && send(m)
+        end
+
+        def build?
+          return false if @output[0] == false
+
+          !doc? || !@output[0].nil?
+        end
+
+        def refresh?
+          build?
+        end
+
+        def depend?
+          !@depend.nil?
+        end
+
+        def doc?
+          !@doc.nil?
+        end
+
+        def copy?
+          @copy.is_a?(::String)
+        end
+
+        def clean?
+          !@clean.nil?
+        end
+
+        def verbose?
+          @workspace.verbose && !pipe?
+        end
+
+        protected
+
+        def run(cmd = @session, exception: false, banner: true, req: nil)
+          return if req && !base_path(req).exist?
+
+          cmd = close_session(cmd)
+          info cmd
+          print_item format_banner(cmd, banner: banner)
+          begin
+            shell(cmd, chdir: @path, exception: exception)
+          rescue StandardError => e
+            error e
+            raise
+          end
+        end
+
+        def run_s(cmd)
+          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}"
+          ret = if suffix
+                  ENV.fetch(([val] + as_a(suffix)).join('_'), '')
+                else
+                  ENV.fetch(val, strict ? '' : ENV[key]).to_s
+                end
+          return ret == equals.to_s unless equals.nil?
+
+          ret unless ret.empty? || ret == '0'
+        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
+          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?
+
+          @session = nil if cmd == @session
+          cmd.done
+        end
+
+        def print_item(*val)
+          puts unless @@print_order == 0 || pipe?
+          @@print_order += 1
+          puts val unless val.empty? || (val.size == 1 && val.first.nil?)
+        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)
+        end
+
+        def format_banner(cmd, banner: true, multitask: false)
+          return unless banner
+
+          if verbose?
+            pad = 0
+            if (args = styles[:banner])
+              if args.any? { |s| s.to_s.end_with?('!') }
+                pad = 1
+              elsif args.size <= 1
+                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} ##"
+          end
+        end
+
+        def empty_status(msg, title, obj)
+          "#{msg}#{!obj || obj == 0 || obj.to_s.empty? ? '' : message(hint: message(title, obj.to_s))}"
+        end
+
+        def append_nocolor
+          @session << (!ENV.fetch('NO_COLOR', '').empty? || pipe? ? '--no-color' : '')
+        end
+
+        def guard_params(action, flag, args: nil, key: nil, pat: nil)
+          if args && key
+            return unless (val = args[key]).nil? || (pat && !pat.match?(val))
+
+            @session = nil
+            raise ArgumentError, message(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')
+          end
+          return unless action.to_s.empty?
+
+          @session = nil
+          raise ArgumentError, message('parameter', flag, hint: 'missing')
+        end
+
+        def pipe?
+          @workspace.pipe?
+        end
+
+        def invoked_sync?(action)
+          return true if invoked?(group = "#{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")
+              true
+            end
+          end
+          if @group
+            ret = check.("#{action}:#{@group}")
+            return ret unless ret.nil?
+          end
+          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))
+        end
+      end
+    end
+  end
+end