summaryrefslogtreecommitdiff
path: root/tool/lib/vcs.rb
diff options
context:
space:
mode:
Diffstat (limited to 'tool/lib/vcs.rb')
-rw-r--r--tool/lib/vcs.rb669
1 files changed, 669 insertions, 0 deletions
diff --git a/tool/lib/vcs.rb b/tool/lib/vcs.rb
new file mode 100644
index 0000000000..dd6162c8c2
--- /dev/null
+++ b/tool/lib/vcs.rb
@@ -0,0 +1,669 @@
+# vcs
+require 'fileutils'
+require 'optparse'
+
+# This library is used by several other tools/ scripts to detect the current
+# VCS in use (e.g. SVN, Git) or to interact with that VCS.
+
+ENV.delete('PWD')
+
+unless File.respond_to? :realpath
+ require 'pathname'
+ def File.realpath(arg)
+ Pathname(arg).realpath.to_s
+ end
+end
+
+def IO.pread(*args)
+ STDERR.puts(args.inspect) if $DEBUG
+ popen(*args) {|f|f.read}
+end
+
+if RUBY_VERSION < "2.0"
+ class IO
+ @orig_popen = method(:popen)
+
+ if defined?(fork)
+ def self.popen(command, *rest, &block)
+ if command.kind_of?(Hash)
+ env = command
+ command = rest.shift
+ end
+ opts = rest.last
+ if opts.kind_of?(Hash)
+ dir = opts.delete(:chdir)
+ rest.pop if opts.empty?
+ opts.delete(:external_encoding)
+ end
+
+ if block
+ @orig_popen.call("-", *rest) do |f|
+ if f
+ yield(f)
+ else
+ Dir.chdir(dir) if dir
+ ENV.replace(env) if env
+ exec(*command)
+ end
+ end
+ else
+ f = @orig_popen.call("-", *rest)
+ unless f
+ Dir.chdir(dir) if dir
+ ENV.replace(env) if env
+ exec(*command)
+ end
+ f
+ end
+ end
+ else
+ require 'shellwords'
+ def self.popen(command, *rest, &block)
+ if command.kind_of?(Hash)
+ env = command
+ oldenv = ENV.to_hash
+ command = rest.shift
+ end
+ opts = rest.last
+ if opts.kind_of?(Hash)
+ dir = opts.delete(:chdir)
+ rest.pop if opts.empty?
+ opts.delete(:external_encoding)
+ end
+
+ command = command.shelljoin if Array === command
+ Dir.chdir(dir || ".") do
+ ENV.replace(env) if env
+ @orig_popen.call(command, *rest, &block)
+ ENV.replace(oldenv) if oldenv
+ end
+ end
+ end
+ end
+else
+ module DebugPOpen
+ verbose, $VERBOSE = $VERBOSE, nil if RUBY_VERSION < "2.1"
+ refine IO.singleton_class do
+ def popen(*args)
+ STDERR.puts args.inspect if $DEBUG
+ super
+ end
+ end
+ ensure
+ $VERBOSE = verbose unless verbose.nil?
+ end
+ using DebugPOpen
+ module DebugSystem
+ def system(*args)
+ STDERR.puts args.inspect if $DEBUG
+ exception = false
+ opts = Hash.try_convert(args[-1])
+ if RUBY_VERSION >= "2.6"
+ unless opts
+ opts = {}
+ args << opts
+ end
+ exception = opts.fetch(:exception) {opts[:exception] = true}
+ elsif opts
+ exception = opts.delete(:exception) {true}
+ args.pop if opts.empty?
+ end
+ ret = super(*args)
+ raise "Command failed with status (#$?): #{args[0]}" if exception and !ret
+ ret
+ end
+ end
+ module Kernel
+ prepend(DebugSystem)
+ end
+end
+
+class VCS
+ prepend(DebugSystem) if defined?(DebugSystem)
+ class NotFoundError < RuntimeError; end
+
+ @@dirs = []
+ def self.register(dir, &pred)
+ @@dirs << [dir, self, pred]
+ end
+
+ def self.detect(path, options = {}, argv = ::ARGV)
+ uplevel_limit = options.fetch(:uplevel_limit, 0)
+ curr = path
+ begin
+ @@dirs.each do |dir, klass, pred|
+ if pred ? pred[curr, dir] : File.directory?(File.join(curr, dir))
+ vcs = klass.new(curr)
+ vcs.parse_options(argv)
+ return vcs
+ end
+ end
+ if uplevel_limit
+ break if uplevel_limit.zero?
+ uplevel_limit -= 1
+ end
+ prev, curr = curr, File.realpath(File.join(curr, '..'))
+ end until curr == prev # stop at the root directory
+ raise VCS::NotFoundError, "does not seem to be under a vcs: #{path}"
+ end
+
+ def self.local_path?(path)
+ String === path or path.respond_to?(:to_path)
+ end
+
+ attr_reader :srcdir
+
+ def initialize(path)
+ @srcdir = path
+ super()
+ end
+
+ def parse_options(opts, parser = OptionParser.new)
+ case opts
+ when Array
+ parser.on("--[no-]dryrun") {|v| @dryrun = v}
+ parser.on("--[no-]debug") {|v| @debug = v}
+ parser.parse(opts)
+ @debug = $DEBUG unless defined?(@debug)
+ @dryrun = @debug unless defined?(@dryrun)
+ when Hash
+ unless (keys = opts.keys - [:debug, :dryrun]).empty?
+ raise "Unknown options: #{keys.join(', ')}"
+ end
+ @debug = opts.fetch(:debug) {$DEBUG}
+ @dryrun = opts.fetch(:dryrun) {@debug}
+ end
+ end
+
+ attr_reader :dryrun, :debug
+ alias dryrun? dryrun
+ alias debug? debug
+
+ NullDevice = defined?(IO::NULL) ? IO::NULL :
+ %w[/dev/null NUL NIL: NL:].find {|dev| File.exist?(dev)}
+
+ # return a pair of strings, the last revision and the last revision in which
+ # +path+ was modified.
+ def get_revisions(path)
+ if self.class.local_path?(path)
+ path = relative_to(path)
+ end
+ last, changed, modified, *rest = (
+ begin
+ if NullDevice
+ save_stderr = STDERR.dup
+ STDERR.reopen NullDevice, 'w'
+ end
+ _get_revisions(path, @srcdir)
+ rescue Errno::ENOENT => e
+ raise VCS::NotFoundError, e.message
+ ensure
+ if save_stderr
+ STDERR.reopen save_stderr
+ save_stderr.close
+ end
+ end
+ )
+ last or raise VCS::NotFoundError, "last revision not found"
+ changed or raise VCS::NotFoundError, "changed revision not found"
+ if modified
+ /\A(\d+)-(\d+)-(\d+)\D(\d+):(\d+):(\d+(?:\.\d+)?)\s*(?:Z|([-+]\d\d)(\d\d))\z/ =~ modified or
+ raise "unknown time format - #{modified}"
+ match = $~[1..6].map { |x| x.to_i }
+ off = $7 ? "#{$7}:#{$8}" : "+00:00"
+ match << off
+ begin
+ modified = Time.new(*match)
+ rescue ArgumentError
+ modified = Time.utc(*$~[1..6]) + $7.to_i * 3600 + $8.to_i * 60
+ end
+ end
+ return last, changed, modified, *rest
+ end
+
+ def modified(path)
+ _, _, modified, * = get_revisions(path)
+ modified
+ end
+
+ def relative_to(path)
+ if path
+ srcdir = File.realpath(@srcdir)
+ path = File.realdirpath(path)
+ list1 = srcdir.split(%r{/})
+ list2 = path.split(%r{/})
+ while !list1.empty? && !list2.empty? && list1.first == list2.first
+ list1.shift
+ list2.shift
+ end
+ if list1.empty? && list2.empty?
+ "."
+ else
+ ([".."] * list1.length + list2).join("/")
+ end
+ else
+ '.'
+ end
+ end
+
+ def after_export(dir)
+ end
+
+ def revision_name(rev)
+ self.class.revision_name(rev)
+ end
+
+ def short_revision(rev)
+ self.class.short_revision(rev)
+ end
+
+ class SVN < self
+ register(".svn")
+ COMMAND = ENV['SVN'] || 'svn'
+
+ def self.revision_name(rev)
+ "r#{rev}"
+ end
+
+ def self.short_revision(rev)
+ rev
+ end
+
+ def _get_revisions(path, srcdir = nil)
+ if srcdir and local_path?(path)
+ path = File.join(srcdir, path)
+ end
+ if srcdir
+ info_xml = IO.pread(%W"#{COMMAND} info --xml #{srcdir}")
+ info_xml = nil unless info_xml[/<url>(.*)<\/url>/, 1] == path.to_s
+ end
+ info_xml ||= IO.pread(%W"#{COMMAND} info --xml #{path}")
+ _, last, _, changed, _ = info_xml.split(/revision="(\d+)"/)
+ modified = info_xml[/<date>([^<>]*)/, 1]
+ branch = info_xml[%r'<relative-url>\^/(?:branches/|tags/)?([^<>]+)', 1]
+ [last, changed, modified, branch]
+ end
+
+ def self.search_root(path)
+ return unless local_path?(path)
+ parent = File.realpath(path)
+ begin
+ parent = File.dirname(wkdir = parent)
+ return wkdir if File.directory?(wkdir + "/.svn")
+ end until parent == wkdir
+ end
+
+ def get_info
+ @info ||= IO.pread(%W"#{COMMAND} info --xml #{@srcdir}")
+ end
+
+ def url
+ unless @url
+ url = get_info[/<root>(.*)<\/root>/, 1]
+ @url = URI.parse(url+"/") if url
+ end
+ @url
+ end
+
+ def wcroot
+ unless @wcroot
+ info = get_info
+ @wcroot = info[/<wcroot-abspath>(.*)<\/wcroot-abspath>/, 1]
+ @wcroot ||= self.class.search_root(@srcdir)
+ end
+ @wcroot
+ end
+
+ def branch(name)
+ return trunk if name == "trunk"
+ url + "branches/#{name}"
+ end
+
+ def tag(name)
+ url + "tags/#{name}"
+ end
+
+ def trunk
+ url + "trunk"
+ end
+ alias master trunk
+
+ def branch_list(pat)
+ IO.popen(%W"#{COMMAND} ls #{branch('')}") do |f|
+ f.each do |line|
+ line.chomp!
+ line.chomp!('/')
+ yield(line) if File.fnmatch?(pat, line)
+ end
+ end
+ end
+
+ def grep(pat, tag, *files, &block)
+ cmd = %W"#{COMMAND} cat"
+ files.map! {|n| File.join(tag, n)} if tag
+ set = block.binding.eval("proc {|match| $~ = match}")
+ IO.popen([cmd, *files]) do |f|
+ f.grep(pat) do |s|
+ set[$~]
+ yield s
+ end
+ end
+ end
+
+ def export(revision, url, dir, keep_temp = false)
+ if @srcdir and (rootdir = wcroot)
+ srcdir = File.realpath(@srcdir)
+ rootdir << "/"
+ if srcdir.start_with?(rootdir)
+ subdir = srcdir[rootdir.size..-1]
+ subdir = nil if subdir.empty?
+ FileUtils.mkdir_p(svndir = dir+"/.svn")
+ FileUtils.ln_s(Dir.glob(rootdir+"/.svn/*"), svndir)
+ system(COMMAND, "-q", "revert", "-R", subdir || ".", :chdir => dir) or return false
+ FileUtils.rm_rf(svndir) unless keep_temp
+ if subdir
+ tmpdir = Dir.mktmpdir("tmp-co.", "#{dir}/#{subdir}")
+ File.rename(tmpdir, tmpdir = "#{dir}/#{File.basename(tmpdir)}")
+ FileUtils.mv(Dir.glob("#{dir}/#{subdir}/{.[^.]*,..?*,*}"), tmpdir)
+ begin
+ Dir.rmdir("#{dir}/#{subdir}")
+ end until (subdir = File.dirname(subdir)) == '.'
+ FileUtils.mv(Dir.glob("#{tmpdir}/#{subdir}/{.[^.]*,..?*,*}"), dir)
+ Dir.rmdir(tmpdir)
+ end
+ return true
+ end
+ end
+ IO.popen(%W"#{COMMAND} export -r #{revision} #{url} #{dir}") do |pipe|
+ pipe.each {|line| /^A/ =~ line or yield line}
+ end
+ $?.success?
+ end
+
+ def after_export(dir)
+ FileUtils.rm_rf(dir+"/.svn")
+ end
+
+ def branch_beginning(url)
+ # `--limit` of svn-log is useless in this case, because it is
+ # applied before `--search`.
+ rev = IO.pread(%W[ #{COMMAND} log --xml
+ --search=matz --search-and=has\ started
+ -- #{url}/version.h])[/<logentry\s+revision="(\d+)"/m, 1]
+ rev.to_i if rev
+ end
+
+ def export_changelog(url, from, to, path)
+ range = [to || 'HEAD', (from ? from+1 : branch_beginning(url))].compact.join(':')
+ IO.popen({'TZ' => 'JST-9', 'LANG' => 'C', 'LC_ALL' => 'C'},
+ %W"#{COMMAND} log -r#{range} #{url}") do |r|
+ open(path, 'w') do |w|
+ IO.copy_stream(r, w)
+ end
+ end
+ end
+
+ def commit
+ args = %W"#{COMMAND} commit"
+ if dryrun?
+ STDERR.puts(args.inspect)
+ return true
+ end
+ system(*args)
+ end
+ end
+
+ class GIT < self
+ register(".git") {|path, dir| File.exist?(File.join(path, dir))}
+ COMMAND = ENV["GIT"] || 'git'
+
+ def cmd_args(cmds, srcdir = nil)
+ (opts = cmds.last).kind_of?(Hash) or cmds << (opts = {})
+ opts[:external_encoding] ||= "UTF-8"
+ if srcdir and self.class.local_path?(srcdir)
+ opts[:chdir] ||= srcdir
+ end
+ STDERR.puts cmds.inspect if debug?
+ cmds
+ end
+
+ def cmd_pipe_at(srcdir, cmds, &block)
+ without_gitconfig { IO.popen(*cmd_args(cmds, srcdir), &block) }
+ end
+
+ def cmd_read_at(srcdir, cmds)
+ without_gitconfig { IO.pread(*cmd_args(cmds, srcdir)) }
+ end
+
+ def cmd_pipe(*cmds, &block)
+ cmd_pipe_at(@srcdir, cmds, &block)
+ end
+
+ def cmd_read(*cmds)
+ cmd_read_at(@srcdir, cmds)
+ end
+
+ def _get_revisions(path, srcdir = nil)
+ gitcmd = [COMMAND]
+ last = cmd_read_at(srcdir, [[*gitcmd, 'rev-parse', 'HEAD']]).rstrip
+ log = cmd_read_at(srcdir, [[*gitcmd, 'log', '-n1', '--date=iso', '--pretty=fuller', *path]])
+ changed = log[/\Acommit (\h+)/, 1]
+ modified = log[/^CommitDate:\s+(.*)/, 1]
+ branch = cmd_read_at(srcdir, [gitcmd + %W[symbolic-ref --short HEAD]])
+ if branch.empty?
+ branch_list = cmd_read_at(srcdir, [gitcmd + %W[branch --list --contains HEAD]]).lines.to_a
+ branch, = branch_list.grep(/\A\*/)
+ case branch
+ when /\A\* *\(\S+ detached at (.*)\)\Z/
+ branch = $1
+ branch = nil if last.start_with?(branch)
+ when /\A\* (\S+)\Z/
+ branch = $1
+ else
+ branch = nil
+ end
+ unless branch
+ branch_list.each {|b| b.strip!}
+ branch_list.delete_if {|b| / / =~ b}
+ branch = branch_list.min_by(&:length) || ""
+ end
+ end
+ branch.chomp!
+ branch = ":detached:" if branch.empty?
+ upstream = cmd_read_at(srcdir, [gitcmd + %W[branch --list --format=%(upstream:short) #{branch}]])
+ upstream.chomp!
+ title = cmd_read_at(srcdir, [gitcmd + %W[log --format=%s -n1 #{upstream}..HEAD]])
+ title = nil if title.empty?
+ [last, changed, modified, branch, title]
+ end
+
+ def self.revision_name(rev)
+ short_revision(rev)
+ end
+
+ def self.short_revision(rev)
+ rev[0, 10]
+ end
+
+ def without_gitconfig
+ home = ENV.delete('HOME')
+ yield
+ ensure
+ ENV['HOME'] = home if home
+ end
+
+ def initialize(*)
+ super
+ if srcdir = @srcdir and self.class.local_path?(srcdir)
+ @srcdir = File.realpath(srcdir)
+ end
+ self
+ end
+
+ Branch = Struct.new(:to_str)
+
+ def branch(name)
+ Branch.new(name)
+ end
+
+ alias tag branch
+
+ def master
+ branch("master")
+ end
+ alias trunk master
+
+ def stable
+ cmd = %W"#{COMMAND} for-each-ref --format=\%(refname:short) refs/heads/ruby_[0-9]*"
+ branch(cmd_read(cmd)[/.*^(ruby_\d+_\d+)$/m, 1])
+ end
+
+ def branch_list(pat)
+ cmd = %W"#{COMMAND} for-each-ref --format=\%(refname:short) refs/heads/#{pat}"
+ cmd_pipe(cmd) {|f|
+ f.each {|line|
+ line.chomp!
+ yield line
+ }
+ }
+ end
+
+ def grep(pat, tag, *files, &block)
+ cmd = %W[#{COMMAND} grep -h --perl-regexp #{tag} --]
+ set = block.binding.eval("proc {|match| $~ = match}")
+ cmd_pipe(cmd+files) do |f|
+ f.grep(pat) do |s|
+ set[$~]
+ yield s
+ end
+ end
+ end
+
+ def export(revision, url, dir, keep_temp = false)
+ ret = system(COMMAND, "clone", "-s", (@srcdir || '.').to_s, "-b", url, dir)
+ ret
+ end
+
+ def after_export(dir)
+ FileUtils.rm_rf(Dir.glob("#{dir}/.git*"))
+ end
+
+ def branch_beginning(url)
+ cmd_read(%W[ #{COMMAND} log -n1 --format=format:%H
+ --author=matz --committer=matz --grep=has\ started
+ -- version.h include/ruby/version.h])
+ end
+
+ def export_changelog(url, from, to, path)
+ from, to = [from, to].map do |rev|
+ rev or next
+ if Integer === rev
+ rev = cmd_read({'LANG' => 'C', 'LC_ALL' => 'C'},
+ %W"#{COMMAND} log -n1 --format=format:%H" <<
+ "--grep=^ *git-svn-id: .*@#{rev} ")
+ end
+ rev unless rev.empty?
+ end
+ unless /./.match(from ||= branch_beginning(url))
+ raise "cannot find the beginning revision of the branch"
+ end
+ range = [from, (to || 'HEAD')].join('^..')
+ cmd_pipe({'TZ' => 'JST-9', 'LANG' => 'C', 'LC_ALL' => 'C'},
+ %W"#{COMMAND} log --format=medium --no-notes --date=iso-local --topo-order #{range}", "rb") do |r|
+ format_changelog(r, path)
+ end
+ end
+
+ def format_changelog(r, path)
+ IO.copy_stream(r, path)
+ end
+
+ def commit(opts = {})
+ args = [COMMAND, "push"]
+ args << "-n" if dryrun
+ (branch = cmd_read(%W"#{COMMAND} symbolic-ref --short HEAD")).chomp!
+ (upstream = cmd_read(%W"#{COMMAND} branch --list --format=%(upstream) #{branch}")).chomp!
+ while ref = upstream[%r"\Arefs/heads/(.*)", 1]
+ upstream = cmd_read(%W"#{COMMAND} branch --list --format=%(upstream) #{ref}")
+ end
+ unless %r"\Arefs/remotes/([^/]+)/(.*)" =~ upstream
+ raise "Upstream not found"
+ end
+ args << $1 << "HEAD:#$2"
+ if dryrun?
+ STDERR.puts(args.inspect)
+ return true
+ end
+ system(*args) or return false
+ true
+ end
+ end
+
+ class GITSVN < GIT
+ def self.revision_name(rev)
+ SVN.revision_name(rev)
+ end
+
+ def self.short_revision(rev)
+ SVN.short_revision(rev)
+ end
+
+ def format_changelog(r, path)
+ open(path, 'w') do |w|
+ sep = "-"*72
+ w.puts sep
+ while s = r.gets('')
+ author = s[/^Author:\s*(\S+)/, 1]
+ time = s[/^Date:\s*(.+)/, 1]
+ s = r.gets('')
+ s.gsub!(/^ {4}/, '')
+ s.sub!(/^git-svn-id: .*@(\d+) .*\n+\z/, '')
+ rev = $1
+ s.gsub!(/^ {8}/, '') if /^(?! {8}|$)/ !~ s
+ s.sub!(/\n\n\z/, "\n")
+ if /\A(\d+)-(\d+)-(\d+)/ =~ time
+ date = Time.new($1.to_i, $2.to_i, $3.to_i).strftime("%a, %d %b %Y")
+ end
+ lines = s.count("\n")
+ lines = "#{lines} line#{lines == 1 ? '' : 's'}"
+ w.puts "r#{rev} | #{author} | #{time} (#{date}) | #{lines}\n\n"
+ w.puts s, sep
+ end
+ end
+ end
+
+ def last_changed_revision
+ rev = cmd_read(%W"#{COMMAND} svn info"+[STDERR=>[:child, :out]])[/^Last Changed Rev: (\d+)/, 1]
+ com = cmd_read(%W"#{COMMAND} svn find-rev r#{rev}").chomp
+ return rev, com
+ end
+
+ def commit(opts = {})
+ rev, com = last_changed_revision
+ head = cmd_read(%W"#{COMMAND} symbolic-ref --short HEAD").chomp
+
+ commits = cmd_read([COMMAND, "log", "--reverse", "--format=%H %ae %ce", "#{com}..@"], "rb").split("\n")
+ commits.each_with_index do |l, i|
+ r, a, c = l.split
+ dcommit = [COMMAND, "svn", "dcommit"]
+ dcommit.insert(-2, "-n") if dryrun
+ dcommit << "--add-author-from" unless a == c
+ dcommit << r
+ system(*dcommit) or return false
+ system(COMMAND, "checkout", head) or return false
+ system(COMMAND, "rebase") or return false
+ end
+
+ if rev
+ old = [cmd_read(%W"#{COMMAND} log -1 --format=%H").chomp]
+ old << cmd_read(%W"#{COMMAND} svn reset -r#{rev}")[/^r#{rev} = (\h+)/, 1]
+ 3.times do
+ sleep 2
+ system(*%W"#{COMMAND} pull --no-edit --rebase")
+ break unless old.include?(cmd_read(%W"#{COMMAND} log -1 --format=%H").chomp)
+ end
+ end
+ true
+ end
+ end
+end