Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

393 lines (298 sloc) 8.62 kb
require 'rubygems'
require 'rubygems/package_task'
require 'rake/testtask'
$:.unshift File.join(File.dirname(__FILE__), 'lib')
require 'redis/version'
REDIS_DIR = File.expand_path(File.join("..", "test"), __FILE__)
REDIS_CNF = File.join(REDIS_DIR, "test.conf")
REDIS_PID = File.join(REDIS_DIR, "db", "redis.pid")
task :default => :run
desc "Run tests and manage server start/stop"
task :run => [:start, :test, :stop]
desc "Start the Redis server"
task :start do
redis_running = \
begin
File.exists?(REDIS_PID) && Process.kill(0, File.read(REDIS_PID).to_i)
rescue Errno::ESRCH
FileUtils.rm REDIS_PID
false
end
unless redis_running
unless system("which redis-server")
STDERR.puts "redis-server not in PATH"
exit 1
end
unless system("redis-server #{REDIS_CNF}")
STDERR.puts "could not start redis-server"
exit 1
end
end
end
desc "Stop the Redis server"
task :stop do
if File.exists?(REDIS_PID)
Process.kill "INT", File.read(REDIS_PID).to_i
FileUtils.rm REDIS_PID
end
end
Rake::TestTask.new do |t|
t.options = "-v"
t.libs << "test"
t.test_files = FileList["test/*_test.rb"]
end
task :doc => ["doc:generate", "doc:prepare"]
namespace :doc do
task :generate do
require "shellwords"
`rm -rf doc`
current_branch = `git branch`[/^\* (.*)$/, 1]
begin
tags = `git tag -l`.split("\n").sort.reverse
tags.each do |tag|
`git checkout -q #{tag} 2>/dev/null`
unless $?.success?
$stderr.puts "Need a clean working copy. Please git-stash away."
exit 1
end
puts tag
`mkdir -p doc/#{tag}`
files = `git ls-tree -r HEAD lib`.split("\n").map do |line|
line[/\t(.*)$/, 1]
end
opts = [
"--title", "A Ruby client for Redis",
"--output", "doc/#{tag}",
"--no-cache",
"--no-save",
"-q",
*files
]
`yardoc #{Shellwords.shelljoin opts}`
end
ensure
`git checkout -q #{current_branch}`
end
end
task :prepare do
versions = `git tag -l`.split("\n").grep(/^v/).sort
latest_version = versions.last
File.open("doc/.htaccess", "w") do |file|
file.puts "RedirectMatch 302 ^/?$ /#{latest_version}"
end
File.open("doc/robots.txt", "w") do |file|
file.puts "User-Agent: *"
(versions - [latest_version]).each do |version|
file.puts "Disallow: /#{version}"
end
end
google_analytics = <<-EOS
<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-11356145-2']);
_gaq.push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();
</script>
EOS
Dir["doc/**/*.html"].each do |path|
lines = IO.readlines(path)
File.open(path, "w") do |file|
lines.each do |line|
if line.include?("</head>")
file.write(google_analytics)
end
file.write(line)
end
end
end
end
task :deploy do
system "rsync --del -avz doc/ redis-rb.keyvalue.org:deploys/redis-rb.keyvalue.org/"
end
end
class Source
MATCHER = "(?:\\s{%d}#[^\\n]*\\n)*^\\s{%d}def ([a-z_?]+)(?:\(.*?\))?\\n.*?^\\s{%d}end\\n\\n"
def initialize(data, options = {})
@doc = parse(File.read(data), options)
end
def methods
@doc.select do |d|
d.is_a?(Method)
end.map do |d|
d.name
end
end
def move(a, b)
ao = @doc.find { |m| m.is_a?(Method) && m.name == a }
bo = @doc.find { |m| m.is_a?(Method) && m.name == b }
ai = @doc.index(ao)
bi = @doc.index(bo)
@doc.delete_at(ai)
@doc.insert(bi, ao)
nil
end
def to_s
@doc.join
end
protected
def parse(data, options = {})
re = Regexp.new(MATCHER % ([options[:indent]] * 3), Regexp::MULTILINE)
tail = data.dup
doc = []
while match = re.match(tail)
doc << match.pre_match
doc << Method.new(match)
tail = match.post_match
end
doc << tail if tail
doc
end
class Method
def initialize(match)
@match = match
end
def name
@match[1]
end
def to_s
@match[0]
end
end
end
namespace :commands do
def redis_commands
$redis_commands ||= doc.keys.map do |key|
key.split(" ").first.downcase
end.uniq
end
def doc
$doc ||= begin
require "open-uri"
require "json"
JSON.parse(open("https://github.com/antirez/redis-doc/raw/master/commands.json").read)
end
end
task :order do
require "json"
reference = if File.exist?(".order")
JSON.parse(File.read(".order"))
else
{}
end
buckets = {}
doc.each do |k, v|
buckets[v["group"]] ||= []
buckets[v["group"]] << k.split.first.downcase
buckets[v["group"]].uniq!
end
result = (reference.keys + (buckets.keys - reference.keys)).map do |g|
[g, reference[g] + (buckets[g] - reference[g])]
end
File.open(".order", "w") do |f|
f.write(JSON.pretty_generate(Hash[result]))
end
end
def reorder(file, options = {})
require "json"
require "set"
STDERR.puts "reordering #{file}..."
reference = if File.exist?(".order")
JSON.parse(File.read(".order"))
else
{}
end
dst = Source.new(file, options)
src_methods = reference.map { |k, v| v }.flatten
dst_methods = dst.methods
src_set = Set.new(src_methods)
dst_set = Set.new(dst_methods)
intersection = src_set & dst_set
intersection.delete("initialize")
loop do
src_methods = reference.map { |k, v| v }.flatten
dst_methods = dst.methods
src_methods = src_methods.select do |m|
intersection.include?(m)
end
dst_methods = dst_methods.select do |m|
intersection.include?(m)
end
if src_methods == dst_methods
break
end
rv = yield(src_methods, dst_methods, dst)
break if rv == false
end
File.open(file, "w") do |f|
f.write(dst.to_s)
end
end
task :reorder do
blk = lambda do |src_methods, dst_methods, dst|
src_methods.zip(dst_methods).each do |a, b|
if a != b
dst.move(a, b)
break
end
end
end
reorder "lib/redis.rb", :indent => 2, &blk
reorder "lib/redis/distributed.rb", :indent => 4, &blk
end
def missing(file, options = {})
src = Source.new(file, options)
defined_methods = src.methods.map(&:downcase)
required_methods = redis_commands.map(&:downcase)
STDOUT.puts "missing in #{file}:"
STDOUT.puts (required_methods - defined_methods).inspect
end
task :missing do
missing "lib/redis.rb", :indent => 2
missing "lib/redis/distributed.rb", :indent => 4
end
def document(file)
source = File.read(file)
doc.each do |name, command|
source.sub!(/(?:^ *# .*\n)*(^ *#\n(^ *# .+?\n)*)*^( *)def #{name.downcase}(\(|$)/) do
extra_comments, indent, extra_args = $1, $3, $4
comment = "#{indent}# #{command["summary"].strip}."
IO.popen("par p#{2 + indent.size} 80", "r+") do |io|
io.puts comment
io.close_write
comment = io.read
end
"#{comment}#{extra_comments}#{indent}def #{name.downcase}#{extra_args}"
end
end
File.open(file, "w") { |f| f.write(source) }
end
task :doc do
document "lib/redis.rb"
document "lib/redis/distributed.rb"
end
task :verify do
require "redis"
require "stringio"
require "./test/helper"
OPTIONS[:logger] = Logger.new("./tmp/log")
Rake::Task["test:ruby"].invoke
redis = Redis.new
report = ["Command", "\033[0mDefined?\033[0m", "\033[0mTested?\033[0m"]
yes, no = "\033[1;32mYes\033[0m", "\033[1;31mNo\033[0m"
log = File.read("./tmp/log")
redis_commands.sort.each do |name, _|
defined, tested = redis.respond_to?(name), log[">> #{name.upcase}"]
next if defined && tested
report << name
report << (defined ? yes : no)
report << (tested ? yes : no)
end
IO.popen("rs 0 3", "w") do |io|
io.puts report.join("\n")
end
end
end
Jump to Line
Something went wrong with that request. Please try again.