squared 0.0.4 → 0.0.6

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: squared
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - An Pham
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-02 00:00:00.000000000 Z
+date: 2024-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -50,21 +50,24 @@ files:
 - README.ruby.md
 - lib/squared.rb
 - lib/squared/common.rb
+- lib/squared/common/base.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
+- lib/squared/workspace.rb
+- lib/squared/workspace/application.rb
+- lib/squared/workspace/project.rb
+- lib/squared/workspace/project/base.rb
+- lib/squared/workspace/project/git.rb
+- lib/squared/workspace/project/node.rb
+- lib/squared/workspace/project/python.rb
+- lib/squared/workspace/project/ruby.rb
+- lib/squared/workspace/repo.rb
+- lib/squared/workspace/series.rb
 - squared.gemspec
 homepage: https://github.com/anpham6/squared
 licenses:

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

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Squared
-  module Repo
-    module Project
-      class Python < Git
-        REF = :python
-        REQUIREMENTS = %w[requirements.txt pyproject.toml setup.py].freeze
-        private_constant :REF, :REQUIREMENTS
-
-        class << self
-          def populate(*); end
-
-          def tasks
-            nil
-          end
-
-          def venv?
-            val = ENV['VIRTUAL_ENV']
-            !val.nil? && Dir.exist?(val)
-          end
-
-          def is_a?(val)
-            if (val = as_path(val))
-              REQUIREMENTS.any? { |file| val.join(file).exist? }
-            else
-              super
-            end
-          end
-        end
-
-        def initialize(name, path, workspace, *, **kwargs)
-          super
-          initialize_build(REF, **kwargs)
-        end
-
-        @@tasks[REF] = {
-          install: %i[upgrade force]
-        }.freeze
-
-        def populate(*)
-          super
-          return unless outdated?
-
-          namespace name do
-            @@tasks[REF].each do |action, flags|
-              namespace action do
-                flags.each do |flag|
-                  case action
-                  when :install
-                    options = lambda do |*opts|
-                      opts += %w[pre venv no-cache dry-run]
-                      format_desc(action, flag, opts)
-                    end
-                    case flag
-                    when :upgrade
-                      desc options.('eager')
-                    when :force
-                      desc options.()
-                    end
-                    task flag do |_, args|
-                      depend(flag, opts: collect_args(args, :opts), override: true)
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        def depend(flag = nil, opts: [], override: false)
-          if @depend && !override
-            super
-          elsif outdated?
-            case install_type
-            when 1, 2
-              cmd = pip_session 'install'
-              case flag
-              when :upgrade
-                cmd << '--upgrade'
-                cmd << '--upgrade-strategy=eager' if opts.include?('eager')
-              when :force
-                cmd << '--force-reinstall'
-              end
-              cmd << '--pre' if opts.include?('pre')
-              cmd << '--require-virtualenv' if opts.include?('venv')
-              cmd << '--no-cache-dir' if opts.include?('no-cache')
-              cmd << '--dry-run' if opts.include?('dry-run')
-              append_nocolor
-              cmd << (install_type == 1 ? '-r requirements.txt' : '.')
-              run(exception: workspace.exception)
-            when 3
-              run_s "#{@bin} setup.py install"
-            end
-          end
-        end
-
-        def outdated(*); end
-
-        def install_type(*)
-          return @requirements if @requirements
-
-          ret = REQUIREMENTS.index { |file| base_path(file).exist? }
-          @requirements = ret ? ret + 1 : 0
-        end
-
-        def depend?
-          !!@depend || outdated?
-        end
-
-        def outdated?
-          install_type > 0
-        end
-
-        private
-
-        def pip_session(*cmd)
-          session('pip', *cmd)
-        end
-      end
-    end
-  end
-end

data/lib/squared/repo/workspace.rb

@@ -1,501 +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: [],
-        copy: [],
-        depend: [],
-        outdated: [],
-        refresh: [],
-        doc: [],
-        test: [],
-        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
-
-        def to_s
-          /[^:]+$/.match(super.to_s)[0]
-        end
-
-        attr_reader :project_kind
-      end
-
-      @project_kind = []
-
-      attr_reader :main, :root, :home, :series, :theme
-      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
-        @theme = common ? __get__(:theme)[:workspace] : {}
-        @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, init: false)
-      end
-
-      def build(**kwargs)
-        return unless enabled?
-
-        default = kwargs[:default]
-        parallel = env('REPO_SYNC', ignore: '0') ? [] : (kwargs[: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
-              # 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
-
-        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?
-
-          unless (valid = parallel.include?(key))
-            group = key.to_s
-            valid = parallel.include?(group.split(':').first.to_sym) if group.include?(':')
-          end
-          if valid && items.size > 1
-            desc "#{key} (thread)"
-            multitask key => items
-
-            desc "#{key} (sync)"
-            task "#{key}:sync": items
-          else
-            desc key.to_s
-            task key => items
-          end
-        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'
-                   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
-        script ? run(script, dev: bool_match(env('REPO_DEV'), dev), prod: bool_match(env('REPO_DEV'), prod)) : self
-      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, **kwargs)
-        path = root_path((path || name).to_s)
-        ref = kwargs[:ref]
-        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 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'
-        file = root_path('.repo/manifest.xml')
-        return unless file.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 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 empty?(dir, init: true)
-        return true if dir.empty? || (init && 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 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: (pat.nil? && global.nil?) || global)
-      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', 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 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] "
-      end
-
-      def with?(state, script: nil, pat: nil, global: false)
-        pat = @script[state] if pat.nil? && global
-        return pat == true unless pat.is_a?(::Regexp)
-        return false if !script && !global
-
-        pat.match?(script || @script[:build])
-      end
-    end
-  end
-end
-
-Repo = Squared::Repo