moneta 1.2.0 → 1.4.2

data/lib/moneta/shared.rb

@@ -11,8 +11,6 @@ module Moneta
   #
   # @api public
   class Shared < Wrapper
-    not_supports :each_key
-
     # @param [Hash] options
     # @option options [Integer] :port (9000) TCP port
     # @option options [String] :host Server hostname
@@ -25,7 +23,7 @@ module Moneta
 
     # (see Proxy#close)
     def close
-      if @server
+      if server?
         @server.stop
         @thread.join
         @server = @thread = nil
@@ -36,13 +34,20 @@ module Moneta
       end
     end
 
+    # Returns true if this wrapper is running as the server
+    #
+    # @return [Boolean] wrapper is a server
+    def server?
+      @server != nil
+    end
+
     protected
 
     def wrap(*args)
       connect
       yield
     rescue Errno::ECONNRESET, Errno::EPIPE, IOError, SystemCallError
-      @connect_lock.synchronize { close unless @server }
+      @connect_lock.synchronize { close unless server? }
       tries ||= 0
       (tries += 1) < 3 ? retry : raise
     end
@@ -52,21 +57,22 @@ module Moneta
       @connect_lock.synchronize do
         @adapter ||= Adapters::Client.new(@options)
       end
-    rescue Errno::ECONNREFUSED, Errno::ENOENT => ex
+    rescue Errno::ECONNREFUSED, Errno::ENOENT, IOError => ex
       start_server
       tries ||= 0
       warn "Moneta::Shared - Failed to connect: #{ex.message}" if tries > 0
-      (tries += 1) < 3 ? retry : raise
+      (tries += 1) < 10 ? retry : raise
     end
 
     # TODO: Implement this using forking (MRI) and threading (JRuby)
     # to get maximal performance
     def start_server
       @connect_lock.synchronize do
+        return if server?
         begin
           raise "Adapter already set" if @adapter
           @adapter = Lock.new(@builder.build.last)
-          raise "Server already set" if @server
+          raise "Server already set" if server?
           @server = Server.new(@adapter, @options)
           @thread = Thread.new { @server.run }
           sleep 0.1 until @server.running?

data/lib/moneta/transformer.rb

@@ -43,12 +43,15 @@ module Moneta
 
       def compile(keys, values)
         @key_validator ||= compile_validator(KEY_TRANSFORMER)
+        @load_key_validator ||= compile_validator(LOAD_KEY_TRANSFORMER)
+        @test_key_validator ||= compile_validator(TEST_KEY_TRANSFORMER)
         @value_validator ||= compile_validator(VALUE_TRANSFORMER)
 
         raise ArgumentError, 'Invalid key transformer chain' if @key_validator !~ keys.map(&:inspect).join
         raise ArgumentError, 'Invalid value transformer chain' if @value_validator !~ values.map(&:inspect).join
 
         klass = Class.new(self)
+        compile_each_key_support_clause(klass, keys)
         klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           def initialize(adapter, options = {})
             super
@@ -58,15 +61,17 @@ module Moneta
         END_EVAL
 
         key, key_opts = compile_transformer(keys, 'key')
+        key_load, key_load_opts = compile_transformer(keys.reverse, 'key', 1) if @load_key_validator =~ keys.map(&:inspect).join
+        key_test, key_test_opts = compile_transformer(keys.reverse, 'key', 4) if @test_key_validator =~ keys.map(&:inspect).join
         dump, dump_opts = compile_transformer(values, 'value')
         load, load_opts = compile_transformer(values.reverse, 'value', 1)
 
         if values.empty?
-          compile_key_transformer(klass, key, key_opts)
+          compile_key_transformer(klass, key, key_opts, key_load, key_load_opts, key_test, key_test_opts)
         elsif keys.empty?
           compile_value_transformer(klass, load, load_opts, dump, dump_opts)
         else
-          compile_key_value_transformer(klass, key, key_opts, load, load_opts, dump, dump_opts)
+          compile_key_value_transformer(klass, key, key_opts, key_load, key_load_opts, key_test, key_test_opts, load, load_opts, dump, dump_opts)
         end
 
         klass
@@ -77,13 +82,28 @@ module Moneta
         options.empty? ? 'options' : "Utils.without(options, #{options.map(&:to_sym).map(&:inspect).join(', ')})"
       end
 
-      def compile_key_transformer(klass, key, key_opts)
+      def compile_each_key_support_clause(klass, keys)
         klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
-          not_supports :each_key
+          #{'not_supports :each_key' if @load_key_validator !~ keys.map(&:inspect).join}
+        END_EVAL
+      end
+
+      def compile_key_transformer(klass, key, key_opts, key_load, key_load_opts, key_test, key_test_opts)
+        if_key_test = key_load && key_test ? "if #{key_test}" : ''
 
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           def key?(key, options = {})
             @adapter.key?(#{key}, #{without key_opts})
           end
+          def each_key(&block)
+            raise NotImplementedError, "each_key is not supported on this transformer" \
+              unless supports? :each_key
+
+            return enum_for(:each_key) unless block_given?
+            @adapter.each_key.lazy.map{ |key| #{key_load} #{if_key_test} }.reject(&:nil?).each(&block)
+
+            self
+          end
           def increment(key, amount = 1, options = {})
             @adapter.increment(#{key}, amount, #{without key_opts})
           end
@@ -200,13 +220,22 @@ module Moneta
         END_EVAL
       end
 
-      def compile_key_value_transformer(klass, key, key_opts, load, load_opts, dump, dump_opts)
-        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
-          not_supports :each_key
+      def compile_key_value_transformer(klass, key, key_opts, key_load, key_load_opts, key_test, key_test_opts, load, load_opts, dump, dump_opts)
+        if_key_test = key_load && key_test ? "if #{key_test}" : ''
 
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           def key?(key, options = {})
             @adapter.key?(#{key}, #{without key_opts})
           end
+          def each_key(&block)
+            raise NotImplementedError, "each_key is not supported on this transformer" \
+              unless supports? :each_key
+
+            return enum_for(:each_key) { @adapter.each_key.size } unless block_given?
+            @adapter.each_key.lazy.map{ |key| #{key_load} #{if_key_test} }.reject(&:nil?).each(&block)
+
+            self
+          end
           def increment(key, amount = 1, options = {})
             @adapter.increment(#{key}, amount, #{without key_opts})
           end
@@ -320,9 +349,15 @@ module Moneta
           raise ArgumentError, "Unknown transformer #{name}" unless t = TRANSFORMER[name]
           require t[3] if t[3]
           code = t[idx]
+          code ||= compile_prefix(name: name, transformer: t, value: value) if idx == 4 && var == 'key'
+
+          raise "Undefined command for transformer #{name}" unless code
+
           options += code.scan(/options\[:(\w+)\]/).flatten
           value =
-            if t[0] == :serialize && var == 'key'
+            if t[0] == :serialize && var == 'key' && idx == 4
+              "(tmp = #{value}; (false === tmp || '' === tmp) ? false : #{code % 'tmp'})"
+            elsif t[0] == :serialize && var == 'key'
               "(tmp = #{value}; String === tmp ? tmp : #{code % 'tmp'})"
             else
               code % value
@@ -336,6 +371,13 @@ module Moneta
         (keys.empty? ? '' : keys.map(&camel_case).join + 'Key') +
           (values.empty? ? '' : values.map(&camel_case).join + 'Value')
       end
+
+      def compile_prefix(name:, transformer:, value:)
+        return unless [:encode, :serialize].include?(transformer[0])
+
+        load_val, = compile_transformer([name], value, 1)
+        "(#{load_val} rescue '')"
+      end
     end
   end
 end

data/lib/moneta/transformer/config.rb

@@ -2,48 +2,61 @@ 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, 'Helper::BSON.load(%s)',        'Helper::BSON.dump(%s)',           'bson'          ],
-      json:     [ :serialize, '::MultiJson.load(%s)',         '::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'            ],
-      php:      [ :serialize, '::PHP.unserialize(%s)',        '::PHP.serialize(%s)',           'php_serialize' ],
-      tnet:     [ :serialize, '::TNetstring.parse(%s).first', '::TNetstring.dump(%s)',           'tnetstring'    ],
-      yaml:     [ :serialize, '::YAML.load(%s)',              '::YAML.dump(%s)',                 'yaml'          ],
-      bzip2:    [ :compress,  'Helper.bunzip2(%s)',           'Helper.bzip2(%s)',                'rbzip2'        ],
-      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'          ],
-      base64:   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                  ],
+      # Name:   [ Type,       Load,                           Dump,                              Library        Test      ],
+      bencode:  [ :serialize, '::BEncode.load(%s)',           '::BEncode.dump(%s)',              'bencode'      ],
+      bert:     [ :serialize, '::BERT.decode(%s)',            '::BERT.encode(%s)',               'bert'         ],
+      bson:     [ :serialize, 'Helper::BSON.load(%s)',        'Helper::BSON.dump(%s)',           'bson'         ],
+      json:     [ :serialize, '::MultiJson.load(%s)',         '::MultiJson.dump(%s)',            'multi_json'   ],
+      marshal:  [ :serialize, '::Marshal.load(%s)',           '::Marshal.dump(%s)',              nil            ],
+      msgpack:  [ :serialize, '::MessagePack.unpack(%s)',     '::MessagePack.pack(%s)',          'msgpack'      ],
+      ox:       [ :serialize, '::Ox.parse_obj(%s)',           '::Ox.dump(%s)',                   'ox'           ],
+      php:      [ :serialize, '::PHP.unserialize(%s)',        '::PHP.serialize(%s)',             'php_serialize'],
+      tnet:     [ :serialize, '::TNetstring.parse(%s).first', '::TNetstring.dump(%s)',           'tnetstring'   ],
+      yaml:     [ :serialize, '::YAML.load(%s)',              '::YAML.dump(%s)',                 'yaml'         ],
+      bzip2:    [ :compress,  'Helper.bunzip2(%s)',           'Helper.bzip2(%s)',                'rbzip2'       ],
+      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'         ],
+      base64:   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                 ],
       urlsafe_base64: [
-        :encode,              'Base64.urlsafe_decode64(%s)',  'Base64.urlsafe_encode64(%s)',     'base64'
+        :encode,
+        'Base64.urlsafe_decode64(%s)',
+        'Base64.urlsafe_encode64(%s)',
+        'base64'
       ],
-      escape:   [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                                ],
-      hex:      [ :encode,    "[%s].pack('H*')",              "%s.unpack('H*').first"                            ],
-      qp:       [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                   ],
-      uuencode: [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                   ],
-      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'   ],
-      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'                                       ]
+      escape:   [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                               ],
+      hex:      [ :encode,    "[%s].pack('H*')",              "%s.unpack('H*').first"                           ],
+      qp:       [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                  ],
+      uuencode: [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                  ],
+      hmac:     [
+        :hmac,
+        'Helper.hmacverify(%s, options[:secret] || @secret)',
+        'Helper.hmacsign(%s, options[:secret] || @secret)',
+        'openssl'
+      ],
+      prefix:   [
+        :prefix,
+        "%s.sub(@prefix, '')",
+        '(options[:prefix] || @prefix)+%s',
+        nil,
+        "%s.start_with?(@prefix)"
+      ],
+      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'     ],
+      spread:   [ :spread,    nil,                            'Helper.spread(%s)'                               ],
+      to_s:     [ :string,    nil,                            '%s.to_s'                                         ],
+      inspect:  [ :string,    nil,                            '%s.inspect'                                      ]
     }.freeze
 
     # Allowed value transformers (Read it like a regular expression!)
@@ -51,5 +64,11 @@ module Moneta
 
     # Allowed key transformers (Read it like a regular expression!)
     KEY_TRANSFORMER = '(serialize | string)? prefix? ((encode? truncate?) | (digest spread?))?'.freeze
+
+    # Key transformers that can be "loaded" (e.g. reversed) and can be used by the key enumeration feature
+    LOAD_KEY_TRANSFORMER = 'serialize? prefix? encode?'.freeze
+
+    # Key transformers that can be "tested for success" with a dumped key and can be used by the key enumeration feature
+    TEST_KEY_TRANSFORMER = 'serialize? prefix? encode?'.freeze
   end
 end

data/lib/moneta/transformer/helper.rb

@@ -5,11 +5,11 @@ module Moneta
       extend self
 
       def escape(value)
-        value.gsub(/[^a-zA-Z0-9_-]+/) { '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase }
+        value.gsub(/[^a-zA-Z0-9_-]+/) { |match| '%' + match.unpack('H2' * match.bytesize).join('%').upcase }
       end
 
       def unescape(value)
-        value.gsub(/((?:%[0-9a-fA-F]{2})+)/) { |matches| [matches[1].delete('%')].pack('H*') }
+        value.gsub(/(?:%[0-9a-fA-F]{2})+/) { |match| [match.delete('%')].pack('H*') }
       end
 
       def hmacverify(value, secret)

data/lib/moneta/transformer/helper/bson.rb

@@ -5,22 +5,12 @@ module Moneta
       module BSON
         extend self
 
-        if ::BSON::VERSION >= '4.0.0'
-          def load(value)
-            ::BSON::Document.from_bson(::BSON::ByteBuffer.new(value))['v']
-          end
-
-          def dump(value)
-            ::BSON::Document['v' => value].to_bson.to_s
-          end
-        else
-          def load(value)
-            ::BSON::Document.from_bson(::StringIO.new(value))['v']
-          end
+        def load(value)
+          ::BSON::Document.from_bson(::BSON::ByteBuffer.new(value))['v']
+        end
 
-          def dump(value)
-            ::BSON::Document['v' => value].to_bson
-          end
+        def dump(value)
+          ::BSON::Document['v' => value].to_bson.to_s
         end
       end
     end

data/lib/moneta/version.rb

@@ -1,5 +1,5 @@
 module Moneta
   # Moneta version number
   # @api public
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.4.2'.freeze
 end

data/lib/rack/cache/moneta.rb

@@ -14,21 +14,20 @@ module Rack
 
       def resolve(uri)
         cache = Rack::Cache::Moneta[uri.to_s.sub(%r{^moneta://}, '')] ||=
-                  begin
-                    options = parse_query(uri.query)
-                    options.keys.each do |key|
-                      options[key.to_sym] =
-                        case value = options.delete(key)
-                        when 'true'
-                          true
-                        when 'false'
-                          false
-                        else
-                          value
-                        end
-                    end
-                    ::Moneta.new(uri.host.to_sym, options)
-                  end
+          begin
+            options = parse_query(uri.query).map do |key, value|
+              [key.to_sym,
+               case value
+               when 'true'
+                 true
+               when 'false'
+                 false
+               else
+                 value
+               end]
+            end
+            ::Moneta.new(uri.host.to_sym, options.to_h)
+          end
         new(cache)
       end
     end

data/moneta.gemspec

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 require File.dirname(__FILE__) + '/lib/moneta/version'
 require 'date'
 
@@ -7,23 +6,30 @@ Gem::Specification.new do |s|
   s.version          = Moneta::VERSION
   s.date             = Date.today.to_s
   s.authors          = ['Daniel Mendler', 'Yehuda Katz', 'Hannes Georg', 'Alastair Pharo']
-  s.email            = %w{mail@daniel-mendler.de wycats@gmail.com hannes.georg@googlemail.com asppsa@gmail.com}
+  s.email            = %w{mail@daniel-mendler.de wycats@gmail.com hannes.georg@googlemail.com me@asph.dev}
   s.description      = 'A unified interface to key/value stores'
   s.extra_rdoc_files = %w{README.md SPEC.md LICENSE}
   s.files            = `git ls-files`.split("\n")
   s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.homepage         = 'http://github.com/moneta-rb/moneta'
+  s.homepage         = 'https://github.com/moneta-rb/moneta'
   s.licenses         = %w(MIT)
   s.require_paths    = %w(lib)
   s.summary          = %{A unified interface to key/value stores, including Redis, Memcached, TokyoCabinet, ActiveRecord and many more}
-  s.required_ruby_version = '>= 2.2.2'
 
+  s.metadata = {
+    'bug_tracker_uri' => 'https://github.com/moneta-rb/moneta/issues',
+    'changelog_uri' => "https://github.com/moneta-rb/moneta/blob/v#{s.version}/CHANGES",
+    'documentation_uri' => "https://www.rubydoc.info/gems/moneta/#{s.version}",
+    'source_code_uri' => "https://github.com/moneta-rb/moneta/tree/v#{s.version}",
+  }
+
+  s.required_ruby_version = '>= 2.3.0'
+
+  s.add_development_dependency 'parallel_tests', '~> 2.29.2'
+  s.add_development_dependency 'rantly', '~> 1.2.0'
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rspec-retry', '~> 0.6.1'
-  s.add_development_dependency 'rantly', '~> 1.2.0'
-  s.add_development_dependency 'parallel_tests', '~> 2.29.2'
+  s.add_development_dependency 'rubocop', '~> 0.81.0'
   s.add_development_dependency 'timecop', '~> 0.9.1'
-  s.add_development_dependency 'rubocop', '~> 0.67.2'
-  s.add_development_dependency 'irb', '~> 1.0.0'
 end

data/script/benchmarks

@@ -36,6 +36,9 @@ class MonetaBenchmarks
   postgres_database1 = ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta1'
   postgres_database2 = ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta2'
 
+  couch_login = ENV['COUCH_LOGIN'] || 'admin'
+  couch_password = ENV['COUCH_PASSWORD'] || 'password'
+
   STORES = [
     # SDBM accepts only very short key/value pairs (1k for both)
     {name: "SDBM", sizes: [:small], options: {file: "#{DIR}/sdbm"}},
@@ -112,7 +115,9 @@ class MonetaBenchmarks
         backend: if defined?(JRUBY_VERSION)
                    require 'faraday/adapter/manticore'
                    ::Faraday.new("http://127.0.0.1:5984/moneta") { |f| f.adapter :manticore }
-                 end
+                 end,
+        login: couch_login,
+        password: couch_password
       },
       clear_options: { compact: true, await_compact: true },
     },
@@ -159,8 +164,7 @@ class MonetaBenchmarks
       {name: "MemcachedNative"}
     end,
     {name: "Memory"},
-    {name: "MongoMoped"},
-    {name: "MongoOfficial"},
+    {name: "Mongo"},
     {name: "PStore", options: { file: "#{DIR}/pstore" }},
     {name: "Redis"},
     {