squared 0.0.4 → 0.0.6

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Squared
+  module Workspace
+    module Project
+      class Python < Git
+        REF = :python
+        REQUIREMENTS = %w[requirements.txt pyproject.toml setup.py].freeze
+        OPT_USER = %w[pre dry-run].freeze
+        OPT_FORCE = [*OPT_USER, 'user'].freeze
+        OPT_UPGRADE = [*OPT_FORCE, 'eager'].freeze
+        OPT_GENERAL = %w{venv isolated no-cache [v]erbose}.freeze
+        private_constant :REF, :REQUIREMENTS, :OPT_USER, :OPT_FORCE, :OPT_UPGRADE, :OPT_GENERAL
+
+        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
+
+        attr_reader :requirements
+
+        def initialize(name, path, workspace, *, **kwargs)
+          super
+          @reqindex = REQUIREMENTS.index { |file| base_path(file).exist? } || 0
+          @requirements = base_path(REQUIREMENTS[@reqindex])
+          initialize_build(REF, **kwargs)
+        end
+
+        @@tasks[REF] = {
+          install: %i[user 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
+                    list = case flag
+                           when :upgrade
+                             OPT_UPGRADE
+                           when :force
+                             OPT_FORCE
+                           else
+                             OPT_USER
+                           end
+                    desc format_desc(action, flag, list + OPT_GENERAL)
+                    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 (type = install_type)
+            when 1, 2
+              cmd = pip_session 'install'
+              case flag
+              when :user
+                cmd << '--user'
+                append_general opts, OPT_USER
+              when :upgrade
+                cmd << '--upgrade'
+                append_general opts, OPT_UPGRADE
+              when :force
+                cmd << '--force-reinstall'
+                append_general opts, OPT_FORCE
+              end
+              cmd << (type == 1 ? '-r requirements.txt' : '.')
+              run(exception: workspace.exception, sync: invoked_sync?('depend'))
+            when 3
+              run_s("#{@bin} setup.py install", sync: invoked_sync?('depend'))
+            end
+          end
+        end
+
+        def outdated(*); end
+
+        def install_type(*)
+          requirements.exist? ? @reqindex + 1 : 0
+        end
+
+        def depend?
+          outdated? || !!@depend
+        end
+
+        def outdated?
+          install_type > 0
+        end
+
+        private
+
+        def pip_session(*cmd)
+          session('pip', *cmd)
+        end
+
+        def append_general(opts, list = [])
+          list += OPT_GENERAL
+          opts.each do |opt|
+            next unless (v = opt.match(/^v+$/)) || list.include?(opt)
+
+            @session << case opt
+                        when 'eager'
+                          '--upgrade-strategy=eager'
+                        when 'venv'
+                          '--require-virtualenv'
+                        when 'no-cache'
+                          '--no-cache-dir'
+                        else
+                          (v ? "-#{v[0]}" : "--#{opt}")
+                        end
+          end
+          @session << '--user' if env('PIP_USER')
+          @session << '--no-input' if env('PIP_NO_INPUT')
+          if (val = env('PIP_PROXY'))
+            @session << "--proxy=#{shell_escape(val, quote: true)}"
+          end
+          append_nocolor
+        end
+      end
+    end
+  end
+end

data/lib/squared/{repo → workspace}/project/ruby.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Squared
-  module Repo
+  module Workspace
     module Project
       class Ruby < Git
         REF = :ruby
@@ -33,17 +33,21 @@ module Squared
           rake: nil
         }.freeze
 
-        def initialize(name, path, workspace, *, **kwargs)
+        attr_reader :gemfile
+
+        def initialize(name, path, workspace, *, version: nil, autodetect: false, **kwargs)
           super
           initialize_build(REF, **kwargs)
-          @version = env('BUILD', suffix: 'VERSION', strict: true) || kwargs.delete(:version)
-          @autodetect = kwargs.key?(:autodetect) ? kwargs.delete(:autodetect) : false
+          @version = env('BUILD', suffix: 'VERSION', strict: true) || version
+          @autodetect = autodetect
+          index = GEMFILE.index { |file| base_path(file).exist? } || 0
+          @gemfile = base_path(GEMFILE[index])
           return if !@output[0].nil? || !@copy.nil? || @version || @autodetect || (file = rakefile).nil?
 
           begin
             pat = %r{\brequire\s+(["'])bundler/gem_tasks\1}
             File.foreach(file) do |line|
-              next unless line.match?(pat)
+              next unless line =~ pat
 
               @output[0] = 'bundle exec rake build'
               @copy = 'bundle exec rake install'
@@ -51,7 +55,7 @@ module Squared
               break
             end
           rescue StandardError => e
-            error e
+            log.error e
           end
         end
 
@@ -112,8 +116,7 @@ module Squared
           elsif outdated?
             case flag
             when :redownload, :local, :'prefer-local'
-              cmd = bundle_session 'install'
-              cmd << "--#{flag}"
+              cmd = bundle_session 'install', "--#{flag}"
               if (val = env('BUNDLE_TRUST_POLICY'))
                 cmd << "--trust-policy=#{case val
                                          when '0'
@@ -130,14 +133,15 @@ module Squared
                                            val
                                          end}"
               end
-              append_opts opts, OPT_INSTALL
+              append_bundle opts, OPT_INSTALL
             when :'with-g', :'without-g'
               guard_params('install', flag, args: group)
               cmd = gem_session 'install', '-g'
               opt = flag.to_s.sub('-g', '')
-              group.each { |s| cmd << "--#{opt}=#{shell_escape(s)}" }
+              group.each { |s| cmd << "--#{opt}=#{shell_escape(s, quote: true)}" }
             else
               cmd = bundle_session 'install'
+              append_bundle
             end
             run(banner: banner?, exception: workspace.exception)
           end
@@ -160,7 +164,7 @@ module Squared
             a = base_path(val)
             b = dest.join(val)
             c = glob[i] || '**/*'
-            warn "cp #{a.join(c)} #{b}"
+            log.warn "cp #{a.join(c)} #{b}"
             copy_d(a, b, glob: c, verbose: verbose?)
           end
         end
@@ -173,7 +177,7 @@ module Squared
           when :all, :major, :patch, :minor
             cmd << "--#{flag}"
           end
-          append_opts opts, OPT_UPDATE
+          append_bundle opts, OPT_UPDATE
           run(banner: banner?, exception: workspace.exception)
         end
 
@@ -203,7 +207,7 @@ module Squared
         end
 
         def copy?
-          return true if @copy && (@copy.is_a?(::String) || @copy.fetch(:gemdir, nil))
+          return true if @copy.is_a?(::String) || @copy&.fetch(:gemdir, nil)
           return gemdir? if @gemdir
 
           gempath = -> { "gems#{::File::SEPARATOR}#{project}-#{@version}" }
@@ -213,11 +217,11 @@ module Squared
           end
           return false unless @autodetect
 
-          quit = ->(hint) { raise ArgumentError, message('failed to parse', hint: hint) }
+          unsafe = ->(hint) { raise_error('failed to parse', hint: hint) }
           begin
             out = `gem -C #{shell_quote(path)} list --local -d #{project}`
             data = /#{Regexp.escape(project)} \(([^)]+)\)/.match(out)
-            quit.('version') unless data
+            unsafe.('version') unless data
             ver = data[1].split(/\s*,\s*/)
             if @version
               ver.unshift(@version)
@@ -227,14 +231,14 @@ module Squared
               data = /\(#{Regexp.escape(v)}(?:,[^)]+|\b)\):([^\n]+)/.match(out)
               next unless data
 
-              warn "using version #{v} (given #{@version})" if @version && @version != v
+              log.warn "using version #{v} (given #{@version})" if @version && @version != v
               @version = v
               break
             end
-            quit.('path') unless data
+            unsafe.('path') unless data
             @gemdir = Pathname.new(data[1].strip).join(gempath.())
           rescue StandardError => e
-            error e
+            log.error e
             @version = nil
             @gemdir = nil
             @autodetect = false
@@ -244,13 +248,11 @@ module Squared
         end
 
         def depend?
-          !!@depend || outdated?
+          outdated? || !!@depend
         end
 
         def outdated?
-          return @outdated unless @outdated.nil?
-
-          @outdated = GEMFILE.any? { |file| base_path(file).exist? }
+          gemfile.exist?
         end
 
         def dev?
@@ -259,15 +261,18 @@ module Squared
 
         private
 
-        def append_opts(opts, list = [])
+        def append_bundle(opts = nil, list = nil)
           if (val = env('BUNDLE_JOBS')).to_i > 0
             @session << "-j#{val}"
           end
-          list.each do |flag|
-            if opts.include?(flag)
-              @session << "--#{flag}"
-            elsif /^g(?:roup)?=(.+)$/.match(flag)
-              @session << "--group=#{$1}"
+          @session << '--norc' if env('BUNDLE_NORC')
+          return unless opts && list
+
+          opts.each do |opt|
+            if list.include?(opt)
+              @session << "--#{opt}"
+            elsif opt.match(/^g(?:roup)?=(.+)$/)
+              @session << "--group=#{shell_escape($1, quote: true)}"
             end
           end
         end

data/lib/squared/{repo → workspace}/project.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Squared
-  module Repo
+  module Workspace
     module Project
       class << self
         attr_accessor :line_width

data/lib/squared/workspace/repo.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Squared
+  module Workspace
+    module Repo
+      include Common
+      include Format
+      include System
+      include Task
+
+      attr_accessor :warning
+
+      def repo(url, manifest = 'latest', run: nil, dev: nil, prod: nil)
+        @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 !install?
+                      @root = nil unless confirm_install
+                    end
+                  end
+                  raise_error('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 !install?
+                    raise_error('REPO_ROOT', val, hint: 'exist') unless confirm_install
+                  end
+                  @root.join(@main).realdirpath
+                else
+                  install?(pwd = Pathname.pwd) ? pwd.join(@main) : pwd
+                end
+        @root = @home.parent
+        @manifest_url = url
+        @manifest = manifest
+        if repo?
+          @script[:build] = case (val = env('REPO_BUILD'))
+                            when 'verbose'
+                              @verbose = true
+                              "#{run}:verbose" if run
+                            when 'silent'
+                              @verbose = false
+                              @warning = false
+                              run
+                            else
+                              val || run
+                            end
+          @script[:dev] = bool_match(env('REPO_DEV'), dev)
+          @script[:prod] = bool_match(env('REPO_PROD'), prod)
+          @warning = case env('REPO_WARN')
+                     when '0'
+                       false
+                     when '1'
+                       true
+                     else
+                       !empty?(@root)
+                     end
+          @extensions << :__repo__
+        else
+          @script[:build] = run
+          @script[:dev] = dev
+          @script[:prod] = prod
+        end
+        self
+      end
+
+      protected
+
+      def repo?
+        !@manifest_url.nil? && (install? || !!@override)
+      end
+
+      def empty?(dir)
+        dir.empty? || (dir.children.size == 1 && dir.join(dir.children.first).to_s == __FILE__)
+      end
+
+      private
+
+      def __repo__(**kwargs)
+        kwargs.delete(:parallel) if env('REPO_SYNC', ignore: '0')
+
+        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_error('repo is not initialized', 'rake repo:init', kind: LoadError) 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
+
+      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 confirm_install
+        return false unless @root.directory?
+
+        @override = confirm(
+          "#{log_title(:warn)} \"#{sub_style(@root, :bold)}\" is not empty. Continue with installation? [y/N] ",
+          default: 'N',
+          timeout: env('REPO_TIMEOUT', ignore: '0', default: 15)
+        )
+      end
+
+      def bool_match(val, pat)
+        case val
+        when nil, ''
+          pat
+        when '0'
+          false
+        when '1'
+          true
+        else
+          Regexp.new(val)
+        end
+      end
+
+      def install?(dir = @root)
+        return true if empty?(dir) || dir.join('.repo').directory?
+        return false unless dir == root && env('REPO_HOME').nil? && !env('REPO_ROOT').nil?
+
+        root.children.none? { |path| path.directory? && path.basename.to_s[0] != '.' && path.to_s != home.to_s }
+      end
+    end
+
+    Application.include Repo
+  end
+end

data/lib/squared/workspace/series.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Squared
+  module Workspace
+    class Series
+      include ::Rake::DSL
+      extend Forwardable
+
+      attr_reader :workspace, :sync, :multiple, :parallel
+
+      def_delegators :@data, :[], :each, :each_key, :keys, :fetch, :to_a, :to_s, :inspect, :merge!, :key?, :has_key?
+
+      def initialize(tasks, workspace, keys: Workspace::Application::WORKSPACE_KEYS)
+        if tasks.is_a?(Array)
+          @data = {}
+          tasks.each { |key| __set__ key }
+        else
+          @data = tasks.dup
+        end
+        @workspace = workspace
+        @keys = keys
+        @sync = []
+        @multiple = []
+        @parallel = []
+        @session = {
+          group: {},
+          parent: {},
+          id: []
+        }
+      end
+
+      def __set__(key)
+        self[key.to_sym] ||= []
+      end
+
+      def populate(proj)
+        return unless @session
+
+        group, parent, id = @session.values
+        each do |key, items|
+          target = "#{proj.name}:#{key}"
+          if @keys.include?(key)
+            next unless proj.has?(key) || (target = workspace.task_base?(key, target))
+          else
+            next unless workspace.task_include?(proj, key)
+          end
+          if (g = proj.group)
+            id << g
+            (group[:"#{key}:#{g}"] ||= []).push(target)
+          else
+            items << target
+          end
+          next unless (b = find_base(proj)) && (name = b.to_sym.to_s) != g
+
+          id << name
+          (parent[:"#{key}:#{name}"] ||= []).push(target)
+        end
+      end
+
+      def method_missing(key, *)
+        self[key]
+      end
+
+      def finalize!(thread = [])
+        thread.map!(&:to_s)
+        group, parent, id = @session.values
+        merge!(parent) if id.uniq.size > 1
+        merge!(group)
+        each do |key, items|
+          next if items.empty?
+
+          key = key.to_s
+          if items.size > 1
+            multiple << key
+            if thread.include?(key) || (key.include?(':') && thread.include?(key.split(':').first.to_sym))
+              desc "#{key} (thread)"
+              multitask key => items
+              parallel << key
+
+              desc "#{key} (sync)"
+              task "#{key}:sync": items
+              sync << "#{key}:sync"
+              multiple << "#{key}:sync"
+              next
+            end
+          end
+
+          desc key
+          task key => items
+        end
+        @session = nil
+      end
+
+      def has?(key)
+        !key.nil? && key?(key = key.to_sym) && !self[key].empty?
+      end
+
+      def multiple?(val = nil)
+        already_invoked?(multiple, val)
+      end
+
+      def sync?(val = nil)
+        already_invoked?(sync, val)
+      end
+
+      def parallel?(val = nil)
+        already_invoked?(parallel, val)
+      end
+
+      def respond_to_missing?(key, *)
+        key?(key)
+      end
+
+      private
+
+      def already_invoked?(list, val)
+        return list.include?(val) && invoked?(val) if val
+
+        ::Rake::Task.tasks.any? { |item| item.already_invoked && list.include?(item.name) }
+      end
+    end
+  end
+end

data/lib/squared/{repo.rb → workspace.rb}

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require_relative 'common'
+
 module Squared
-  module Repo
+  module Workspace
     class << self
       def resolve(*args)
         ret = args.map do |id|
@@ -35,5 +37,6 @@ module Squared
   end
 end
 
-require_relative 'repo/workspace'
-require_relative 'repo/project'
+require_relative 'workspace/application'
+require_relative 'workspace/series'
+require_relative 'workspace/project'

data/lib/squared.rb

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