squared 0.0.1

data/lib/squared/repo/workspace.rb

@@ -0,0 +1,427 @@
+# frozen_string_literal: true
+
+module Squared
+  module Repo
+    class Workspace
+      include Common
+      include Format
+      include System
+      include Task
+      include ::Rake::DSL
+
+      TASK_NAME = {
+        build: [],
+        copy: [],
+        depend: [],
+        outdated: [],
+        refresh: [],
+        doc: [],
+        clean: []
+      }
+      TASK_BASE = {}
+      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
+
+        attr_reader :project_kind
+      end
+
+      @project_kind = []
+
+      attr_reader :main, :root, :home, :series
+      attr_accessor :script, :manifest, :manifest_url, :exception, :styles, :verbose
+
+      def initialize(main)
+        prompt = lambda do |path|
+          return false unless path.directory?
+
+          confirm "#{log_title(:warn)} \"#{sub_style(path, :bold)}\" is not empty. Continue with installation? [y/N] "
+        end
+        @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 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 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
+        @styles = {}
+        @project = {}
+        @exception = !env('PIPE_FAIL', ignore: '0').nil?
+        @pipe = !env('PIPE_OUT', ignore: '0').nil?
+        @verbose = true
+      end
+
+      def repo(url, manifest = 'latest')
+        @manifest_url = url
+        @manifest = manifest
+        self
+      end
+
+      def run(script, **kwargs)
+        @script = case (val = env('REPO_BUILD'))
+                  when 'verbose'
+                    "#{script}:verbose"
+                  when 'silent'
+                    @verbose = false
+                    script
+                  else
+                    val || script
+                  end
+        @dev = bool_match(env('REPO_DEV'), kwargs[:dev])
+        @prod = bool_match(env('REPO_PROD'), kwargs[:prod])
+        self
+      end
+
+      def add(name, dir = nil, **kwargs)
+        path = (dir || name).to_s
+        ref = kwargs[:ref]
+        project = if !ref.is_a?(::Class)
+                    Workspace.find(path: root_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
+        self
+      end
+
+      def build(default: nil, parallel: [])
+        group = {}
+        parent = {}
+        incl = Set.new
+        @project.each do |name, proj|
+          next unless proj.enabled?
+
+          @series.each do |key, items|
+            target = "#{name}:#{key}"
+            case key
+            when :build, :refresh, :depend, :outdated, :doc, :copy, :clean
+              next unless proj.has?(key) || ::Rake::Task.task_defined?(target)
+            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))
+
+            id = base.to_sym.to_s
+            next if id == proj.group
+
+            incl << id
+            (parent[:"#{key}:#{id}"] ||= []).push(target)
+          end
+          proj.populate
+        end
+        @series.merge!(parent) if incl.size > 1
+        @series.merge!(group)
+        if @manifest_url && (empty?(@root) || @override)
+          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
+              # rubocop:disable Style/CombinableLoops
+              @project.each_value { |proj| proj.depend if proj.enabled? }
+              @project.each_value do |proj|
+                next unless proj.enabled? && proj.build?
+
+                proj.has?(:dev) ? proj.refresh : proj.build
+              end
+              # rubocop:enable Style/CombinableLoops
+            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
+        return unless enabled?
+
+        multi = env('REPO_SYNC', ignore: '0') ? [] : parallel.map(&:to_sym)
+        output = dev? ? :refresh : :build
+
+        task default: default || output
+
+        desc 'all[git?=rebase|stash]'
+        task :all, [:git] do |_, args|
+          sync = ->(key) { multi.include?(key) ? :"#{key}:sync" : key }
+          pull = case args.git
+                 when 'rebase'
+                   sync.(:rebase)
+                 when 'stash'
+                   invoke sync.(:stash)
+                   sync.(:pull)
+                 else
+                   sync.(:pull)
+                 end
+          invoke(pull, exception: @exception)
+          invoke(output, exception: @exception)
+        end
+
+        desc 'init'
+        task init: [:depend, output]
+
+        @series.each do |key, items|
+          next if items.empty?
+
+          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
+
+            desc "#{key} (sync)"
+            task "#{key}:sync": items
+          else
+            desc key.to_s
+            task key => items
+          end
+        end
+      end
+
+      def compose(name, &block)
+        namespace(name, &block)
+        self
+      end
+
+      def apply(&block)
+        instance_eval(&block)
+        self
+      end
+
+      def style(name, *args)
+        set = ->(k, v) { @styles[k.to_sym] = check_style(v, empty: false) }
+        if name.is_a?(Hash)
+          name.each { |k, v| set.(k, v || args.flatten) }
+        else
+          set.(name, args.flatten)
+        end
+        self
+      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'
+        file = root_path('.repo/manifest.xml')
+        return unless file.exist?
+
+        doc = REXML::Document.new(File.read(file))
+        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 empty?(dir)
+        return true if dir.empty? || dir.join('.repo').directory?
+        return true if dir.children.size == 1 && dir.join(dir.children.first).to_s == __FILE__
+
+        dir == @root && !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 enabled?
+        !@series[:build].empty? || !@series[:doc].empty?
+      end
+
+      def multitask?
+        ::Rake::Task.tasks.any? do |item|
+          next unless item.already_invoked
+
+          item.name.end_with?(':sync') || (!item.name.include?(':') && !item.name.start_with?('all', 'init'))
+        end
+      end
+
+      def task_defined?(obj, key)
+        obj.is_a?(TASK_BASE[key])
+      end
+
+      def dev?(pat = nil, script: nil)
+        with?(pat, script: script, state: @dev)
+      end
+
+      def prod?(pat = nil, script: nil)
+        return false if @dev == true || !@prod
+
+        with?(pat, script: script, state: @prod)
+      end
+
+      def pipe?
+        @pipe
+      end
+
+      protected
+
+      def confirm(msg, agree: 'Y', cancel: 'N', 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
+              end
+              attempts -= 1
+              exit 1 unless attempts >= 0
+            end
+          rescue Interrupt
+            puts
+            exit 0
+          else
+            ret
+          end
+        end
+      end
+
+      private
+
+      def with?(pat, script: nil, state: nil)
+        pat = state if pat.nil?
+        return pat == true unless pat.is_a?(::Regexp)
+
+        pat.match?(script || @script)
+      end
+    end
+  end
+end
+
+Repo = Squared::Repo

data/lib/squared/repo.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Squared
+  module Repo
+    class << self
+      def resolve(*args)
+        ret = args.map do |id|
+          if id.is_a?(::Symbol)
+            project id
+          else
+            (id = Pathname.new(id).realdirpath.to_s) rescue nil if id.is_a?(::String)
+            get(:project).find { |_, val| val.path.to_s == id.to_s }
+          end
+        end
+        ret.size == 1 ? ret.first : ret
+      end
+
+      def expect(name)
+        ret = project(name)
+        return ret if ret&.path&.directory?
+
+        raise NoMethodError, message('project is not initialized', name)
+      end
+
+      def project?(name)
+        !!project(name)&.enabled?
+      end
+
+      private
+
+      def project(name)
+        get(:project)[name.to_sym]
+      end
+    end
+  end
+end
+
+require_relative 'repo/workspace'
+require_relative 'repo/project'

data/lib/squared/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Squared
+  VERSION = '0.0.1'
+end

data/lib/squared.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'squared/version'
+require_relative 'squared/common'
+require_relative 'squared/repo'
+require_relative 'squared/config'
+
+Repo::Workspace.implement(
+  Repo::Project::Git,
+  Repo::Project::Node,
+  Repo::Project::Python,
+  Repo::Project::Ruby
+)

data/squared.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "lib/squared/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "squared"
+  spec.version       = Squared::VERSION
+  spec.authors       = ["An Pham"]
+  spec.email         = ["anpham6@gmail.com"]
+
+  spec.summary       = %q{Rake task generator for managing multi-language workspaces.}
+  spec.description   = %q{Rake task generator for managing multi-language workspaces.}
+  spec.homepage      = "https://github.com/anpham6/squared"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+  spec.licenses      = ["BSD-3-Clause"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = "https://squared.readthedocs.io"
+
+  spec.files         = Dir["lib/**/*"] +
+                       %w[LICENSE README.md README.ruby.md squared.gemspec]
+  spec.bindir        = "exe"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rake"
+  spec.add_dependency "logger"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: squared
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- An Pham
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rake task generator for managing multi-language workspaces.
+email:
+- anpham6@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- README.ruby.md
+- lib/squared.rb
+- lib/squared/common.rb
+- lib/squared/common/class.rb
+- lib/squared/common/format.rb
+- lib/squared/common/shell.rb
+- lib/squared/common/system.rb
+- lib/squared/common/task.rb
+- lib/squared/config.rb
+- lib/squared/repo.rb
+- lib/squared/repo/project.rb
+- lib/squared/repo/project/base.rb
+- lib/squared/repo/project/git.rb
+- lib/squared/repo/project/node.rb
+- lib/squared/repo/project/python.rb
+- lib/squared/repo/project/ruby.rb
+- lib/squared/repo/workspace.rb
+- lib/squared/version.rb
+- squared.gemspec
+homepage: https://github.com/anpham6/squared
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://github.com/anpham6/squared
+  source_code_uri: https://github.com/anpham6/squared
+  documentation_uri: https://squared.readthedocs.io
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Rake task generator for managing multi-language workspaces.
+test_files: []