lunar 0.4.1 → 0.5.0

data/test/test_sets.rb

@@ -1,48 +0,0 @@
-require "helper"
-
-class LunarSetsTest < Test::Unit::TestCase
-  setup do
-    Lunar.redis(Redis.new(:host => "127.0.0.1", :port => "6380"))
-    Lunar.redis.flushdb
-    
-    @keys = [
-      "Lunar:Item:name:#{ Lunar.encode('iphone') }",
-      "Lunar:Item:desc:#{ Lunar.encode('iphone') }",
-      "Lunar:Item:tags:#{ Lunar.encode('asian') }",  
-      "Lunar:Item:tags:#{ Lunar.encode('hacker') }",    
-      "Lunar:Item:tags:#{ Lunar.encode('ninja') }",  
-      "Lunar:Item:body:#{ Lunar.encode('ninja') }",   
-      "Lunar:Item:body:#{ Lunar.encode('assassin') }"    
-    ]
-  
-    @keys.each { |key| Lunar.redis.zadd key, 1, 1001 }
-  end
-
-  context "given prefix Item, keywords iphone" do
-    should "return both keys" do
-      sets = Lunar::Sets.new("Item", "iphone")
-
-      assert sets.include?(@keys[0])
-      assert sets.include?(@keys[1])
-    end
-  end
-
-  context "given prefix Item, keywords iphone, field name" do
-    should "return only the name key" do
-      sets = Lunar::Sets.new("Item", "iphone", "name")
-
-      assert sets.include?(@keys[0])
-      assert ! sets.include?(@keys[1])
-    end
-  end
-
-  context "given asian ninja assassin" do
-    should "return all relevant keys" do
-      sets = Lunar::Sets.new("Item", "asian ninja assassin", "tags")
-
-      assert sets.include?(@keys[2])
-      assert sets.include?(@keys[4])
-    end
-  end
-
-end

data/vendor/nest/nest.rb

@@ -1,7 +0,0 @@
-class Nest < String
-  VERSION = "0.0.2"
-
-  def [](key)
-    self.class.new("#{self}:#{key}")
-  end
-end

data/vendor/redis/.gitignore

@@ -1,9 +0,0 @@
-nohup.out
-redis/*
-rdsrv
-pkg/*
-coverage/*
-.idea
-*.gemspec
-*.rdb
-*.swp

data/vendor/redis/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2009 Ezra Zygmuntowicz
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/redis/README.markdown

@@ -1,120 +0,0 @@
-# redis-rb
-
-A Ruby client library for the [Redis](http://code.google.com/p/redis) key-value store.
-
-## A note about versions
-
-Versions *1.0.x* target all versions of Redis. You have to use this one if you are using Redis < 1.2.
-
-Version *2.0* is a big refactoring of the previous version and makes little effort to be
-backwards-compatible when it shouldn't. It does not support Redis' original protocol, favoring the
-new, binary-safe one. You should be using this version if you're running Redis 1.2+.
-
-## Information about Redis
-
-Redis is a key-value store with some interesting features:
-
-1. It's fast.
-2. Keys are strings but values are typed. Currently Redis supports strings, lists, sets, sorted sets and hashes. [Atomic operations](http://code.google.com/p/redis/wiki/CommandReference) can be done on all of these types.
-
-See [the Redis homepage](http://code.google.com/p/redis/wiki/README) for more information.
-
-## Getting started
-
-You can connect to Redis by instantiating the `Redis` class:
-
-    require "redis"
-
-    redis = Redis.new
-
-This assumes Redis was started with default values listening on `localhost`, port 6379. If you need to connect to a remote server or a different port, try:
-
-    redis = Redis.new(:host => "10.0.1.1", :port => 6380)
-
-Once connected, you can start running commands against Redis:
-
-    >> redis.set "foo", "bar"
-    => "OK"
-
-    >> redis.get "foo"
-    => "bar"
-
-    >> redis.sadd "users", "albert"
-    => true
-
-    >> redis.sadd "users", "bernard"
-    => true
-
-    >> redis.sadd "users", "charles"
-    => true
-
-How many users?
-
-    >> redis.scard "users"
-    => 3
-
-Is `albert` a user?
-
-    >> redis.sismember "users", "albert"
-    => true
-
-Is `isabel` a user?
-
-    >> redis.sismember "users", "isabel"
-    => false
-
-Handle groups:
-
-    >> redis.sadd "admins", "albert"
-    => true
-
-    >> redis.sadd "admins", "isabel"
-    => true
-
-Users who are also admins:
-
-    >> redis.sinter "users", "admins"
-    => ["albert"]
-
-Users who are not admins:
-
-    >> redis.sdiff "users", "admins"
-    => ["bernard", "charles"]
-
-Admins who are not users:
-
-    >> redis.sdiff "admins", "users"
-    => ["isabel"]
-
-All users and admins:
-
-    >> redis.sunion "admins", "users"
-    => ["albert", "bernard", "charles", "isabel"]
-
-
-## Storing objects
-
-Redis only stores strings as values. If you want to store an object inside a key, you can use a serialization/deseralization mechanism like JSON:
-
-    >> redis.set "foo", [1, 2, 3].to_json
-    => OK
-
-    >> JSON.parse(redis.get("foo"))
-    => [1, 2, 3]
-
-## Executing multiple commands atomically
-
-You can use `MULTI/EXEC` to run arbitrary commands in an atomic fashion:
-
-    redis.multi do
-      redis.set "foo", "bar"
-      redis.incr "baz"
-    end
-
-## More info
-
-Check the [Redis Command Reference](http://code.google.com/p/redis/wiki/CommandReference) or check the tests to find out how to use this client.
-
-## Contributing
-
-[Fork the project](http://github.com/ezmobius/redis-rb) and send pull requests. You can also ask for help at `#redis` on Freenode.

data/vendor/redis/Rakefile

@@ -1,75 +0,0 @@
-require 'rubygems'
-require 'rake/gempackagetask'
-require 'rake/testtask'
-require 'tasks/redis.tasks'
-
-$:.unshift File.join(File.dirname(__FILE__), 'lib')
-require 'redis'
-
-GEM = 'redis'
-GEM_NAME = 'redis'
-GEM_VERSION = Redis::VERSION
-AUTHORS = ['Ezra Zygmuntowicz', 'Taylor Weibley', 'Matthew Clark', 'Brian McKinney', 'Salvatore Sanfilippo', 'Luca Guidi']
-EMAIL = "ez@engineyard.com"
-HOMEPAGE = "http://github.com/ezmobius/redis-rb"
-SUMMARY = "Ruby client library for Redis, the key value storage server"
-
-spec = Gem::Specification.new do |s|
-  s.name = GEM
-  s.version = GEM_VERSION
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["LICENSE"]
-  s.summary = SUMMARY
-  s.description = s.summary
-  s.authors = AUTHORS
-  s.email = EMAIL
-  s.homepage = HOMEPAGE
-  s.require_path = 'lib'
-  s.autorequire = GEM
-  s.files = %w(LICENSE README.markdown Rakefile) + Dir.glob("{lib,tasks,spec}/**/*")
-end
-
-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
-  unless File.exists?(REDIS_PID)
-    system "redis-server #{REDIS_CNF}"
-  end
-end
-
-desc "Stop the Redis server"
-task :stop do
-  if File.exists?(REDIS_PID)
-    system "kill #{File.read(REDIS_PID)}"
-    system "rm #{REDIS_PID}"
-  end
-end
-
-Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-end
-
-desc "install the gem locally"
-task :install => [:package] do
-  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
-end
-
-desc "create a gemspec file"
-task :gemspec do
-  File.open("#{GEM}.gemspec", "w") do |file|
-    file.puts spec.to_ruby
-  end
-end

data/vendor/redis/benchmarking/logging.rb

@@ -1,62 +0,0 @@
-# Run with
-#
-#   $ ruby -Ilib benchmarking/logging.rb
-#
-
-begin
-  require "bench"
-rescue LoadError
-  $stderr.puts "`gem install bench` and try again."
-  exit 1
-end
-
-require "redis"
-require "logger"
-
-def log(level, namespace = nil)
-  logger = (namespace || Kernel).const_get(:Logger).new("/dev/null")
-  logger.level = (namespace || Logger).const_get(level)
-  logger
-end
-
-def stress(redis)
-  redis.flushdb
-
-  n = (ARGV.shift || 2000).to_i
-
-  n.times do |i|
-    key = "foo:#{i}"
-    redis.set key, i
-    redis.get key
-  end
-end
-
-default = Redis.new
-
-logging_redises = [
-  Redis.new(:logger => log(:DEBUG)),
-  Redis.new(:logger => log(:INFO)),
-]
-
-begin
-  require "log4r"
-
-  logging_redises += [
-    Redis.new(:logger => log(:DEBUG, Log4r)),
-    Redis.new(:logger => log(:INFO, Log4r)),
-  ]
-rescue LoadError
-  $stderr.puts "Log4r not installed. `gem install log4r` if you want to compare it against Ruby's Logger (spoiler: it's much faster)."
-end
-
-benchmark "Default options (no logger)" do
-  stress(default)
-end
-
-logging_redises.each do |redis|
-  benchmark "#{redis.client.logger.class} on #{Logger::SEV_LABEL[redis.client.logger.level]}" do
-    stress(redis)
-  end
-end
-
-run 10

data/vendor/redis/benchmarking/pipeline.rb

@@ -1,44 +0,0 @@
-require 'benchmark'
-$:.push File.join(File.dirname(__FILE__), 'lib')
-require 'redis'
-
-times = 20000
-
-@r = Redis.new#(:debug => true)
-@r['foo'] = "The first line we sent to the server is some text"
-
-Benchmark.bmbm do |x|
-  x.report("set") do
-    20000.times do |i|
-      @r["set#{i}"] = "The first line we sent to the server is some text"; @r["foo#{i}"]
-    end
-  end
-  
-  x.report("set (pipelined)") do
-    @r.pipelined do |pipeline|
-      20000.times do |i|
-        pipeline["set_pipelined#{i}"] = "The first line we sent to the server is some text"; @r["foo#{i}"]
-      end
-    end
-  end
-  
-  x.report("push+trim") do
-    20000.times do |i|
-      @r.push_head "push_trim#{i}", i
-      @r.list_trim "push_trim#{i}", 0, 30
-    end
-  end
-  
-  x.report("push+trim (pipelined)") do
-    @r.pipelined do |pipeline|
-      20000.times do |i|
-        pipeline.push_head "push_trim_pipelined#{i}", i
-        pipeline.list_trim "push_trim_pipelined#{i}", 0, 30
-      end
-    end
-  end
-end
-
-@r.keys('*').each do |k|
-  @r.delete k
-end

data/vendor/redis/benchmarking/speed.rb

@@ -1,21 +0,0 @@
-# Run with
-#
-#   $ ruby -Ilib benchmarking/speed.rb
-#
-
-require "benchmark"
-require "redis"
-
-r = Redis.new
-n = (ARGV.shift || 20000).to_i
-
-elapsed = Benchmark.realtime do
-  # n sets, n gets
-  n.times do |i|
-    key = "foo#{i}"
-    r[key] = key * 10
-    r[key]
-  end
-end
-
-puts '%.2f Kops' % (2 * n / 1000 / elapsed)

data/vendor/redis/benchmarking/suite.rb

@@ -1,24 +0,0 @@
-require 'fileutils'
-
-def run_in_background(command)
-  fork { system command }
-end
-
-def with_all_segments(&block)
-  0.upto(9) do |segment_number|
-    block_size = 100000
-    start_index = segment_number * block_size
-    end_index = start_index + block_size - 1
-    block.call(start_index, end_index)
-  end
-end
-
-#with_all_segments do |start_index, end_index|
-#  puts "Initializing keys from #{start_index} to #{end_index}"
-#  system "ruby worker.rb initialize #{start_index} #{end_index} 0"
-#end
-
-with_all_segments do |start_index, end_index|
-  run_in_background "ruby worker.rb write #{start_index} #{end_index} 10"
-  run_in_background "ruby worker.rb read #{start_index} #{end_index} 1"
-end