657 lines
18 KiB
Ruby
Executable File
657 lines
18 KiB
Ruby
Executable File
#!/usr/bin/ruby -s
|
|
# -*- coding: us-ascii -*-
|
|
require 'rubygems'
|
|
require 'rubygems/package'
|
|
require 'rubygems/package/tar_writer'
|
|
require 'uri'
|
|
require 'digest/sha1'
|
|
require 'digest/sha2'
|
|
require 'fileutils'
|
|
require 'shellwords'
|
|
require 'tmpdir'
|
|
require 'pathname'
|
|
require 'yaml'
|
|
require 'json'
|
|
require File.expand_path("../lib/vcs", __FILE__)
|
|
require File.expand_path("../lib/colorize", __FILE__)
|
|
STDOUT.sync = true
|
|
|
|
$srcdir ||= nil
|
|
$archname = nil if ($archname ||= nil) == ""
|
|
$keep_temp ||= nil
|
|
$patch_file ||= nil
|
|
$packages ||= nil
|
|
$digests ||= nil
|
|
$no7z ||= nil
|
|
$tooldir = File.expand_path("..", __FILE__)
|
|
$unicode_version = nil if ($unicode_version ||= nil) == ""
|
|
$colorize = Colorize.new
|
|
|
|
def usage
|
|
<<USAGE
|
|
usage: #{File.basename $0} [option...] new-directory-to-save [version ...]
|
|
options:
|
|
-srcdir=PATH source directory path
|
|
-archname=NAME make the basename of snapshots NAME
|
|
-keep_temp keep temporary working directory
|
|
-patch_file=PATCH apply PATCH file after export
|
|
-packages=PKG[,...] make PKG packages (#{PACKAGES.keys.join(", ")})
|
|
-digests=ALG[,...] show ALG digests (#{DIGESTS.join(", ")})
|
|
-unicode_version=VER Unicode version to generate encodings
|
|
-svn[=URL] make snapshot from SVN repository
|
|
(#{SVNURL})
|
|
-help, --help show this message
|
|
version:
|
|
master, trunk, stable, branches/*, tags/*, X.Y, X.Y.Z, X.Y.Z-pL
|
|
each versions may be followed by optional @revision.
|
|
USAGE
|
|
end
|
|
|
|
DIGESTS = %w[SHA1 SHA256 SHA512]
|
|
PACKAGES = {
|
|
"tar" => %w".tar",
|
|
"bzip" => %w".tar.bz2 bzip2 -c",
|
|
"gzip" => %w".tar.gz gzip -c",
|
|
"xz" => %w".tar.xz xz -c",
|
|
"zip" => %w".zip zip -Xqr",
|
|
}
|
|
DEFAULT_PACKAGES = PACKAGES.keys - ["tar"]
|
|
if !$no7z and system("7z", out: IO::NULL)
|
|
PACKAGES["gzip"] = %w".tar.gz 7z a dummy -tgzip -mx -so"
|
|
PACKAGES["zip"] = %w".zip 7z a -tzip -l -mx -mtc=off" << {out: IO::NULL}
|
|
elsif gzip = ENV.delete("GZIP")
|
|
PACKAGES["gzip"].concat(gzip.shellsplit)
|
|
end
|
|
|
|
if mflags = ENV["GNUMAKEFLAGS"] and /\A-(\S*)j\d*/ =~ mflags
|
|
mflags = mflags.gsub(/(\A|\s)(-\S*)j\d*/, '\1\2')
|
|
mflags.strip!
|
|
ENV["GNUMAKEFLAGS"] = (mflags unless mflags.empty?)
|
|
end
|
|
ENV["LC_ALL"] = ENV["LANG"] = "C"
|
|
SVNURL = URI.parse("https://svn.ruby-lang.org/repos/ruby/")
|
|
# https git clone is disabled at git.ruby-lang.org/ruby.git.
|
|
GITURL = URI.parse("https://github.com/ruby/ruby.git")
|
|
RUBY_VERSION_PATTERN = /^\#define\s+RUBY_VERSION\s+"([\d.]+)"/
|
|
|
|
ENV["VPATH"] ||= "include/ruby"
|
|
YACC = ENV["YACC"] ||= "bison"
|
|
ENV["BASERUBY"] ||= "ruby"
|
|
ENV["RUBY"] ||= "ruby"
|
|
ENV["MV"] ||= "mv"
|
|
ENV["RM"] ||= "rm -f"
|
|
ENV["MINIRUBY"] ||= "ruby"
|
|
ENV["PROGRAM"] ||= "ruby"
|
|
ENV["AUTOCONF"] ||= "autoconf"
|
|
ENV["BUILTIN_TRANSOBJS"] ||= "newline.o"
|
|
ENV["TZ"] = "UTC"
|
|
|
|
class String
|
|
# for older ruby
|
|
alias bytesize size unless method_defined?(:bytesize)
|
|
end
|
|
|
|
class Dir
|
|
def self.mktmpdir(path)
|
|
path = File.join(tmpdir, path+"-#{$$}-#{rand(100000)}")
|
|
begin
|
|
mkdir(path)
|
|
rescue Errno::EEXIST
|
|
path.succ!
|
|
retry
|
|
end
|
|
path
|
|
end unless respond_to?(:mktmpdir)
|
|
end
|
|
|
|
$packages &&= $packages.split(/[, ]+/).tap {|pkg|
|
|
if all = pkg.index("all")
|
|
pkg[all, 1] = DEFAULT_PACKAGES - pkg
|
|
end
|
|
pkg -= PACKAGES.keys
|
|
pkg.empty? or abort "#{File.basename $0}: unknown packages - #{pkg.join(", ")}"
|
|
}
|
|
$packages ||= DEFAULT_PACKAGES
|
|
|
|
$digests &&= $digests.split(/[, ]+/).tap {|dig|
|
|
dig -= DIGESTS
|
|
dig.empty? or abort "#{File.basename $0}: unknown digests - #{dig.join(", ")}"
|
|
}
|
|
$digests ||= DIGESTS
|
|
|
|
$patch_file &&= File.expand_path($patch_file)
|
|
path = ENV["PATH"].split(File::PATH_SEPARATOR)
|
|
%w[YACC BASERUBY RUBY MV MINIRUBY].each do |var|
|
|
cmd, = ENV[var].shellsplit
|
|
unless path.any? {|dir|
|
|
file = File.expand_path(cmd, dir)
|
|
File.file?(file) and File.executable?(file)
|
|
}
|
|
abort "#{File.basename $0}: #{var} command not found - #{cmd}"
|
|
end
|
|
end
|
|
|
|
%w[BASERUBY RUBY MINIRUBY].each do |var|
|
|
%x[#{ENV[var]} --disable-gem -e1 2>&1]
|
|
if $?.success?
|
|
ENV[var] += ' --disable-gem'
|
|
end
|
|
end
|
|
|
|
if defined?($help) or defined?($_help)
|
|
puts usage
|
|
exit
|
|
end
|
|
unless destdir = ARGV.shift
|
|
abort usage
|
|
end
|
|
revisions = ARGV.empty? ? [nil] : ARGV
|
|
|
|
if defined?($exported)
|
|
abort "#{File.basename $0}: -exported option is deprecated; use -srcdir instead"
|
|
end
|
|
|
|
FileUtils.mkpath(destdir)
|
|
destdir = File.expand_path(destdir)
|
|
tmp = Dir.mktmpdir("ruby-snapshot")
|
|
FileUtils.mkpath(tmp)
|
|
at_exit {
|
|
Dir.chdir "/"
|
|
FileUtils.rm_rf(tmp)
|
|
} unless $keep_temp
|
|
|
|
def tar_create(tarball, dir)
|
|
header = Gem::Package::TarHeader
|
|
dir_type = "5"
|
|
uname = gname = "ruby"
|
|
File.open(tarball, "wb") do |f|
|
|
w = Gem::Package::TarWriter.new(f)
|
|
list = Dir.glob("#{dir}/**/*", File::FNM_DOTMATCH)
|
|
list.reject! {|name| name.end_with?("/.")}
|
|
list.sort_by! {|name| name.split("/")}
|
|
list.each do |path|
|
|
next if File.basename(path) == "."
|
|
s = File.stat(path)
|
|
mode = 0644
|
|
case
|
|
when s.file?
|
|
type = nil
|
|
size = s.size
|
|
mode |= 0111 if s.executable?
|
|
when s.directory?
|
|
path += "/"
|
|
type = dir_type
|
|
size = 0
|
|
mode |= 0111
|
|
else
|
|
next
|
|
end
|
|
name, prefix = w.split_name(path)
|
|
h = header.new(name: name, prefix: prefix, typeflag: type,
|
|
mode: mode, size: size, mtime: s.mtime,
|
|
uname: uname, gname: gname)
|
|
f.write(h)
|
|
if size > 0
|
|
IO.copy_stream(path, f)
|
|
f.write("\0" * (-size % 512))
|
|
end
|
|
end
|
|
end
|
|
true
|
|
rescue => e
|
|
warn e.message
|
|
false
|
|
end
|
|
|
|
def touch_all(time, pattern, opt, &cond)
|
|
Dir.glob(pattern, opt) do |n|
|
|
stat = File.stat(n)
|
|
if stat.file? or stat.directory?
|
|
next if cond and !yield(n, stat)
|
|
File.utime(time, time, n)
|
|
end
|
|
end
|
|
rescue
|
|
false
|
|
else
|
|
true
|
|
end
|
|
|
|
class MAKE < Struct.new(:prog, :args)
|
|
def initialize(vars)
|
|
vars = vars.map {|arg| arg.join("=")}
|
|
super(ENV["MAKE"] || ENV["make"] || "make", vars)
|
|
end
|
|
|
|
def run(target)
|
|
err = IO.pipe do |r, w|
|
|
begin
|
|
pid = Process.spawn(self.prog, *self.args, target, {:err => w, r => :close})
|
|
w.close
|
|
r.read
|
|
ensure
|
|
Process.wait(pid)
|
|
end
|
|
end
|
|
if $?.success?
|
|
true
|
|
else
|
|
STDERR.puts err
|
|
$colorize.fail("#{target} failed")
|
|
false
|
|
end
|
|
end
|
|
end
|
|
|
|
def measure
|
|
clock = Process::CLOCK_MONOTONIC
|
|
t0 = Process.clock_gettime(clock)
|
|
STDOUT.flush
|
|
result = yield
|
|
printf(" %6.3f", Process.clock_gettime(clock) - t0)
|
|
STDOUT.flush
|
|
result
|
|
end
|
|
|
|
def package(vcs, rev, destdir, tmp = nil)
|
|
pwd = Dir.pwd
|
|
patchlevel = false
|
|
prerelease = false
|
|
if rev and revision = rev[/@(\h+)\z/, 1]
|
|
rev = $`
|
|
end
|
|
case rev
|
|
when nil
|
|
url = nil
|
|
when /\A(?:master|trunk)\z/
|
|
url = vcs.trunk
|
|
when /\Abranches\//
|
|
url = vcs.branch($')
|
|
when /\Atags\//
|
|
url = vcs.tag($')
|
|
when /\Astable\z/
|
|
vcs.branch_list("ruby_[0-9]*") {|n| url = n[/\Aruby_\d+_\d+\z/]}
|
|
url &&= vcs.branch(url)
|
|
when /\A(.*)\.(.*)\.(.*)-(preview|rc)(\d+)/
|
|
prerelease = true
|
|
tag = "#{$4}#{$5}"
|
|
url = vcs.tag("v#{$1}_#{$2}_#{$3}_#{$4}#{$5}")
|
|
when /\A(.*)\.(.*)\.(.*)-p(\d+)/
|
|
patchlevel = true
|
|
tag = "p#{$4}"
|
|
url = vcs.tag("v#{$1}_#{$2}_#{$3}_#{$4}")
|
|
when /\A(\d+)\.(\d+)(?:\.(\d+))?\z/
|
|
if $3 && ($1 > "2" || $1 == "2" && $2 >= "1")
|
|
patchlevel = true
|
|
tag = ""
|
|
url = vcs.tag("v#{$1}_#{$2}_#{$3}")
|
|
else
|
|
url = vcs.branch("ruby_#{rev.tr('.', '_')}")
|
|
end
|
|
else
|
|
warn "#{$0}: unknown version - #{rev}"
|
|
return
|
|
end
|
|
if info = vcs.get_revisions(url)
|
|
modified = info[2]
|
|
else
|
|
_, _, modified = VCS::Null.new(nil).get_revisions(url)
|
|
end
|
|
if !revision and info
|
|
revision = info
|
|
url ||= vcs.branch(revision[3])
|
|
revision = revision[1]
|
|
end
|
|
version = nil
|
|
unless revision
|
|
url = vcs.trunk
|
|
vcs.grep(RUBY_VERSION_PATTERN, url, "version.h") {version = $1}
|
|
unless rev == version
|
|
warn "#{$0}: #{rev} not found"
|
|
return
|
|
end
|
|
revision = vcs.get_revisions(url)[1]
|
|
end
|
|
|
|
v = "ruby"
|
|
puts "Exporting #{rev}@#{revision}"
|
|
exported = tmp ? File.join(tmp, v) : v
|
|
unless vcs.export(revision, url, exported, true) {|line| print line}
|
|
warn("Export failed")
|
|
return
|
|
end
|
|
if $srcdir
|
|
Dir.glob($srcdir + "/{tool/config.{guess,sub},gems/*.gem,.downloaded-cache/*,enc/unicode/data/**/*.txt}") do |file|
|
|
puts "copying #{file}" if $VERBOSE
|
|
dest = exported + file[$srcdir.size..-1]
|
|
FileUtils.mkpath(File.dirname(dest))
|
|
begin
|
|
FileUtils.cp_r(file, dest)
|
|
FileUtils.chmod_R("a+rwX,go-w", dest)
|
|
rescue SystemCallError
|
|
end
|
|
end
|
|
end
|
|
|
|
Dir.glob("#{exported}/.*.yml") do |file|
|
|
FileUtils.rm(file, verbose: $VERBOSE)
|
|
end
|
|
|
|
status = IO.read(File.dirname(__FILE__) + "/prereq.status")
|
|
Dir.chdir(tmp) if tmp
|
|
|
|
if !File.directory?(v)
|
|
v = Dir.glob("ruby-*").select(&File.method(:directory?))
|
|
v.size == 1 or abort "#{File.basename $0}: not exported"
|
|
v = v[0]
|
|
end
|
|
|
|
File.open("#{v}/revision.h", "wb") {|f|
|
|
f.puts vcs.revision_header(revision, modified)
|
|
}
|
|
version ||= (versionhdr = IO.read("#{v}/version.h"))[RUBY_VERSION_PATTERN, 1]
|
|
version ||=
|
|
begin
|
|
include_ruby_versionhdr = IO.read("#{v}/include/ruby/version.h")
|
|
api_major_version = include_ruby_versionhdr[/^\#define\s+RUBY_API_VERSION_MAJOR\s+([\d.]+)/, 1]
|
|
api_minor_version = include_ruby_versionhdr[/^\#define\s+RUBY_API_VERSION_MINOR\s+([\d.]+)/, 1]
|
|
version_teeny = versionhdr[/^\#define\s+RUBY_VERSION_TEENY\s+(\d+)/, 1]
|
|
[api_major_version, api_minor_version, version_teeny].join('.')
|
|
end
|
|
version or return
|
|
if patchlevel
|
|
unless tag.empty?
|
|
versionhdr ||= IO.read("#{v}/version.h")
|
|
patchlevel = versionhdr[/^\#define\s+RUBY_PATCHLEVEL\s+(\d+)/, 1]
|
|
tag = (patchlevel ? "p#{patchlevel}" : vcs.revision_name(revision))
|
|
end
|
|
elsif prerelease
|
|
versionhdr ||= IO.read("#{v}/version.h")
|
|
versionhdr.sub!(/^\#define\s+RUBY_PATCHLEVEL_STR\s+"\K.+?(?=")/, tag)
|
|
IO.write("#{v}/version.h", versionhdr)
|
|
else
|
|
tag ||= vcs.revision_name(revision)
|
|
end
|
|
|
|
if $archname
|
|
n = $archname
|
|
elsif tag.empty?
|
|
n = "ruby-#{version}"
|
|
else
|
|
n = "ruby-#{version}-#{tag}"
|
|
end
|
|
File.directory?(n) or File.rename v, n
|
|
v = n
|
|
|
|
if $patch_file && !system(*%W"patch -d #{v} -p0 -i #{$patch_file}")
|
|
puts $colorize.fail("patching failed")
|
|
return
|
|
end
|
|
def (clean = []).add(n) push(n); n end
|
|
def clean.create(file, content = "") File.binwrite(add(file), content) end
|
|
Dir.chdir(v) do
|
|
unless File.exist?("ChangeLog")
|
|
vcs.export_changelog(url, nil, revision, "ChangeLog")
|
|
end
|
|
|
|
unless touch_all(modified, "**/*", File::FNM_DOTMATCH)
|
|
modified = nil
|
|
colors = %w[red yellow green cyan blue magenta]
|
|
"take a breath, and go ahead".scan(/./) do |c|
|
|
if c == ' '
|
|
print c
|
|
else
|
|
colors.push(color = colors.shift)
|
|
print $colorize.decorate(c, color)
|
|
end
|
|
sleep(c == "," ? 0.7 : 0.05)
|
|
end
|
|
puts
|
|
end
|
|
|
|
File.open(clean.add("cross.rb"), "w") do |f|
|
|
f.puts "Object.__send__(:remove_const, :CROSS_COMPILING) if defined?(CROSS_COMPILING)"
|
|
f.puts "CROSS_COMPILING=true"
|
|
f.puts "Object.__send__(:remove_const, :RUBY_PLATFORM)"
|
|
f.puts "RUBY_PLATFORM='none'"
|
|
f.puts "Object.__send__(:remove_const, :RUBY_VERSION)"
|
|
f.puts "RUBY_VERSION='#{version}'"
|
|
end
|
|
puts "cross.rb:", File.read("cross.rb").gsub(/^/, "> "), "" if $VERBOSE
|
|
unless File.exist?("configure")
|
|
print "creating configure..."
|
|
unless system([ENV["AUTOCONF"]]*2)
|
|
puts $colorize.fail(" failed")
|
|
return
|
|
end
|
|
puts $colorize.pass(" done")
|
|
end
|
|
clean.add("autom4te.cache")
|
|
clean.add("enc/unicode/data")
|
|
print "creating prerequisites..."
|
|
if File.file?("common.mk") && /^prereq/ =~ commonmk = IO.read("common.mk")
|
|
puts
|
|
extout = clean.add('tmp')
|
|
begin
|
|
status = IO.read("tool/prereq.status")
|
|
rescue Errno::ENOENT
|
|
# use fallback file
|
|
end
|
|
clean.create("config.status", status)
|
|
clean.create("noarch-fake.rb", "require_relative 'cross'\n")
|
|
FileUtils.mkpath(hdrdir = "#{extout}/include/ruby")
|
|
File.binwrite("#{hdrdir}/config.h", "")
|
|
FileUtils.mkpath(defaults = "#{extout}/rubygems/defaults")
|
|
File.binwrite("#{defaults}/operating_system.rb", "")
|
|
File.binwrite("#{defaults}/ruby.rb", "")
|
|
miniruby = ENV['MINIRUBY'] + " -I. -I#{extout} -rcross"
|
|
baseruby = ENV["BASERUBY"]
|
|
mk = (IO.read("template/Makefile.in") rescue IO.read("Makefile.in")).
|
|
gsub(/^@.*\n/, '')
|
|
vars = {
|
|
"EXTOUT"=>extout,
|
|
"PATH_SEPARATOR"=>File::PATH_SEPARATOR,
|
|
"MINIRUBY"=>miniruby,
|
|
"RUBY"=>ENV["RUBY"],
|
|
"BASERUBY"=>baseruby,
|
|
"PWD"=>Dir.pwd,
|
|
"ruby_version"=>version,
|
|
"MAJOR"=>api_major_version,
|
|
"MINOR"=>api_minor_version,
|
|
"TEENY"=>version_teeny,
|
|
}
|
|
status.scan(/^s([%,])@([A-Za-z_][A-Za-z_0-9]*)@\1(.*?)\1g$/) do
|
|
vars[$2] ||= $3
|
|
end
|
|
vars.delete("UNICODE_FILES") # for stable branches
|
|
vars["UNICODE_VERSION"] = $unicode_version if $unicode_version
|
|
args = vars.dup
|
|
mk.gsub!(/@([A-Za-z_]\w*)@/) {args.delete($1); vars[$1] || ENV[$1]}
|
|
mk << commonmk.gsub(/\{\$([^(){}]*)[^{}]*\}/, "").sub(/^revision\.tmp::$/, '\& Makefile')
|
|
mk << <<-'APPEND'
|
|
|
|
update-download:: touch-unicode-files
|
|
prepare-package: prereq after-update
|
|
clean-cache: $(CLEAN_CACHE)
|
|
after-update:: extract-gems
|
|
extract-gems: update-gems
|
|
update-gems:
|
|
$(UNICODE_SRC_DATA_DIR)/.unicode-tables.time:
|
|
touch-unicode-files:
|
|
APPEND
|
|
clean.create("Makefile", mk)
|
|
clean.create("revision.tmp")
|
|
clean.create(".revision.time")
|
|
ENV["CACHE_SAVE"] = "no"
|
|
make = MAKE.new(args)
|
|
return unless make.run("update-download")
|
|
clean.push("rbconfig.rb", ".rbconfig.time", "enc.mk", "ext/ripper/y.output", ".revision.time")
|
|
Dir.glob("**/*") do |dest|
|
|
next unless File.symlink?(dest)
|
|
orig = File.expand_path(File.readlink(dest), File.dirname(dest))
|
|
File.unlink(dest)
|
|
FileUtils.cp_r(orig, dest)
|
|
end
|
|
File.utime(modified, modified, *Dir.glob(["tool/config.{guess,sub}", "gems/*.gem", "tool"]))
|
|
return unless make.run("prepare-package")
|
|
return unless make.run("clean-cache")
|
|
if modified
|
|
new_time = modified + 2
|
|
touch_all(new_time, "**/*", File::FNM_DOTMATCH) do |name, stat|
|
|
stat.mtime > modified unless clean.include?(name)
|
|
end
|
|
modified = new_time
|
|
end
|
|
print "prerequisites"
|
|
else
|
|
system(*%W"#{YACC} -o parse.c parse.y")
|
|
end
|
|
vcs.after_export(".") if exported
|
|
clean.concat(Dir.glob("ext/**/autom4te.cache"))
|
|
FileUtils.rm_rf(clean) unless $keep_temp
|
|
FileUtils.rm_rf(".downloaded-cache")
|
|
if File.exist?("gems/bundled_gems")
|
|
gems = Dir.glob("gems/*.gem")
|
|
gems -= File.readlines("gems/bundled_gems").map {|line|
|
|
next if /^\s*(?:#|$)/ =~ line
|
|
name, version, _ = line.split(' ')
|
|
"gems/#{name}-#{version}.gem"
|
|
}
|
|
FileUtils.rm_f(gems)
|
|
else
|
|
FileUtils.rm_rf("gems")
|
|
end
|
|
if modified
|
|
touch_all(modified, "**/*/", 0) do |name, stat|
|
|
stat.mtime > modified
|
|
end
|
|
File.utime(modified, modified, ".")
|
|
end
|
|
unless $?.success?
|
|
puts $colorize.fail(" failed")
|
|
return
|
|
end
|
|
puts $colorize.pass(" done")
|
|
end
|
|
|
|
if v == "."
|
|
v = File.basename(Dir.pwd)
|
|
Dir.chdir ".."
|
|
else
|
|
Dir.chdir(File.dirname(v))
|
|
v = File.basename(v)
|
|
end
|
|
|
|
tarball = nil
|
|
return $packages.collect do |mesg|
|
|
(ext, *cmd) = PACKAGES[mesg]
|
|
File.directory?(destdir) or FileUtils.mkpath(destdir)
|
|
file = File.join(destdir, "#{$archname||v}#{ext}")
|
|
case ext
|
|
when /\.tar/
|
|
if tarball
|
|
next if tarball.empty?
|
|
else
|
|
tarball = ext == ".tar" ? file : "#{$archname||v}.tar"
|
|
print "creating tarball... #{tarball}"
|
|
if measure {tar_create(tarball, v)}
|
|
puts $colorize.pass(" done")
|
|
File.utime(modified, modified, tarball) if modified
|
|
next if tarball == file
|
|
else
|
|
puts $colorize.fail(" failed")
|
|
tarball = ""
|
|
next
|
|
end
|
|
end
|
|
print "creating #{mesg} tarball... #{file}"
|
|
done = measure {system(*cmd, tarball, out: file)}
|
|
else
|
|
print "creating #{mesg} archive... #{file}"
|
|
if Hash === cmd.last
|
|
*cmd, opt = *cmd
|
|
cmd << file << v << opt
|
|
else
|
|
(cmd = cmd.dup) << file << v
|
|
end
|
|
done = measure {system(*cmd)}
|
|
end
|
|
if done
|
|
puts $colorize.pass(" done")
|
|
file
|
|
else
|
|
puts $colorize.fail(" failed")
|
|
nil
|
|
end
|
|
end.compact
|
|
ensure
|
|
FileUtils.rm_rf(tmp ? File.join(tmp, v) : v) if v and !$keep_temp
|
|
Dir.chdir(pwd)
|
|
end
|
|
|
|
if [$srcdir, ($svn||=nil), ($git||=nil)].compact.size > 1
|
|
abort "#{File.basename $0}: -srcdir, -svn, and -git are exclusive"
|
|
end
|
|
if $srcdir
|
|
vcs = VCS.detect($srcdir)
|
|
elsif $svn
|
|
vcs = VCS::SVN.new($svn == true ? SVNURL : URI.parse($svn))
|
|
elsif $git
|
|
abort "#{File.basename $0}: use -srcdir with cloned local repository"
|
|
else
|
|
begin
|
|
vcs = VCS.detect(File.expand_path("../..", __FILE__))
|
|
rescue VCS::NotFoundError
|
|
vcs = VCS::SVN.new(SVNURL)
|
|
end
|
|
end
|
|
|
|
release_date = Time.now.getutc
|
|
info = {}
|
|
|
|
success = true
|
|
revisions.collect {|rev| package(vcs, rev, destdir, tmp)}.flatten.each do |name|
|
|
if !name
|
|
success = false
|
|
next
|
|
end
|
|
str = File.binread(name)
|
|
pathname = Pathname(name)
|
|
basename = pathname.basename.to_s
|
|
extname = pathname.extname.sub(/\A\./, '')
|
|
version = basename[/\Aruby-(.*)\.(?:tar|zip)/, 1]
|
|
key = basename[/\A(.*)\.(?:tar|zip)/, 1]
|
|
info[key] ||= Hash.new{|h,k|h[k]={}}
|
|
info[key]['version'] = version if version
|
|
info[key]['date'] = release_date.strftime('%Y-%m-%d')
|
|
if version
|
|
info[key]['post'] = "/en/news/#{release_date.strftime('%Y/%m/%d')}/ruby-#{version.tr('.', '-')}-released/"
|
|
info[key]['url'][extname] = "https://cache.ruby-lang.org/pub/ruby/#{version[/\A\d+\.\d+/]}/#{basename}"
|
|
else
|
|
info[key]['filename'][extname] = basename
|
|
end
|
|
info[key]['size'][extname] = str.bytesize
|
|
puts "* #{$colorize.pass(name)}"
|
|
puts " SIZE: #{str.bytesize} bytes"
|
|
$digests.each do |alg|
|
|
digest = Digest(alg).hexdigest(str)
|
|
info[key][alg.downcase][extname] = digest
|
|
printf " %-8s%s\n", "#{alg}:", digest
|
|
end
|
|
end
|
|
|
|
yaml = info.values.to_yaml
|
|
json = info.values.to_json
|
|
puts "#{$colorize.pass('YAML:')}"
|
|
puts yaml
|
|
puts "#{$colorize.pass('JSON:')}"
|
|
puts json
|
|
infodir = Pathname(destdir) + 'info'
|
|
infodir.mkpath
|
|
(infodir+'info.yml').write(yaml)
|
|
(infodir+'info.json').write(json)
|
|
|
|
exit false if !success
|
|
|
|
# vim:fileencoding=US-ASCII sw=2 ts=4 noexpandtab ff=unix
|