squared 0.0.1

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

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Squared
+  module Repo
+    module Project
+      class Ruby < Git
+        GEMFILE = %w[Gemfile Gemfile.lock gem.deps.rb Isolate].freeze
+        OPT_INSTALL = %w[no-cache force quiet verbose].freeze
+        OPT_UPDATE = %w[redownload local strict conservative quiet verbose].freeze
+        private_constant :GEMFILE, :OPT_INSTALL, :OPT_UPDATE
+
+        class << self
+          def tasks
+            nil
+          end
+
+          def to_sym
+            :ruby
+          end
+
+          def is_a?(path)
+            if path.is_a?(::String) || path.is_a?(::Pathname)
+              base = Pathname.new(path)
+              [*GEMFILE, 'Rakefile', 'README.rdoc'].any? { |file| base.join(file).exist? }
+            else
+              super
+            end
+          end
+        end
+
+        @@tasks[:ruby] = {
+          install: %i[redownload local prefer-local with-g without-g],
+          update: %i[all patch minor major],
+          pristine: %i[version extensions]
+        }.freeze
+
+        def initialize(name, project, workspace, **kwargs)
+          super
+          if env('BUILD', suffix: 'DEV', equals: '0')
+            @dev = false
+          else
+            @dev = kwargs.delete(:dev)
+            if env('BUILD', suffix: 'DEV')
+              @dev = true
+            elsif @dev.nil?
+              @dev = @workspace.dev?
+            end
+          end
+          @version = env('BUILD', suffix: 'VERSION', strict: true) || kwargs.delete(:version)
+          @autodetect = kwargs.key?(:autodetect) ? kwargs.delete(:autodetect) : false
+          @gemdir = nil
+          return unless @output[0].nil? && @copy.nil? && !@version && !@autodetect && !doc? && (file = rakefile)
+
+          begin
+            pat = %r{\brequire\s+(["'])bundler/gem_tasks\1}
+            File.foreach(file) do |line|
+              next unless pat.match?(line)
+
+              @output[0] = 'bundle exec rake build'
+              @copy = 'bundle exec rake install'
+              @clean ||= 'bundle exec rake clean'
+              break
+            end
+          rescue StandardError => e
+            warn e
+          end
+        end
+
+        def populate(*)
+          super
+          return unless outdated?
+
+          namespace @name do
+            @@tasks[:ruby].each do |action, flags|
+              namespace action do
+                flags.each do |flag|
+                  case action
+                  when :install
+                    case flag
+                    when :'with-g', :'without-g'
+                      desc format_desc(action, flag, 'group+')
+                      task flag, [:group] do |_, args|
+                        install(flag, group: collect_args(args, :group))
+                      end
+                    else
+                      desc format_desc(action, flag, OPT_INSTALL)
+                      task flag, [:opts] do |_, args|
+                        install(flag, opts: collect_args(args, :opts))
+                      end
+                    end
+                  when :update
+                    desc format_desc(action, flag, OPT_UPDATE)
+                    task flag, [:opts] do |_, args|
+                      update(flag, opts: collect_args(args, :opts))
+                    end
+                  when :pristine
+                    desc format_desc(action, flag, 'version?')
+                    task flag, [:version] do |_, args|
+                      pristine(flag, version: args.version)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def depend(flag = nil, opts: [], group: [])
+          if @depend
+            super
+          else
+            case flag
+            when :redownload, :local, :'prefer-local'
+              cmd = bundle_session 'install'
+              cmd << "--#{flag}"
+              if (val = env('BUNDLE_TRUST_POLICY'))
+                cmd << "--trust-policy=#{case val
+                                         when '0'
+                                           'NoSecurity'
+                                         when '1'
+                                           'AlmostNoSecurity'
+                                         when '2'
+                                           'LowSecurity'
+                                         when '3'
+                                           'MediumSecurity'
+                                         when '4'
+                                           'HighSecurity'
+                                         else
+                                           val
+                                         end}"
+              end
+              append_opts 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)}" }
+            else
+              cmd = bundle_session 'install'
+            end
+            run(banner: banner?, exception: @workspace.exception)
+          end
+        end
+
+        def copy(from: 'lib', glob: '**/*', basedir: @gemdir, override: false)
+          if @copy && !override
+            return super if @copy.is_a?(::String)
+
+            from = @copy[:from] if @copy.key?(:from)
+            glob = @copy[:glob] if @copy.key?(:glob)
+            basedir = @copy[:basedir] if @copy.key?(:basedir)
+          end
+          return unless basedir
+
+          dest = Pathname.new(basedir).realpath
+          print_item unless @output[0]
+          glob = as_a(glob)
+          as_a(from).each_with_index do |val, i|
+            a = base_path(val)
+            b = dest.join(val)
+            c = glob[i] || '**/*'
+            warn "cp #{a.join(c)} #{b}"
+            copy_d(a, b, glob: c, verbose: verbose?)
+          end
+        end
+
+        def outdated(*); end
+
+        def update(flag, opts: [])
+          cmd = bundle_session 'update'
+          case flag
+          when :all, :major, :patch, :minor
+            cmd << "--#{flag}"
+          end
+          append_opts opts, OPT_UPDATE
+          run(banner: banner?, exception: @workspace.exception)
+        end
+
+        def pristine(flag, version: nil)
+          cmd = gem_session 'pristine', @project
+          case flag
+          when :extensions
+            cmd << '--extensions'
+          when :version
+            guard_params version, 'version'
+          end
+          cmd << "--version=#{version}" if version
+          run(banner: banner?, exception: @workspace.exception)
+        end
+
+        def rakefile
+          file = ::Rake::Application::DEFAULT_RAKEFILES.find { |val| base_path(val).exist? }
+          base_path(file) if file
+        end
+
+        def copy?
+          return true if @copy && (@copy.is_a?(::String) || @copy.fetch(:gemdir, nil))
+          return gemdir? if @gemdir
+
+          gem_path = -> { "gems#{::File::SEPARATOR}#{@project}-#{@version}" }
+          if @version && (val = ENV['GEM_HOME'])
+            @gemdir = Pathname.new(val).join(gem_path.())
+            return true if gemdir?
+          end
+          return false unless @autodetect
+
+          error = ->(hint) { raise ArgumentError, message('failed to parse', hint: hint) }
+          begin
+            out = `gem -C #{shell_quote(@path)} list --local -d #{@project}`
+            data = /#{Regexp.escape(@project)} \(([^)]+)\)/.match(out)
+            error.('version') unless data
+            ver = data[1].split(/\s*,\s*/)
+            if @version
+              ver.unshift(@version)
+              ver.uniq!
+            end
+            ver.each do |v|
+              data = /\(#{Regexp.escape(v)}(?:,[^)]+|\b)\):([^\n]+)/.match(out)
+              next unless data
+
+              warn "using version #{v} (given #{@version})" if @version && @version != v
+              @version = v
+              break
+            end
+            error.('path') unless data
+            @gemdir = Pathname.new(data[1].strip).join(gem_path.())
+          rescue StandardError => e
+            warn e
+            @version = nil
+            @gemdir = nil
+            @autodetect = false
+          else
+            gemdir?
+          end
+        end
+
+        def depend?
+          !@depend.nil? || outdated?
+        end
+
+        def outdated?
+          GEMFILE.any? { |file| base_path(file).exist? }
+        end
+
+        def dev?
+          @dev
+        end
+
+        private
+
+        def append_opts(opts, list = [])
+          if (val = env('BUNDLE_JOBS')).to_i > 0
+            @session << "-j#{val}"
+          end
+          list.each { |flag| @session << "--#{flag}" if opts.include?(flag) }
+        end
+
+        def gem_session(*cmd)
+          session('gem', *cmd)
+        end
+
+        def bundle_session(*cmd)
+          session('bundle', *cmd)
+          append_nocolor
+        end
+
+        def banner?
+          !@session.include?('--quiet')
+        end
+
+        def gemdir?
+          @gemdir.exist? && !@gemdir.empty?
+        end
+      end
+    end
+  end
+end

data/lib/squared/repo/project.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Squared
+  module Repo
+    module Project
+      class << self
+        include Common::Format
+
+        attr_accessor :line_width
+
+        def banner(*lines, styles: nil, pad: 0, first: false)
+          n = max_width(lines)
+          ch = ' ' * pad
+          index = -1
+          out = lines.map do |val|
+            index += 1
+            val = ch + val.ljust(n - (pad * 2)) + ch
+            if styles && (!first || index == 0)
+              sub_style(val, *styles)
+            else
+              val
+            end
+          end
+          out << ('-' * n)
+          out.join("\n")
+        end
+
+        def footer(*lines)
+          n = max_width(lines)
+          ['-' * n, *lines.map { |val| val.ljust(n) }].join("\n")
+        end
+
+        private
+
+        def max_width(lines)
+          [lines.max_by(&:size).size, line_width].max
+        end
+      end
+
+      @line_width = ENV.fetch('LOG_COLUMNS', 80).to_i
+    end
+  end
+end
+
+require_relative 'project/base'
+require_relative 'project/git'
+require_relative 'project/node'
+require_relative 'project/python'
+require_relative 'project/ruby'