benschwarz-smoke 0.4.2 → 0.5.0

data/vendor/json-1.1.3/tests/test_json_unicode.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'json'
+
+class TC_JSONUnicode < Test::Unit::TestCase
+  include JSON
+
+  def setup
+    $KCODE = 'UTF8'
+  end
+
+  def test_unicode
+    assert_equal '""', ''.to_json
+    assert_equal '"\\b"', "\b".to_json
+    assert_equal '"\u0001"', 0x1.chr.to_json
+    assert_equal '"\u001f"', 0x1f.chr.to_json
+    assert_equal '" "', ' '.to_json
+    assert_equal "\"#{0x7f.chr}\"", 0x7f.chr.to_json
+    utf8 = [ "© ≠ €! \01" ]
+    json = '["\u00a9 \u2260 \u20ac! \u0001"]'
+    assert_equal json, utf8.to_json
+    assert_equal utf8, parse(json)
+    utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
+    json = "[\"\\u3042\\u3044\\u3046\\u3048\\u304a\"]"
+    assert_equal json, utf8.to_json
+    assert_equal utf8, parse(json)
+    utf8 = ['საქართველო']
+    json = "[\"\\u10e1\\u10d0\\u10e5\\u10d0\\u10e0\\u10d7\\u10d5\\u10d4\\u10da\\u10dd\"]"
+    assert_equal json, utf8.to_json
+    assert_equal utf8, parse(json)
+    assert_equal '["\\u00c3"]', JSON.generate(["Ã"])
+    assert_equal ["€"], JSON.parse('["\u20ac"]')
+    utf8 = ["\xf0\xa0\x80\x81"]
+    json = '["\ud840\udc01"]'
+    assert_equal json, JSON.generate(utf8)
+    assert_equal utf8, JSON.parse(json)
+  end
+
+  def test_chars
+    (0..0x7f).each do |i|
+      json = '["\u%04x"]' % i
+      if RUBY_VERSION >= "1.9."
+        i = i.chr
+      end
+      assert_equal i, JSON.parse(json).first[0]
+      if i == ?\b
+        generated = JSON.generate(["" << i])
+        assert '["\b"]' == generated || '["\10"]' == generated
+      elsif [?\n, ?\r, ?\t, ?\f].include?(i)
+        assert_equal '[' << ('' << i).dump << ']', JSON.generate(["" << i])
+      elsif i.chr < 0x20.chr
+        assert_equal json, JSON.generate(["" << i])
+      end
+    end
+    assert_raises(JSON::GeneratorError) do
+      JSON.generate(["" << 0x80])
+    end
+    assert_equal "\302\200", JSON.parse('["\u0080"]').first
+  end
+end

data/vendor/json-1.1.3/tools/fuzz.rb

@@ -0,0 +1,140 @@
+$KCODE='UTF8'
+require 'json'
+
+require 'iconv'
+ISO_8859_1_TO_UTF8 = Iconv.new('utf-8', 'iso-8859-15')
+class ::String
+  def to_utf8
+    ISO_8859_1_TO_UTF8.iconv self
+  end
+end
+
+class Fuzzer
+  def initialize(n, freqs = {})
+    sum = freqs.inject(0.0) { |s, x| s + x.last }
+    freqs.each_key { |x| freqs[x] /= sum }
+    s = 0.0
+    freqs.each_key do |x|
+      freqs[x] = s .. (s + t = freqs[x])
+      s += t
+    end
+    @freqs = freqs
+    @n = n
+    @alpha = (0..0xff).to_a
+  end
+
+  def random_string
+    s = ''
+    30.times { s << @alpha[rand(@alpha.size)] }
+    s.to_utf8
+  end
+
+  def pick
+    r = rand
+    found = @freqs.find { |k, f| f.include? rand }
+    found && found.first
+  end
+
+  def make_pick
+    k = pick
+    case
+    when k == Hash, k == Array
+      k.new
+    when k == true, k == false, k == nil
+      k
+    when k == String
+      random_string
+    when k == Fixnum
+      rand(2 ** 30) - 2 ** 29
+    when k == Bignum
+      rand(2 ** 70) - 2 ** 69
+    end
+  end
+
+  def fuzz(current = nil)
+    if @n > 0
+      case current
+      when nil
+        @n -= 1
+        current = fuzz [ Hash, Array ][rand(2)].new
+      when Array
+        while @n > 0
+          @n -= 1
+          current << case p = make_pick
+          when Array, Hash
+            fuzz(p)
+          else
+            p
+          end
+        end
+      when Hash
+        while @n > 0
+          @n -= 1
+          current[random_string] = case p = make_pick
+          when Array, Hash
+            fuzz(p)
+          else
+            p
+          end
+        end
+      end
+    end
+    current
+  end
+end
+
+class MyState < JSON.state
+  WS = " \r\t\n"
+
+  def initialize
+    super(
+          :indent       => make_spaces,
+          :space        => make_spaces,
+          :space_before => make_spaces,
+          :object_nl    => make_spaces,
+          :array_nl     => make_spaces,
+          :max_nesting  => false
+         )
+  end
+
+  def make_spaces
+    s = ''
+    rand(1).times { s << WS[rand(WS.size)] }
+    s
+  end
+end
+
+n = (ARGV.shift || 500).to_i
+loop do
+  fuzzer = Fuzzer.new(n,
+                      Hash => 25,
+                      Array => 25,
+                      String => 10,
+                      Fixnum => 10,
+                      Bignum => 10,
+                      nil => 5,
+                      true => 5,
+                      false => 5
+                     )
+  o1 = fuzzer.fuzz
+  json = JSON.generate o1, MyState.new
+  if $DEBUG
+    puts "-" * 80
+    puts json, json.size
+  else 
+    puts json.size
+  end
+  begin
+    o2 = JSON.parse(json, :max_nesting => false)
+  rescue JSON::ParserError => e
+    puts "Caught #{e.class}: #{e.message}\n#{e.backtrace * "\n"}"
+    puts "o1 = #{o1.inspect}", "json = #{json}", "json_str = #{json.inspect}"
+    puts "locals = #{local_variables.inspect}"
+    exit
+  end
+  if o1 != o2
+    puts "mismatch", "o1 = #{o1.inspect}", "o2 = #{o2.inspect}",
+      "json = #{json}", "json_str = #{json.inspect}"
+    puts "locals = #{local_variables.inspect}"
+  end
+end

data/vendor/json-1.1.3/tools/server.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+$KCODE='UTF8'
+require 'webrick'
+include WEBrick
+$:.unshift 'ext'
+$:.unshift 'lib'
+require 'json'
+
+class JSONServlet < HTTPServlet::AbstractServlet
+  @@count = 1
+
+  def do_GET(req, res)
+    obj = {
+      "TIME" => Time.now.strftime("%FT%T"),
+      "foo" => "Bär",
+      "bar" => "© ≠ €!",
+      'a' => 2,
+      'b' => 3.141,
+      'COUNT' => @@count += 1,
+      'c' => 'c',
+      'd' => [ 1, "b", 3.14 ],
+      'e' => { 'foo' => 'bar' },
+      'g' => "松本行弘",
+      'h' => 1000.0,
+      'i' => 0.001,
+      'j' => "\xf0\xa0\x80\x81",
+    }
+    res.body = JSON.generate obj
+    res['Content-Type'] = "application/json"
+  end
+end
+
+def create_server(err, dir, port)
+  dir = File.expand_path(dir)
+  err.puts "Surf to:", "http://#{Socket.gethostname}:#{port}"
+
+  s = HTTPServer.new(
+    :Port         => port,
+    :DocumentRoot => dir,
+    :Logger       => WEBrick::Log.new(err),
+    :AccessLog    => [
+      [ err, WEBrick::AccessLog::COMMON_LOG_FORMAT  ],
+      [ err, WEBrick::AccessLog::REFERER_LOG_FORMAT ],
+      [ err, WEBrick::AccessLog::AGENT_LOG_FORMAT   ]
+    ]
+  )
+  s.mount("/json", JSONServlet)
+  s
+end
+
+default_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'data'))
+dir = ARGV.shift || default_dir
+port = (ARGV.shift || 6666).to_i
+s = create_server(STDERR, dir, 6666)
+t = Thread.new { s.start }
+trap(:INT) do
+  s.shutdown
+  t.join
+  exit
+end
+sleep

data/vendor/moneta/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Yehuda Katz
+
+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/moneta/README

@@ -0,0 +1,51 @@
+Moneta: A unified interface for key/value stores
+================================================
+
+Moneta provides a standard interface for interacting with various kinds of key/value stores.
+
+Out of the box, it supports:
+
+* File store for xattr
+* Basic File Store
+* Memcache store
+* In-memory store
+* The xattrs in a file system
+* DataMapper
+* S3
+* Berkeley DB
+* Redis
+* SDBM
+* Tokyo
+* CouchDB
+
+All stores support key expiration, but only memcache supports it natively. All other stores
+emulate expiration.
+
+The Moneta API is purposely extremely similar to the Hash API. In order so support an
+identical API across stores, it does not support iteration or partial matches, but that
+might come in a future release.
+
+The API:
+
+#initialize(options)::          options differs per-store, and is used to set up the store
+
+#[](key)::                      retrieve a key. if the key is not available, return nil
+
+#[]=(key, value)::              set a value for a key. if the key is already used, clobber it.
+                                keys set using []= will never expire
+
+#delete(key)::                  delete the key from the store and return the current value
+
+#key?(key)::                    true if the key exists, false if it does not
+
+#has_key?(key)::                alias for key?
+
+#store(key, value, options)::   same as []=, but you can supply an :expires_in option, 
+                                which will specify a number of seconds before the key
+                                should expire. In order to support the same features
+                                across all stores, only full seconds are supported
+
+#update_key(key, options)::     updates an existing key with a new :expires_in option.
+                                if the key has already expired, it will not be updated.
+
+#clear::                        clear all keys in this store

data/vendor/moneta/Rakefile

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'spec/rake/spectask'
+require 'date'
+
+GEM = "moneta"
+GEM_VERSION = "0.5.0"
+AUTHOR = "Yehuda Katz"
+EMAIL = "wycats@gmail.com"
+HOMEPAGE = "http://www.yehudakatz.com"
+SUMMARY = "A unified interface to key/value stores"
+
+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 = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+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 :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc "Run all examples (or a specific spec with TASK=xxxx)"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_opts  = ["-cfs"]
+  t.spec_files = begin
+    if ENV["TASK"] 
+      ENV["TASK"].split(',').map { |task| "spec/**/#{task}_spec.rb" }
+    else
+      FileList['spec/**/*_spec.rb']
+    end
+  end
+end

data/vendor/moneta/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= name %>.rb

data/vendor/moneta/benchmarks/various.rb

@@ -0,0 +1,234 @@
+#!/usr/bin/env ruby
+require 'benchmark'
+require "rubygems"
+
+# Hacked arrays
+# Array modifications
+class HackedArray < Array
+  # Random keys/values
+  attr_reader :keys_used
+  def random_key(no_repeat = true, clean_keys_used = false)
+    @keys_used = [] if clean_keys_used or @keys_used.nil? or @keys_used.size == self.size
+    begin key = rand(self.size) end while no_repeat and @keys_used.include?(key)
+    @keys_used << key
+    return key
+  end
+
+  def random_value(no_repeat = true, clean_keys_used = false)
+    values_at(random_key(no_repeat, clean_keys_used)).first
+  end
+  alias_method :random, :random_value
+
+  def random_subset(n, no_repeat = true, clean_keys_used = true)
+    (1..n).map{|x| random_value(no_repeat, (clean_keys_used && x == 1))}
+  end
+
+  def self.new_from_string(str)
+    res = new
+    str.split('').each{|x| res << x}
+    res
+  end
+end
+
+require "../lib/moneta"
+require "moneta/memcache"
+require "moneta/tyrant"
+require "moneta/berkeley"
+
+
+stores = {
+  'Redis' => { },
+  'Memcached' => { :class_name => "Memcache", :server => "localhost:11211", :namespace => 'moneta_bench' },
+  'Tyrant' => { :host => 'localhost', :port => 1978 }, # Breaks for any n > 50 on my machine
+  'MongoDB' => { :host => 'localhost', :port => 27017, :db => 'moneta_bench' },
+  'LMC' => { :filename => "bench.lmc" },
+  'Berkeley' => { :file => "bench.bdb" },
+  'Rufus' => {:file => "bench.rufus"},
+  'Memory' => { },
+  'DataMapper' => { :setup => "sqlite3::memory:" },
+  # 'Couch' => {:db => "couch_test"},
+  'TC (Tyrant)' => 
+    {:name => "test.tieredtyrant", :backup => Moneta::Tyrant.new(:host => "localhost", :port => 1978), :class_name => "TieredCache"},
+  'TC (Memcached)' => 
+    {:name => "test.tieredmc", :backup => Moneta::Memcache.new(:server => "localhost:11211", :namespace => "various"), :class_name => "TieredCache"}
+}
+
+stats, keys, data, errors, summary = {}, [], HackedArray.new, HackedArray.new, HackedArray.new
+dict = HackedArray.new_from_string 'abcdefghijklnopq123456789'
+n = ARGV[0] ? ARGV[0].to_i : 100
+m = ARGV[1] ? ARGV[1].to_i : 10
+c = ARGV[2] ? ARGV[2].to_i : 3
+vlen_min, vlen_max, vlen_ttl, vlen_avg = 99999, 0, 0, 0
+ds = dict.size
+
+puts "======================================================================"
+puts "Comparison of write/read between Moneta Stores"
+puts "======================================================================"
+
+puts "Data loading..."
+n.times do |x|
+  klen = 6 + rand(3)
+  vlen = (rand(m) + 1) * (rand(m) + rand(m) + 1)
+  key = dict.random_subset(klen).join
+  keys << key
+  value = key * vlen
+  data << [key, value]
+  vs = value.size
+  vlen_min = vs if vs < vlen_min
+  vlen_max = vs if vs > vlen_max
+  vlen_ttl = vlen_ttl + vs
+end
+vlen_avg = vlen_ttl / n
+
+puts "----------------------------------------------------------------------"
+#puts data.inspect
+puts "Total keys: #{keys.size}, unique: #{keys.uniq.size}"
+#puts keys.sort.inspect
+
+puts "----------------------------------------------------------------------"
+puts "                  Minimum    Maximum      Total    Average        xps "
+puts "----------------------------------------------------------------------"
+puts "Lenght Stats   % 10i % 10i % 10i % 10i " % [vlen_min, vlen_max, vlen_ttl, vlen_avg]
+
+module Moneta
+  class TieredCache
+    include Moneta::Defaults
+  
+    def initialize(options)
+      @bdb = Moneta::Berkeley.new(:file => File.join(File.dirname(__FILE__), options[:name]))
+      @mc = options[:backup]
+      # @mc = Moneta::Tyrant.new(:host => "localhost", :port => 1978)
+      # @mc  = Moneta::Memcache.new(:server => "localhost:11211", :namespace => options[:name])
+    end
+  
+    def [](key)
+      val = @bdb[key]
+      unless val
+        @bdb[key] = val if val = @mc[key]
+      end
+      val
+    end
+  
+    def []=(key, val)
+      @bdb[key] = val
+      @mc[key]  = val
+    end
+  
+    def store(key, value, options = {})
+      @bdb.store(key, value, options)
+      @mc.store(key, value, options)
+    end
+  
+    def delete(key)
+      bdb_val = @bdb.delete(key)
+      mc_val  = @mc.delete(key)
+      bdb_val || mc_val
+    end
+  
+    def clear
+      @mc.clear
+      @bdb.clear
+    end
+  
+    def update_key(name, options)
+      @mc.update_key(name, options)
+      @bdb.update_key(name, options)
+    end
+  
+    def key?(key)
+      @bdb.key?(key) || @mc.key?(key)
+    end
+  end
+end
+
+stores.each do |name, options|
+  cname = options.delete(:class_name) || name
+  puts "======================================================================"
+  puts name
+  puts "----------------------------------------------------------------------"
+  begin
+    require "../lib/moneta/#{cname.downcase}"
+  rescue LoadError
+  end
+  klass = Moneta.const_get(cname)
+  @cache = klass.new(options)
+  stats[name] = {
+    :writes => [],
+    :reads => [],
+    :totals => [],
+    :avgs => [],
+  }
+  c.times do |round|
+    @cache.clear
+    print "[#{round + 1}] R"
+    m1 = Benchmark.measure do
+      n.times do
+        key, value = data.random
+          
+        @cache[key] = value
+      end
+    end
+    stats[name][:writes] << m1.real
+    print "W "
+    m2 = Benchmark.measure do
+      n.times do
+        key, value = data.random
+        res = @cache[key]
+        errors << [name, key, value, res] unless res == value
+      end
+    end
+    stats[name][:reads] << m2.real
+    stats[name][:totals] << (m1.real + m2.real)
+    stats[name][:avgs] << (m1.real + m2.real)
+  end
+  print "\n"
+  puts "----------------------------------------------------------------------"
+  puts "                  Minimum    Maximum      Total    Average        xps "
+  puts "----------------------------------------------------------------------"
+  tcmin, tcmax, tctot, tcavg = 99999, 0, 0, 0
+  [:writes, :reads].each do |sname|
+    cmin, cmax, ctot, cavg = 99999, 0, 0, 0
+    stats[name][sname].each do |val|
+      cmin = val if val < cmin
+      tcmin = val if val < tcmin
+      cmax = val if val > cmax
+      tcmax = val if val > tcmax
+      ctot = ctot + val
+      tctot = tctot + val
+    end
+    cavg = ctot / c
+    puts "%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f " % ["#{name} #{sname}", cmin, cmax, ctot, cavg, n / cavg]
+  end
+  tcavg = tctot / (c * 2)
+  puts "%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f " % ["#{name} avgs", tcmin, tcmax, tctot, tcavg, n / tcavg]
+  summary << [name, tcmin, tcmax, tctot, tcavg, n / tcavg]
+end
+puts "----------------------------------------------------------------------"
+if errors.size > 0
+  puts "Errors : #{errors.size}"
+#  puts errors.inspect
+else
+  puts "No errors in reading!"
+end
+puts "======================================================================"
+puts "Summary :: #{c} runs, #{n} keys"
+puts "======================================================================"
+puts "                  Minimum    Maximum      Total    Average        xps "
+puts "----------------------------------------------------------------------"
+summary.each do |sry|
+  puts "%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f " % sry
+end
+puts "======================================================================"
+puts "THE END"
+puts "======================================================================"
+
+#======================================================================
+#Summary :: 3 runs, 1000 keys
+#======================================================================
+#                  Minimum    Maximum      Total    Average       xps
+#----------------------------------------------------------------------
+#MemcacheDB         0.6202     2.7850     7.0099     1.1683   855.9366
+#Memcached          0.4483     0.6563     3.3251     0.5542  1804.4385
+#Redis              0.3282     0.5221     2.2965     0.3828  2612.6444
+#MongoDB            0.6660     1.0539     5.1667     0.8611  1161.2745
+#======================================================================