moneta 0.7.17 → 0.7.18

data/lib/moneta/adapters/sqlite.rb

@@ -26,16 +26,17 @@ module Moneta
         @backend.busy_timeout(options[:busy_timeout] || 1000)
         @backend.execute("create table if not exists #{table} (k blob not null primary key, v blob)")
         @stmts =
-          [@select = @backend.prepare("select v from #{table} where k = ?"),
+          [@exists  = @backend.prepare("select exists(select 1 from #{table} where k = ?)"),
+           @select  = @backend.prepare("select v from #{table} where k = ?"),
            @replace = @backend.prepare("replace into #{table} values (?, ?)"),
-           @delete = @backend.prepare("delete from #{table} where k = ?"),
-           @clear = @backend.prepare("delete from #{table}"),
-           @create = @backend.prepare("insert into #{table} values (?, ?)")]
+           @delete  = @backend.prepare("delete from #{table} where k = ?"),
+           @clear   = @backend.prepare("delete from #{table}"),
+           @create  = @backend.prepare("insert into #{table} values (?, ?)")]
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        !@select.execute!(key).empty?
+        @exists.execute!(key).first.first.to_i == 1
       end
 
       # (see Proxy#load)

data/lib/moneta/pool.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Moneta
   # Creates a pool of stores.
   # Each thread gets its own store.
@@ -14,24 +16,45 @@ module Moneta
   class Pool < Wrapper
     # @param [Moneta store] adapter The underlying store
     # @param [Hash] options
+    # @option options [String] :mutex (::Mutex.new) Mutex object
     def initialize(options = {}, &block)
       super(nil)
+      @mutex = options[:mutex] || ::Mutex.new
+      @id = "Moneta::Pool(#{object_id})"
       @builder = Builder.new(&block)
-      @pool, @active = [], {}
+      @pool, @all = [], []
+    end
+
+    def close
+      @mutex.synchronize do
+        raise '#close can only when no thread is using the pool' if @all.size != @pool.size
+        @all.each(&:close)
+        @all = @pool = nil
+      end
     end
 
     protected
 
     def adapter
-      @active[Thread.current]
+      Thread.current[@id]
     end
 
     def wrap(*args)
-      @pool << @builder.build.last if @pool.empty?
-      @active[Thread.current] = @pool.pop
+      store = Thread.current[@id] = pop
       yield
     ensure
-      @pool << @active.delete(Thread.current)
+      Thread.current[@id] = nil
+      @mutex.synchronize { @pool << store }
+    end
+
+    def pop
+      if @mutex.synchronize { @pool.empty? }
+        store = @builder.build.last
+        @mutex.synchronize { @all << store }
+        store
+      else
+        @mutex.synchronize { @pool.pop }
+      end
     end
   end
 end

data/lib/moneta/transformer/config.rb

@@ -2,42 +2,45 @@ module Moneta
   class Transformer
     # Available key/value transformers
     TRANSFORMER = {
-      # Name    => [ Type,       Load,                           Dump,                             Library         ],
-      :bencode  => [ :serialize, '::BEncode.load(%s)',           '::BEncode.dump(%s)',             'bencode'       ],
-      :bert     => [ :serialize, '::BERT.decode(%s)',            '::BERT.encode(%s)',              'bert'          ],
-      :bson     => [ :serialize, "::BSON.deserialize(%s)['v']",  "::BSON.serialize('v'=>%s).to_s", 'bson'          ],
-      :json     => [ :serialize, '::MultiJson.load(%s).first',   '::MultiJson.dump([%s])',         'multi_json'    ],
-      :marshal  => [ :serialize, '::Marshal.load(%s)',           '::Marshal.dump(%s)'                              ],
-      :msgpack  => [ :serialize, '::MessagePack.unpack(%s)',     '::MessagePack.pack(%s)',         'msgpack'       ],
-      :ox       => [ :serialize, '::Ox.parse_obj(%s)',           '::Ox.dump(%s)',                  'ox'            ],
-      :tnet     => [ :serialize, '::TNetstring.parse(%s).first', '::TNetstring.dump(%s)',          'tnetstring'    ],
-      :yaml     => [ :serialize, '::YAML.load(%s)',              '::YAML.dump(%s)',                'yaml'          ],
-      :bzip2    => [ :compress,  '::Bzip2.uncompress(%s)',       '::Bzip2.compress(%s)',           'bzip2'         ],
-      :lz4      => [ :compress,  '::LZ4.uncompress(%s)',         '::LZ4.compress(%s)',             'lz4-ruby'      ],
-      :lzma     => [ :compress,  '::LZMA.decompress(%s)',        '::LZMA.compress(%s)',            'lzma'          ],
-      :lzo      => [ :compress,  '::LZO.decompress(%s)',         '::LZO.compress(%s)',             'lzoruby'       ],
-      :snappy   => [ :compress,  '::Snappy.inflate(%s)',         '::Snappy.deflate(%s)',           'snappy'        ],
-      :quicklz  => [ :compress,  '::QuickLZ.decompress(%s)',     '::QuickLZ.compress(%s)',         'qlzruby'       ],
-      :zlib     => [ :compress,  '::Zlib::Inflate.inflate(%s)',  '::Zlib::Deflate.deflate(%s)',    'zlib'          ],
-      :qp       => [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                  ],
-      :uuencode => [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                  ],
+      # Name    => [ Type,       Load,                           Dump,                              Library         ],
+      :bencode  => [ :serialize, '::BEncode.load(%s)',           '::BEncode.dump(%s)',              'bencode'       ],
+      :bert     => [ :serialize, '::BERT.decode(%s)',            '::BERT.encode(%s)',               'bert'          ],
+      :bson     => [ :serialize, "::BSON.deserialize(%s)['v']",  "::BSON.serialize('v'=>%s).to_s",  'bson'          ],
+      :json     => [ :serialize, '::MultiJson.load(%s).first',   '::MultiJson.dump([%s])',          'multi_json'    ],
+      :marshal  => [ :serialize, '::Marshal.load(%s)',           '::Marshal.dump(%s)'                               ],
+      :msgpack  => [ :serialize, '::MessagePack.unpack(%s)',     '::MessagePack.pack(%s)',          'msgpack'       ],
+      :ox       => [ :serialize, '::Ox.parse_obj(%s)',           '::Ox.dump(%s)',                   'ox'            ],
+      :tnet     => [ :serialize, '::TNetstring.parse(%s).first', '::TNetstring.dump(%s)',           'tnetstring'    ],
+      :yaml     => [ :serialize, '::YAML.load(%s)',              '::YAML.dump(%s)',                 'yaml'          ],
+      :bzip2    => [ :compress,  '::Bzip2.uncompress(%s)',       '::Bzip2.compress(%s)',            'bzip2'         ],
+      :lz4      => [ :compress,  '::LZ4.uncompress(%s)',         '::LZ4.compress(%s)',              'lz4-ruby'      ],
+      :lzma     => [ :compress,  '::LZMA.decompress(%s)',        '::LZMA.compress(%s)',             'lzma'          ],
+      :lzo      => [ :compress,  '::LZO.decompress(%s)',         '::LZO.compress(%s)',              'lzoruby'       ],
+      :snappy   => [ :compress,  '::Snappy.inflate(%s)',         '::Snappy.deflate(%s)',            'snappy'        ],
+      :quicklz  => [ :compress,  '::QuickLZ.decompress(%s)',     '::QuickLZ.compress(%s)',          'qlzruby'       ],
+      :zlib     => [ :compress,  '::Zlib::Inflate.inflate(%s)',  '::Zlib::Deflate.deflate(%s)',     'zlib'          ],
+      :qp       => [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                   ],
+      :uuencode => [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                   ],
       :base64   => RUBY_VERSION > '1.9' ?
-                   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                 ] :
-                   [ :encode,    "%s.unpack('m').first",         "[%s].pack('m').gsub(\"\n\", '')"                 ],
-      :escape   => [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                               ],
+                   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                  ] :
+                   [ :encode,    "%s.unpack('m').first",         "[%s].pack('m').gsub(\"\n\", '')"                  ],
+      :escape   => [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                                ],
       :hmac     => [ :hmac,      'Helper.hmacverify(%s, options[:secret] || @secret)',
-                                 'Helper.hmacsign(%s, options[:secret] || @secret)',               'openssl'       ],
-      :truncate => [ :truncate,  nil,                            'Helper.truncate(%s, @maxlen)',   'digest/md5'    ],
-      :md5      => [ :digest,    nil,                            '::Digest::MD5.hexdigest(%s)',    'digest/md5'    ],
-      :rmd160   => [ :digest,    nil,                            '::Digest::RMD160.hexdigest(%s)', 'digest/rmd160' ],
-      :sha1     => [ :digest,    nil,                            '::Digest::SHA1.hexdigest(%s)',   'digest/sha1'   ],
-      :sha256   => [ :digest,    nil,                            '::Digest::SHA256.hexdigest(%s)', 'digest/sha2'   ],
-      :sha384   => [ :digest,    nil,                            '::Digest::SHA384.hexdigest(%s)', 'digest/sha2'   ],
-      :sha512   => [ :digest,    nil,                            '::Digest::SHA512.hexdigest(%s)', 'digest/sha2'   ],
-      :prefix   => [ :prefix,    nil,                            '(options[:prefix] || @prefix)+%s'                ],
-      :spread   => [ :spread,    nil,                            'Helper.spread(%s)'                               ],
-      :to_s     => [ :string,    nil,                            '%s.to_s'                                         ],
-      :inspect  => [ :string,    nil,                            '%s.inspect'                                      ],
+                                 'Helper.hmacsign(%s, options[:secret] || @secret)',                'openssl'       ],
+      :truncate => [ :truncate,  nil,                            'Helper.truncate(%s, @maxlen)',    'digest/md5'    ],
+      :md5      => [ :digest,    nil,                            '::Digest::MD5.hexdigest(%s)',     'digest/md5'    ],
+      :rmd160   => [ :digest,    nil,                            '::Digest::RMD160.hexdigest(%s)',  'digest/rmd160' ],
+      :sha1     => [ :digest,    nil,                            '::Digest::SHA1.hexdigest(%s)',    'digest/sha1'   ],
+      :sha256   => [ :digest,    nil,                            '::Digest::SHA256.hexdigest(%s)',  'digest/sha2'   ],
+      :sha384   => [ :digest,    nil,                            '::Digest::SHA384.hexdigest(%s)',  'digest/sha2'   ],
+      :sha512   => [ :digest,    nil,                            '::Digest::SHA512.hexdigest(%s)',  'digest/sha2'   ],
+      :city32   => [ :digest,    nil,                            '::CityHash.hash32(%s).to_s(16)',  'cityhash'      ],
+      :city64   => [ :digest,    nil,                            '::CityHash.hash64(%s).to_s(16)',  'cityhash'      ],
+      :city128  => [ :digest,    nil,                            '::CityHash.hash128(%s).to_s(16)', 'cityhash'      ],
+      :prefix   => [ :prefix,    nil,                            '(options[:prefix] || @prefix)+%s'                 ],
+      :spread   => [ :spread,    nil,                            'Helper.spread(%s)'                                ],
+      :to_s     => [ :string,    nil,                            '%s.to_s'                                          ],
+      :inspect  => [ :string,    nil,                            '%s.inspect'                                       ],
     }
 
     # Allowed value transformers (Read it like a regular expression!)

data/lib/moneta/version.rb

@@ -1,5 +1,5 @@
 module Moneta
   # Moneta version number
   # @api public
-  VERSION = '0.7.17'
+  VERSION = '0.7.18'
 end

data/script/contributors

@@ -0,0 +1,7 @@
+#!/bin/sh
+git log --format='%aN <%aE>' |\
+sed -e 's/hiddenbek/Scott Wadden/g' |\
+sed -e 's/Asmod4n/Hendrik Beskow/' |\
+grep -v 'hannes.georg@xing.com\|spotapov\|yehuda-katzs-mac\|wycats ' |\
+sort -u | sort > CONTRIBUTORS
+

data/script/generate-specs

@@ -7,8 +7,8 @@ class Specs
 
   def initialize(options = {})
     @specs = options.delete(:specs).to_a
-    @key = options.delete(:key)     || %w(object string hash boolean nil integer)
-    @value = options.delete(:value) || %w(object string hash boolean nil integer)
+    @key = options.delete(:key)     || %w(object string hash boolean nil integer number)
+    @value = options.delete(:value) || %w(object string hash boolean nil integer number)
     @features = []
     [:expires, :expires_native, :increment, :create].each do |feature|
       @features << feature if @specs.include?(feature)
@@ -21,8 +21,8 @@ class Specs
     Specs.new({:specs => specs, :key => key, :value => value}.merge(options))
   end
 
-  def stringkeys_only
-    new(:key => %w(string))
+  def simplestringkeys_only
+    new(:key => %w(simplestring))
   end
 
   def stringvalues_only
@@ -404,12 +404,12 @@ end
     :store => :Couch,
     :options => ":db => 'simple_couch'",
     :load_value => '::Marshal.load(value.unpack(\'m\').first)',
-    :specs => STANDARD_SPECS.without_increment.without_create
+    :specs => STANDARD_SPECS.without_increment
   },
   'simple_couch_with_expires' => {
     :store => :Couch,
     :options => ":db => 'simple_couch_with_expires', :expires => true",
-    :specs => STANDARD_SPECS.without_increment.without_create.with_expires,
+    :specs => STANDARD_SPECS.without_increment.with_expires,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_mongo' => {
@@ -495,16 +495,18 @@ end
     :specs => STANDARD_SPECS.without_increment.without_create.with_expires
   },
   'weak_create' => {
+    :preamble => "start_restserver\n",
     :build => %{Moneta.build do
   use :WeakCreate
-  adapter :Couch, :db => 'weak_create'
+  adapter :RestClient, :url => 'http://localhost:8808/moneta/'
 end},
     :specs => ADAPTER_SPECS.without_increment.without_concurrent
   },
   'weak_increment' => {
+    :preamble => "start_restserver\n",
     :build => %{Moneta.build do
   use :WeakIncrement
-  adapter :Couch, :db => 'weak_increment'
+  adapter :RestClient, :url => 'http://localhost:8808/moneta/'
 end},
     :specs => ADAPTER_SPECS.without_create.without_concurrent
   },
@@ -1103,6 +1105,42 @@ end},
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalMd5SpreadKeyMarshalValue.should_not be_nil
+end}
+  },
+  'transformer_marshal_city32' => {
+    :build => %{Moneta.build do
+  use :Transformer, :key => [:marshal, :city32], :value => :marshal
+  adapter :Memory
+end},
+    :specs => STANDARD_SPECS.without_persist,
+    :tests => %{
+it 'compile transformer class' do
+  store.should_not be_nil
+  Moneta::Transformer::MarshalCity32KeyMarshalValue.should_not be_nil
+end}
+  },
+  'transformer_marshal_city64' => {
+    :build => %{Moneta.build do
+  use :Transformer, :key => [:marshal, :city64], :value => :marshal
+  adapter :Memory
+end},
+    :specs => STANDARD_SPECS.without_persist,
+    :tests => %{
+it 'compile transformer class' do
+  store.should_not be_nil
+  Moneta::Transformer::MarshalCity64KeyMarshalValue.should_not be_nil
+end}
+  },
+  'transformer_marshal_city128' => {
+    :build => %{Moneta.build do
+  use :Transformer, :key => [:marshal, :city128], :value => :marshal
+  adapter :Memory
+end},
+    :specs => STANDARD_SPECS.without_persist,
+    :tests => %{
+it 'compile transformer class' do
+  store.should_not be_nil
+  Moneta::Transformer::MarshalCity128KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_truncate' => {
@@ -1187,7 +1225,7 @@ end}
   },
   'adapter_couch' => {
     :build => "Moneta::Adapters::Couch.new(:db => 'adapter_couch')",
-    :specs => ADAPTER_SPECS.without_increment.without_create
+    :specs => ADAPTER_SPECS.without_increment.simplevalues_only.simplestringkeys_only
   },
   'adapter_datamapper' => {
     :build => 'Moneta::Adapters::DataMapper.new(:setup => "mysql://root:@localhost/moneta", :table => "adapter_datamapper")',
@@ -1307,7 +1345,7 @@ end}
   },
   'adapter_mongo' => {
     :build => 'Moneta::Adapters::Mongo.new(:db => "adapter_mongo")',
-    :specs => ADAPTER_SPECS.with_native_expires,
+    :specs => ADAPTER_SPECS.with_native_expires.simplevalues_only,
     :tests => %{
 it 'automatically deletes expired document' do
   store.store('key', 'val', :expires => 5)
@@ -1318,7 +1356,7 @@ end}
   },
   'adapter_mongo_with_default_expires' => {
     :build => %{Moneta::Adapters::Mongo.new(:expires => 1)},
-    :specs => ADAPTER_SPECS.with_expires.with_default_expires
+    :specs => ADAPTER_SPECS.with_expires.with_default_expires.simplevalues_only
   },
   'adapter_pstore' => {
     :build => 'Moneta::Adapters::PStore.new(:file => File.join(make_tempdir, "adapter_pstore"))',
@@ -1606,8 +1644,10 @@ SPECS = {}
 KEYS = {
   'nil' => [0, 'nil'],
   'integer' => [-10, 42],
+  'number' => [0.5, -0.3, 1<<127, 99],
   'boolean' => [true, false],
-  'string' => ['strkey1', 'strkey2'].map(&:inspect),
+  'string' => %w(strkey1 strkey2 foo/bar bar/foo/baz).map(&:inspect),
+  'simplestring' => %w(strkey1 strkey2).map(&:inspect),
   'object' => ['Value.new(:objkey1)', 'Value.new(:objkey2)'],
   'hash' => [{'hashkey1' => 'hashkey2'}, {'hashkey3' => 'hashkey4'}].map(&:inspect)
 }
@@ -1615,19 +1655,24 @@ KEYS = {
 VALUES = {
   'nil' => [0, 'nil'],
   'integer' => [41, -12],
+  'number' => [123.456, -98.7, 1<<128, 33],
   'boolean' => [true, false],
-  'string' => ['strval1', 'strval2'].map(&:inspect),
+  'string' => %w(strval1 strval2).map(&:inspect),
   'hash' => [{'hashval1' => ['array1', 1]}, {'hashval3' => ['array2', {'hashval4' => 42}]}].map(&:inspect),
   'object' => ['Value.new(:objval1)', 'Value.new(:objval2)'],
 }
 
-KEYS.each do |key_type, keypair|
-  VALUES.each do |val_type, valpair|
-    4.times do |i|
-      key1, key2 = i % 2 == 0 ? keypair : keypair.reverse
-      val1, val2 = i < 2 ? valpair : valpair.reverse
-
-      code = %{it 'reads from keys like a Hash' do
+KEYS.each do |key_type, keys|
+  VALUES.each do |val_type, vals|
+    (keys.size/2).times do |k|
+      keypair = keys[2*k,2]
+      (vals.size/2).times do |v|
+        valpair = vals[2*v,2]
+        4.times do |i|
+          key1, key2 = i % 2 == 0 ? keypair : keypair.reverse
+          val1, val2 = i < 2 ? valpair : valpair.reverse
+
+          code = %{it 'reads from keys like a Hash' do
   store[#{key1}].should be_nil
   store.load(#{key1}).should be_nil
 end
@@ -1677,9 +1722,9 @@ it 'accepts frozen options' do
   store.clear(options).should equal(store)
   store.store(#{key1}, #{val1}, options).should == #{val1}
 end}
-    (SPECS["null_#{key_type}key_#{val_type}value"] ||= []) << code
+          (SPECS["null_#{key_type}key_#{val_type}value"] ||= []) << code
 
-    code = %{it 'writes values to keys that like a Hash' do
+          code = %{it 'writes values to keys that like a Hash' do
   store[#{key1}] = #{val1}
   store[#{key1}].should == #{val1}
   store.load(#{key1}).should == #{val1}
@@ -1717,10 +1762,22 @@ it 'overwrites existing values' do
   store[#{key1}].should == #{val1}
   store[#{key1}] = #{val2}
   store[#{key1}].should == #{val2}
+end
+
+it 'stores frozen values' do
+  value = #{val1}.freeze
+  (store[#{key1}] = value).should equal(value)
+  store[#{key1}].should == #{val1}
+end
+
+it 'stores frozen keys' do
+  key = #{key1}.freeze
+  store[key] = #{val1}
+  store[#{key1}].should == #{val1}
 end}
 
-      if val_type != 'nil'
-        code << %{
+          if val_type != 'nil'
+            code << %{
 it 'fetches a key with a default value with fetch, if the key is available' do
   store[#{key1}] = #{val1}
   store.fetch(#{key1}, #{val2}).should == #{val1}
@@ -1732,11 +1789,11 @@ it 'does not run the block in fetch if the key is available' do
   store.fetch(#{key1}) { unaltered = 'altered' }
   unaltered.should == 'unaltered'
 end}
-      end
+          end
 
-      (SPECS["store_#{key_type}key_#{val_type}value"] ||= []) << code
+          (SPECS["store_#{key_type}key_#{val_type}value"] ||= []) << code
 
-      if val_type != 'boolean' && val_type != 'nil' && val_type != 'integer'
+          if val_type != 'boolean' && val_type != 'nil' && val_type != 'integer' && val_type != 'number'
         (SPECS["returndifferent_#{key_type}key_#{val_type}value"] ||= []) << %{it 'guarantees that a different value is retrieved' do
   value = #{val1}
   store[#{key1}] = value
@@ -1747,15 +1804,17 @@ end}
   store[#{key1}] = value
   store[#{key1}].should be_equal(value)
 end}
-      end
+          end
 
-      code = %{it 'persists values' do
+          code = %{it 'persists values' do
   store[#{key1}] = #{val1}
   store.close
   @store = nil
   store[#{key1}].should == #{val1}
 end}
-      (SPECS["persist_#{key_type}key_#{val_type}value"] ||= []) << code
+          (SPECS["persist_#{key_type}key_#{val_type}value"] ||= []) << code
+        end
+      end
     end
   end
 end

data/script/install-bundle

@@ -16,7 +16,7 @@ end
 
 BUNDLE_FILE = "moneta-bundle-#{RUBY_VERSION}-#{ruby}.tar.gz"
 
-if system("wget --no-check-certificate --quiet -O #{BUNDLE_FILE} https://moneta:#{ENV['DAV_PW']}@mendler.net/dav/#{BUNDLE_FILE}")
+if system("curl -u moneta:#{ENV['DAV_PW']} -k -o #{BUNDLE_FILE} https://mendler.net/dav/#{BUNDLE_FILE}")
   cmd 'rm -rf .bundle'
   cmd "tar -xpf #{BUNDLE_FILE}"
   cmd "rm -f #{BUNDLE_FILE}"

data/script/start-services

@@ -1,17 +1,11 @@
 #!/bin/bash
-sudo service riak start
-sudo service couchdb start
-sudo service redis-server start
-sudo service cassandra start
-sudo service memcached start
-sudo service mongodb start
 
 echo 'Starting TokyoTyrant'
 /usr/sbin/ttserver -dmn -pid /tmp/ttserver.pid -log /tmp/ttserver.log -port 1978
 
-# Waiting for servers to start
-sleep 3
-
-#echo 'TokyoTyrant status'
-#ps aux | grep ttserver
-#cat /tmp/ttserver.log
+sudo service riak start &
+sudo service couchdb start &
+sudo service redis-server start &
+sudo service cassandra start &
+sudo service memcached start &
+sudo service mongodb start &