squared 0.0.5 → 0.0.6

data/lib/squared/repo/workspace.rb

@@ -1,552 +0,0 @@
-# frozen_string_literal: true
-
-module Squared
-  module Repo
-    class Workspace
-      include Common
-      include Format
-      include System
-      include Task
-      include ::Rake::DSL
-
-      TASK_NAME = {
-        build: [],
-        refresh: [],
-        depend: [],
-        outdated: [],
-        doc: [],
-        test: [],
-        copy: [],
-        clean: []
-      }
-      TASK_BASE = {}
-      TASK_KEYS = TASK_NAME.keys.freeze
-      private_constant :TASK_NAME, :TASK_BASE
-
-      class << self
-        def implement(*objs)
-          objs.each do |obj|
-            next unless obj < Project::Base
-
-            project_kind.unshift(obj)
-            obj.tasks&.each do |val|
-              TASK_NAME[val] = []
-              TASK_BASE[val] = 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, :sync, :multiple, :parallel
-      attr_accessor :manifest, :manifest_url, :exception, :pipe, :verbose, :warning
-
-      def initialize(main, *, common: true, **)
-        @main = main.to_s
-        @home = if (val = env('REPO_HOME'))
-                  home = Pathname.new(val)
-                  if @main == home.basename.to_s
-                    @root = home.parent
-                    if home.exist?
-                      @root = nil unless home.directory?
-                    elsif !@root.exist?
-                      @root.mkpath
-                    elsif !empty?(@root)
-                      if repo_prompt(@root)
-                        @override = true
-                      else
-                        @root = nil
-                      end
-                    end
-                  end
-                  raise ArgumentError, message('REPO_HOME', val, hint: 'invalid') unless @root
-
-                  home.realdirpath
-                elsif (val = env('REPO_ROOT'))
-                  @root = Pathname.new(val).realdirpath
-                  if !@root.exist?
-                    @root.mkpath
-                  elsif !empty?(@root)
-                    raise ArgumentError, message('REPO_ROOT', val, hint: 'exist') unless repo_prompt(@root)
-
-                    @override = true
-                  end
-                  @root.join(@main).realdirpath
-                else
-                  empty?(pwd = Pathname.pwd) ? pwd.join(@main) : pwd
-                end
-        @root ||= @home.parent
-        @series = TASK_NAME.dup
-        @project = {}
-        @script = {
-          group: {},
-          ref: {},
-          build: nil,
-          dev: nil,
-          prod: nil
-        }
-        @exception = !env('PIPE_FAIL', ignore: '0').nil?
-        @pipe = !env('PIPE_OUT', ignore: '0').nil?
-        @verbose = !@pipe
-        @warning = !empty?(@root, repo: false)
-        @sync = []
-        @multiple = []
-        @parallel = []
-        @theme = common && @verbose ? __get__(:theme)[:workspace] : {}
-      end
-
-      def build(**kwargs)
-        return unless enabled?
-
-        default = kwargs[:default]
-        multi = env('REPO_SYNC', ignore: '0') ? [] : kwargs.fetch(:parallel, []).map!(&:to_sym)
-
-        group = {}
-        parent = {}
-        incl = []
-        @project.each do |name, proj|
-          next unless proj.enabled?
-
-          series.each do |key, items|
-            target = "#{name}:#{key}"
-            case key
-            when :build, :refresh, :depend, :copy, :outdated, :doc, :test, :clean
-              valid = proj.has?(key) || ::Rake::Task.task_defined?(target)
-              next unless valid || (key == :refresh && series[:build].include?(target = "#{name}:build"))
-            else
-              next unless task_defined?(proj, key)
-            end
-            if proj.group
-              incl << proj.group
-              (group[:"#{key}:#{proj.group}"] ||= []).push(target)
-            else
-              items << target
-            end
-            next unless (base = find_base(proj))
-
-            unless (id = base.to_sym.to_s) == proj.group
-              incl << id
-              (parent[:"#{key}:#{id}"] ||= []).push(target)
-            end
-          end
-          proj.populate(**kwargs)
-        end
-        series.merge!(parent) if incl.uniq.size > 1
-        series.merge!(group)
-        series[:refresh].clear if series[:refresh].all? { |target| target.end_with?(':build') }
-
-        if repo?
-          branch = env('REPO_MANIFEST') || read_manifest
-          target = branch || manifest
-          stage = nil
-          failfast = true
-          cmd = []
-          newline = ARGV.index { |val| val.start_with?('repo:') }.to_i > 0
-          parse_opts = lambda do |args|
-            collect_args(args, :opts).each do |val|
-              case val
-              when 'no-fail'
-                failfast = false
-              when 'force'
-                cmd << '--force-checkout'
-              when 'rebase'
-                cmd << '--rebase'
-              when 'detach'
-                cmd << '--detach'
-              when 'gc'
-                cmd << '--auto-gc'
-              when 'no-update'
-                cmd << '--no-manifest-update'
-              end
-            end
-          end
-          status = lambda do |val, alt = nil|
-            ver = branch || alt
-            ver ? message('repo', val.sub('{0}', 'opts*=force,rebase,detach,gc,no-update,no-fail'), ver) : 'inactive'
-          end
-
-          namespace :repo do |repo|
-            desc status.('all[{0}]')
-            task :all, [:opts] do |_, args|
-              parse_opts.(args)
-              stage ||= :all
-              repo[:sync].invoke
-              @project.select do |_, proj|
-                if proj.enabled?
-                  proj.depend
-                  proj.build?
-                end
-              end
-              .each_value { |proj| proj.has?(:dev) ? proj.refresh : proj.build }
-            end
-
-            desc status.("init[manifest?=#{target},{0}]", target)
-            task :init, [:manifest, :opts] do |_, args|
-              parse_opts.(args)
-              stage = :init
-              puts if newline
-              system("repo init -u #{manifest_url} -m #{args.manifest || target}.xml", chdir: root)
-              repo[:all].invoke
-            end
-
-            desc status.('sync[{0}]')
-            task :sync, [:opts] do |_, args|
-              raise LoadError, message('repo is not initialized', 'rake repo:init') unless branch || stage == :init
-
-              parse_opts.(args)
-              cmd << "-j#{ENV.fetch('REPO_JOBS', ::Rake::CpuCounter.count)}"
-              cmd << '--fail-fast' if failfast
-              puts if newline && stage != :init
-              begin
-                shell("repo sync #{cmd.join(' ')}", chdir: root, exception: failfast)
-              rescue StandardError => e
-                emphasize(e, title: "rake stash repo:#{stage || 'sync'}")
-                raise
-              end
-            end
-          end
-        end
-
-        Workspace.project_kind.each { |obj| obj.populate(self, **kwargs) }
-
-        if !series[:build].empty?
-          init = [:depend, dev? && !series[:refresh].empty? ? :refresh : :build]
-
-          task default: default || init[1]
-
-          desc 'init'
-          task init: init
-        elsif default && !series[default].empty?
-          task default: default
-        end
-
-        series.each do |key, items|
-          next if items.empty?
-
-          s = key.to_s
-          if items.size > 1
-            multiple << s
-            unless (valid = multi.include?(key))
-              group = key.to_s
-              valid = multi.include?(group.split(':').first.to_sym) if group.include?(':')
-            end
-            if valid
-              desc "#{key} (thread)"
-              multitask key => items
-              parallel << s
-
-              desc "#{key} (sync)"
-              task "#{key}:sync": items
-              sync << "#{key}:sync"
-              multiple << "#{key}:sync"
-              next
-            end
-          end
-          desc s
-          task key => items
-        end
-
-        yield self if block_given?
-      end
-
-      def repo(url, manifest = 'latest', run: nil, dev: nil, prod: nil)
-        @manifest_url = url
-        @manifest = manifest
-        script = case (val = env('REPO_BUILD'))
-                 when 'verbose'
-                   @verbose = true
-                   run ? "#{run}:verbose" : nil
-                 when 'silent'
-                   @verbose = false
-                   @warning = false
-                   run
-                 else
-                   val || run
-                 end
-        case env('REPO_WARN')
-        when '0'
-          @warning = false
-        when '1'
-          @warning = true
-        end
-        return self unless script
-
-        run(script, dev: bool_match(env('REPO_DEV'), dev), prod: bool_match(env('REPO_DEV'), prod))
-      end
-
-      def run(script, group: nil, ref: nil, **kwargs)
-        if group || ref
-          script_command :run, script, group, ref
-        else
-          @script[:build] = script
-          @script[:dev] = kwargs[:dev]
-          @script[:prod] = kwargs[:prod]
-          self
-        end
-      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)
-                    Workspace.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)
-        ret = ENV.fetch("#{key}_#{main.gsub(/[^\w]/, '_').upcase}", ENV[key]).to_s
-        return ret == equals.to_s if equals
-
-        ret.empty? || as_a(ignore).any? { |val| ret == val.to_s } ? nil : ret
-      end
-
-      def read_manifest(*)
-        require 'rexml/document'
-        return unless (file = root_path('.repo/manifest.xml')).exist?
-
-        doc = REXML::Document.new(file.read)
-        doc.elements['manifest/include'].attributes['name']&.sub('.xml', '')
-      end
-
-      def root_path(*args)
-        root.join(*args)
-      end
-
-      def home_path(*args)
-        home.join(*args)
-      end
-
-      def find_base(obj)
-        Workspace.project_kind.find { |proj| obj.instance_of?(proj) }
-      end
-
-      def bool_match(val, pat)
-        case val
-        when nil, ''
-          pat.is_a?(::Regexp) ? pat : nil
-        when '0'
-          false
-        when '1'
-          true
-        else
-          Regexp.new(val)
-        end
-      end
-
-      def to_s
-        root.to_s
-      end
-
-      def inspect
-        "#<#{self.class}: #{main} => #{self}>"
-      end
-
-      def enabled?
-        repo? || @project.any? { |_, proj| proj.enabled? }
-      end
-
-      def repo?
-        !manifest_url.nil? && (empty?(root) || @override)
-      end
-
-      def multiple?(val = nil)
-        return multiple.include?(val) && invoked?(val) if val
-
-        ::Rake::Task.tasks.any? { |item| item.already_invoked && multiple.include?(item.name) }
-      end
-
-      def sync?(val = nil)
-        return sync.include?(val) && invoked?(val) if val
-
-        ::Rake::Task.tasks.any? { |item| item.already_invoked && sync.include?(item.name) }
-      end
-
-      def parallel?(val = nil)
-        return parallel.include?(val) && invoked?(val) if val
-
-        ::Rake::Task.tasks.any? { |item| item.already_invoked && parallel.include?(item.name) }
-      end
-
-      def empty?(dir, repo: true)
-        return true if dir.empty? || (repo && dir.join('.repo').directory?)
-        return true if dir.children.size == 1 && dir.join(dir.children.first).to_s == __FILE__
-
-        dir.to_s == root.to_s && !env('REPO_ROOT').nil? && root.children.none? do |path|
-          path.directory? && !path.basename.to_s.start_with?('.') && path.to_s != home.to_s
-        end
-      end
-
-      def task_defined?(obj, key)
-        obj.is_a?(TASK_BASE[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'
-        Timeout.timeout(ENV.fetch('REPO_TIMEOUT', timeout).to_i) do
-          ret = false
-          begin
-            while (ch = Readline.readline(msg, true))
-              case ch.chomp.upcase
-              when agree
-                ret = true
-                break
-              when cancel
-                break
-              when ''
-                case default
-                when agree
-                  ret = true
-                  break
-                when cancel
-                  break
-                end
-              end
-              attempts -= 1
-              exit 1 unless attempts >= 0
-            end
-          rescue Interrupt
-            puts
-            exit 0
-          else
-            ret
-          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 repo_prompt(path)
-        return false unless path.directory?
-
-        confirm("#{log_title(:warn)} \"#{sub_style(path, :bold)}\" is not empty. Continue with installation? [y/N] ",
-                default: 'N')
-      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
-
-Repo = Squared::Repo