moneta 0.7.6 → 0.7.8

data/lib/moneta/transformer.rb

@@ -57,86 +57,91 @@ module Moneta
           end
         end_eval
 
-        key = compile_transformer(keys, 'key')
-        dump = compile_transformer(values, 'value')
-        load = compile_transformer(values.reverse, 'value', 1)
+        key, key_opts = compile_transformer(keys, 'key')
+        dump, dump_opts = compile_transformer(values, 'value')
+        load, load_opts = compile_transformer(values.reverse, 'value', 1)
 
         if values.empty?
-          compile_key_transformer(klass, key)
+          compile_key_transformer(klass, key, key_opts)
         elsif keys.empty?
-          compile_value_transformer(klass, load, dump)
+          compile_value_transformer(klass, load, load_opts, dump, dump_opts)
         else
-          compile_key_value_transformer(klass, key, load, dump)
+          compile_key_value_transformer(klass, key, key_opts, load, load_opts, dump, dump_opts)
         end
 
         klass
       end
 
-      def compile_key_transformer(klass, key)
+      def without(*options)
+        options = options.flatten.uniq
+        options.empty? ? 'options' : "Utils.without(options, #{options.map(&:to_sym).map(&:inspect).join(', ')})"
+      end
+
+      def compile_key_transformer(klass, key, key_opts)
         klass.class_eval <<-end_eval, __FILE__, __LINE__
           def key?(key, options = {})
-            @adapter.key?(#{key}, options)
+            @adapter.key?(#{key}, #{without key_opts})
           end
           def increment(key, amount = 1, options = {})
-            @adapter.increment(#{key}, amount, options)
+            @adapter.increment(#{key}, amount, #{without key_opts})
           end
           def load(key, options = {})
-            options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            @adapter.load(#{key}, options)
+            @adapter.load(#{key}, #{without :raw, key_opts})
           end
           def store(key, value, options = {})
-            options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            @adapter.store(#{key}, value, options)
+            @adapter.store(#{key}, value, #{without :raw, key_opts})
           end
           def delete(key, options = {})
-            options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            @adapter.delete(#{key}, options)
+            @adapter.delete(#{key}, #{without :raw, key_opts})
+          end
+          def create(key, value, options = {})
+            @adapter.create(#{key}, value, #{without :raw, key_opts})
           end
         end_eval
       end
 
-      def compile_value_transformer(klass, load, dump)
+      def compile_value_transformer(klass, load, load_opts, dump, dump_opts)
         klass.class_eval <<-end_eval, __FILE__, __LINE__
           def load(key, options = {})
-            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            value = @adapter.load(key, options)
-            value && !raw ? #{load} : value
+            value = @adapter.load(key, #{without :raw, load_opts})
+            value && !options[:raw] ? #{load} : value
           end
           def store(key, value, options = {})
-            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            @adapter.store(key, raw ? value : #{dump}, options)
+            @adapter.store(key, options[:raw] ? value : #{dump}, #{without :raw, dump_opts})
             value
           end
           def delete(key, options = {})
-            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            value = @adapter.delete(key, options)
-            value && !raw ? #{load} : value
+            value = @adapter.delete(key, #{without :raw, load_opts})
+            value && !options[:raw] ? #{load} : value
+          end
+          def create(key, value, options = {})
+            @adapter.create(key, options[:raw] ? value : #{dump}, #{without :raw, dump_opts})
           end
         end_eval
       end
 
-      def compile_key_value_transformer(klass, key, load, dump)
+      def compile_key_value_transformer(klass, key, key_opts, load, load_opts, dump, dump_opts)
         klass.class_eval <<-end_eval, __FILE__, __LINE__
           def key?(key, options = {})
-            @adapter.key?(#{key}, options)
+            @adapter.key?(#{key}, #{without key_opts})
           end
           def increment(key, amount = 1, options = {})
-            @adapter.increment(#{key}, amount, options)
+            @adapter.increment(#{key}, amount, #{without key_opts})
           end
           def load(key, options = {})
-            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            value = @adapter.load(#{key}, options)
-            value && !raw ? #{load} : value
+            value = @adapter.load(#{key}, #{without :raw, key_opts, load_opts})
+            value && !options[:raw] ? #{load} : value
           end
           def store(key, value, options = {})
-            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            @adapter.store(#{key}, raw ? value : #{dump}, options)
+            @adapter.store(#{key}, options[:raw] ? value : #{dump}, #{without :raw, key_opts, dump_opts})
             value
           end
           def delete(key, options = {})
-            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
-            value = @adapter.delete(#{key}, options)
-            value && !raw ? #{load} : value
+            value = @adapter.delete(#{key}, #{without :raw, key_opts, load_opts})
+            value && !options[:raw] ? #{load} : value
+          end
+          def create(key, value, options = {})
+            @adapter.create(#{key}, options[:raw] ? value : #{dump}, #{without :raw, key_opts, dump_opts})
           end
         end_eval
       end
@@ -151,7 +156,6 @@ module Moneta
         end.join("\n")
       end
 
-      # Compile transformer validator regular expression
       def compile_validator(s)
         Regexp.new('\A' + s.gsub(/\w+/) do
                      '(' + TRANSFORMER.select {|k,v| v.first.to_s == $& }.map {|v| ":#{v.first}" }.join('|') + ')'
@@ -160,16 +164,20 @@ module Moneta
 
       # Returned compiled transformer code string
       def compile_transformer(transformer, var, i = 2)
-        transformer.inject(var) do |value, name|
+        value, options = var, []
+        transformer.each do |name|
           raise ArgumentError, "Unknown transformer #{name}" unless t = TRANSFORMER[name]
           require t[3] if t[3]
           code = t[i]
-          if t[0] == :serialize && var == 'key'
-            "(tmp = #{value}; String === tmp ? tmp : #{code % 'tmp'})"
-          else
-            code % value
-          end
+          options += code.scan(/options\[:(\w+)\]/).flatten
+          value =
+            if t[0] == :serialize && var == 'key'
+              "(tmp = #{value}; String === tmp ? tmp : #{code % 'tmp'})"
+            else
+              code % value
+            end
         end
+        return value, options
       end
 
       def class_name(keys, values)

data/lib/moneta/transformer/config.rb

@@ -2,44 +2,46 @@ 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'         ],
-      :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'          ],
-      :uuencode => [ :encode,    "%s.unpack('u').first",           "[%s].pack('u').strip"                            ],
+      # 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'         ],
+      :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'          ],
+      :uuencode => [ :encode,    "%s.unpack('u').first",         "[%s].pack('u').strip"                            ],
       :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)'                               ],
-      :hmac     => [ :hmac,      'Helper.hmacverify(%s, @secret)', 'Helper.hmacsign(%s, @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     => [ :to_s,      nil,                              '%s.to_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'                                      ],
     }
 
     # Allowed value transformers (Read it like a regular expression!)
     VALUE_TRANSFORMER = 'serialize? compress? hmac? encode?'
 
     # Allowed key transformers (Read it like a regular expression!)
-    KEY_TRANSFORMER = '(serialize | to_s)? prefix? ((encode? truncate?) | (digest spread?))?'
+    KEY_TRANSFORMER = '(serialize | string)? prefix? ((encode? truncate?) | (digest spread?))?'
   end
 end

data/lib/moneta/utils.rb

@@ -0,0 +1,20 @@
+module Moneta
+  # @api private
+  module Utils
+    extend self
+
+    def without(hash, *keys)
+      if keys.any? {|k| hash.include?(k) }
+        hash = hash.dup
+        keys.each {|k| hash.delete(k) }
+      end
+      hash
+    end
+
+    def to_int(value)
+      intvalue = value.to_i
+      raise "#{value.inspect} is not an integer value" unless value == nil || intvalue.to_s == value.to_s
+      intvalue
+    end
+  end
+end

data/lib/moneta/version.rb

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

data/lib/moneta/weak.rb

@@ -0,0 +1,17 @@
+module Moneta
+  # Adds weak create support to the underlying store
+  #
+  # @note The increment method will not be thread or multi-process safe (this is meant by weak)
+  # @api public
+  class WeakCreate < Proxy
+    include CreateSupport
+  end
+
+  # Adds weak increment support to the underlying store
+  #
+  # @note The increment method will not be thread or multi-process safe (this is meant by weak)
+  # @api public
+  class WeakIncrement < Proxy
+    include IncrementSupport
+  end
+end

data/lib/moneta/wrapper.rb

@@ -27,6 +27,11 @@ module Moneta
       wrap(:increment, key, amount, options) { super }
     end
 
+    # (see Proxy#create)
+    def create(key, value, options = {})
+      wrap(:create, key, value, options) { super }
+    end
+
     # (see Proxy#clear)
     def clear(options = {})
       wrap(:clear, options) { super }

data/lib/rack/moneta_cookies.rb

@@ -23,7 +23,7 @@ module Rack
   #     adapter :Cookie
   #   end
   #
-  #   run lambda do |env|
+  #   run lambda { |env|
   #     req = Rack::Request.new(env)
   #     req.cookies #=> is now a Moneta store!
   #     env['rack.request.cookie_hash'] #=> is now a Moneta store!
@@ -31,7 +31,7 @@ module Rack
   #     req.cookies['key'] = 'value' #=> sets 'moneta.key'
   #     req.cookies.delete('key') #=> removes 'moneta.key'
   #     [200, {}, []]
-  #   end
+  #   }
   #
   # @api public
   class MonetaCookies

data/lib/rack/moneta_store.rb

@@ -8,9 +8,9 @@ module Rack
   #   # Add Rack::MonetaStore somewhere in your rack stack
   #   use Rack::MonetaStore, :Memory, :cache => true
   #
-  #   run lambda do |env|
+  #   run lambda { |env|
   #     env['rack.moneta_store'] # is a Moneta store with per-request caching
-  #   end
+  #   }
   #
   # @example config.ru
   #   # Pass it a block like the one passed to Moneta.build
@@ -19,9 +19,9 @@ module Rack
   #     adapter :Cookie
   #   end
   #
-  #   run lambda do |env|
+  #   run lambda { |env|
   #     env['rack.moneta_store'] # is a Moneta store without caching
-  #   end
+  #   }
   #
   # @api public
   class MonetaStore

data/script/benchmarks

@@ -24,12 +24,6 @@ class Array
     m = mean
     Math.sqrt(map {|s| (s - m) ** 2 }.mean)
   end
-
-  def randomize
-    rest, result = dup, []
-    result << rest.slice!(rand(rest.size)) until result.size == size
-    result
-  end
 end
 
 class MonetaBenchmarks
@@ -242,7 +236,7 @@ class MonetaBenchmarks
         puts "\e[31m#{name} not benchmarked - #{ex.message}\e[0m"
         STORES.delete(name)
       ensure
-        cache.close if cache
+        (cache.close rescue nil) if cache
       end
     end
   end
@@ -312,14 +306,14 @@ class MonetaBenchmarks
         store.clear
         print "%s[%-#{2 * @config[:runs]}s] " % ["\b" * (2 * @config[:runs] + 3), state << 'W']
 
-        @data = @data.randomize
+        @data.shuffle!
         m1 = Benchmark.measure do
           @data.each {|k,v| store[k] = v }
         end
 
         print "%s[%-#{2 * @config[:runs]}s] " % ["\b" * (2 * @config[:runs] + 3), state << 'R']
 
-        @data = @data.randomize
+        @data.shuffle!
         error = 0
         m2 = Benchmark.measure do
           @data.each do |k, v|

data/script/generate-specs

@@ -61,14 +61,17 @@ class Specs
     a = specs.dup
     if a.include?(:transform_value)
       a.delete(:transform_value)
-      a << :transform_value_with_expires
+      a << :transform_value_expires
     end
+    a << :create_expires if a.include?(:create)
     a << :expires
     new(:specs => a)
   end
 
   def with_native_expires
-    new(:specs => specs.with(:expires))
+    a = specs.dup
+    a << :create_expires if a.include?(:create)
+    new(:specs => a.with(:expires))
   end
 
   def without_marshallable
@@ -98,11 +101,15 @@ class Specs
   def with_default_expires
     new(:specs => specs.with(:default_expires))
   end
+
+  def without_create
+    new(:specs => specs.without(:create, :create_expires).with(:not_create))
+  end
 end
 
-ADAPTER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :increment, :persist, :multiprocess], :key => %w(string), :value => %w(string))
-STANDARD_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :persist, :multiprocess])
-TRANSFORMER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :transform_value, :increment])
+ADAPTER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :increment, :persist, :multiprocess, :create], :key => %w(string), :value => %w(string))
+STANDARD_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :persist, :multiprocess, :create])
+TRANSFORMER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :transform_value, :increment, :create])
 
 header = "# Generated by #{File.basename(__FILE__)}\n"
 
@@ -129,16 +136,16 @@ end
 }
   },
   'simple_client_unix' => {
-    :preamble => "start_server(Moneta::Adapters::Memory.new, :file => File.join(make_tempdir, 'simple_client_unix'))\n",
+    :preamble => "start_server(Moneta::Adapters::Memory.new, :socket => File.join(make_tempdir, 'simple_client_unix'))\n",
     :store => :Client,
-    :options => ":file => File.join(make_tempdir, 'simple_client_unix')",
+    :options => ":socket => File.join(make_tempdir, 'simple_client_unix')",
     :specs => STANDARD_SPECS
   },
   'simple_restclient' => {
     :preamble => "start_restserver\n",
     :store => :RestClient,
     :options => ":url => 'http://localhost:8808/moneta/'",
-    :specs => STANDARD_SPECS.without_increment
+    :specs => STANDARD_SPECS.without_increment.without_create
   },
   'simple_memory' => {
     :store => :Memory,
@@ -215,12 +222,12 @@ end
   'simple_cassandra' => {
     :store => :Cassandra,
     :options => ':keyspace => "simple_cassandra"',
-    :specs => STANDARD_SPECS.without_increment.with_native_expires,
+    :specs => STANDARD_SPECS.without_increment.without_create.with_native_expires,
   },
   'simple_hbase' => {
     :store => :HBase,
     :options => ':table => "simple_hbase"',
-    :specs => STANDARD_SPECS
+    :specs => STANDARD_SPECS.without_create
   },
   'simple_hbase_with_expires' => {
     :store => :HBase,
@@ -314,12 +321,12 @@ end
   'simple_localmemcache' => {
     :store => :LocalMemCache,
     :options => ':file => File.join(make_tempdir, "simple_localmemcache")',
-    :specs => STANDARD_SPECS.without_increment
+    :specs => STANDARD_SPECS.without_increment.without_create
   },
   'simple_localmemcache_with_expires' => {
     :store => :LocalMemCache,
     :options => ':file => File.join(make_tempdir, "simple_localmemcache_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_increment.with_expires
+    :specs => STANDARD_SPECS.without_increment.without_create.with_expires
   },
   'simple_tokyocabinet' => {
     :store => :TokyoCabinet,
@@ -365,25 +372,25 @@ end
     :options => ":bucket => 'simple_riak'",
     # We don't want Riak warnings in tests
     :preamble => "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n",
-    :specs => STANDARD_SPECS.without_increment
+    :specs => STANDARD_SPECS.without_increment.without_create
   },
   'simple_riak_with_expires' => {
     :store => :Riak,
     :options => ":bucket => 'simple_riak_with_expires', :expires => true",
     # We don't want Riak warnings in tests
     :preamble => "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n",
-    :specs => STANDARD_SPECS.without_increment.with_expires
+    :specs => STANDARD_SPECS.without_increment.with_expires.without_create
   },
   'simple_couch' => {
     :store => :Couch,
     :options => ":db => 'simple_couch'",
     :load_value => '::Marshal.load(value.unpack(\'m\').first)',
-    :specs => STANDARD_SPECS.without_increment
+    :specs => STANDARD_SPECS.without_increment.without_create
   },
   'simple_couch_with_expires' => {
     :store => :Couch,
     :options => ":db => 'simple_couch_with_expires', :expires => true",
-    :specs => STANDARD_SPECS.without_increment.with_expires,
+    :specs => STANDARD_SPECS.without_increment.without_create.with_expires,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_mongo' => {
@@ -393,11 +400,11 @@ end
   },
   'simple_null' => {
     :store => :Null,
-    :specs => STANDARD_SPECS.without_increment.without_store.without_persist
+    :specs => STANDARD_SPECS.without_increment.without_create.without_store.without_persist
   },
   'null_adapter' => {
     :build => 'Moneta::Adapters::Null.new',
-    :specs => Specs.new(:specs => [:null, :not_increment, :not_persist])
+    :specs => Specs.new(:specs => [:null, :not_increment, :not_create, :not_persist])
   },
   'simple_sequel' => {
     :store => :Sequel,
@@ -449,7 +456,7 @@ end
   },
   'simple_fog' => {
     :store                  => :Fog,
-    :specs                  => STANDARD_SPECS.without_increment,
+    :specs                  => STANDARD_SPECS.without_increment.without_create,
     :options => ":aws_access_key_id => 'fake_access_key_id',
     :aws_secret_access_key  => 'fake_secret_access_key',
     :provider               => 'AWS',
@@ -466,7 +473,21 @@ end
     :expires                => true",
     # Put Fog into testing mode
     :preamble               => "require 'fog'\nFog.mock!\n",
-    :specs => STANDARD_SPECS.without_increment.with_expires
+    :specs => STANDARD_SPECS.without_increment.without_create.with_expires
+  },
+  'weak_create' => {
+    :build => %{Moneta.build do
+  use :WeakCreate
+  adapter :Memory
+end},
+    :specs => STANDARD_SPECS.without_transform.without_persist.returnsame
+  },
+  'weak_increment' => {
+    :build => %{Moneta.build do
+  use :WeakIncrement
+  adapter :Memory
+end},
+    :specs => STANDARD_SPECS.without_transform.without_persist.returnsame
   },
   'expires_memory' => {
     :build => %{Moneta.build do
@@ -549,10 +570,27 @@ end
 end},
     :specs => ADAPTER_SPECS.without_persist.returnsame
   },
-  'shared' => {
+  'shared_tcp' => {
     :build => %{Moneta.build do
   use(:Shared, :port => 9001) do
-    adapter :PStore, :file => File.join(make_tempdir, 'shared')
+    adapter :PStore, :file => File.join(make_tempdir, 'shared_tcp')
+  end
+end},
+    :specs => ADAPTER_SPECS,
+    :tests => %{
+it 'shares values' do
+  store['shared_key'] = 'shared_value'
+  second = new_store
+  second.key?('shared_key').should be_true
+  second['shared_key'].should == 'shared_value'
+  second.close
+end
+}
+  },
+  'shared_unix' => {
+    :build => %{Moneta.build do
+  use(:Shared, :socket => File.join(make_tempdir, 'shared_unix.socket')) do
+    adapter :PStore, :file => File.join(make_tempdir, 'shared_unix')
   end
 end},
     :specs => ADAPTER_SPECS,
@@ -575,7 +613,7 @@ end
     add { adapter :Memory }
   end
 end},
-    :specs => ADAPTER_SPECS.without_increment
+    :specs => ADAPTER_SPECS.without_increment.without_create
   },
   'stack_memory_file' => {
     :build => %{Moneta.build do
@@ -586,7 +624,7 @@ end},
     add { adapter :File, :dir => File.join(make_tempdir, "stack_memory_file") }
   end
 end},
-    :specs => STANDARD_SPECS.without_increment.returnsame.without_transform.stringkeys_only.stringvalues_only
+    :specs => STANDARD_SPECS.without_increment.without_create.returnsame.without_transform.stringkeys_only.stringvalues_only
   },
   'lock' => {
     :build => %{Moneta.build do
@@ -810,6 +848,19 @@ end},
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::To_sKey.should_not be_nil
+end}
+  },
+  'transformer_key_inspect' => {
+    :build => %{Moneta.build do
+  use :Transformer, :key => :inspect
+  adapter :Memory
+end},
+    :specs => TRANSFORMER_SPECS.returnsame.simplekeys_only,
+    :load_value => 'value',
+    :tests => %{
+it 'compile transformer class' do
+  store.should_not be_nil
+  Moneta::Transformer::InspectKey.should_not be_nil
 end}
   },
   'transformer_value_marshal' => {
@@ -1050,19 +1101,19 @@ end
   'adapter_restclient' => {
     :preamble => "start_restserver\n",
     :build => "Moneta::Adapters::RestClient.new(:url => 'http://localhost:8808/moneta/')",
-    :specs => ADAPTER_SPECS.without_increment
+    :specs => ADAPTER_SPECS.without_increment.without_create
   },
   'adapter_cassandra' => {
     :build => "Moneta::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra')",
-    :specs => ADAPTER_SPECS.without_increment.with_native_expires
+    :specs => ADAPTER_SPECS.without_increment.without_create.with_native_expires
   },
   'adapter_cassandra_with_default_expires' => {
     :build => %{Moneta::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra_with_default_expires', :expires => 1)},
-    :specs => ADAPTER_SPECS.without_increment.with_native_expires.with_default_expires
+    :specs => ADAPTER_SPECS.without_increment.without_create.with_native_expires.with_default_expires
   },
   'adapter_hbase' => {
     :build => "Moneta::Adapters::HBase.new(:table => 'adapter_hbase')",
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.without_create
   },
   'adapter_cookie' => {
     :build => 'Moneta::Adapters::Cookie.new',
@@ -1070,7 +1121,7 @@ end
   },
   'adapter_couch' => {
     :build => "Moneta::Adapters::Couch.new(:db => 'adapter_couch')",
-    :specs => ADAPTER_SPECS.without_increment
+    :specs => ADAPTER_SPECS.without_increment.without_create
   },
   'adapter_datamapper' => {
     :build => 'Moneta::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper")',
@@ -1132,15 +1183,15 @@ end
     # Put Fog into testing mode
     :preamble               => "require 'fog'\nFog.mock!\n",
     # Fog returns same object in mocking mode (in-memory store)
-    :specs => ADAPTER_SPECS.without_increment.returnsame
+    :specs => ADAPTER_SPECS.without_increment.without_create.returnsame
   },
   'adapter_gdbm' => {
     :build => 'Moneta::Adapters::GDBM.new(:file => File.join(make_tempdir, "adapter_gdbm"))',
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.without_multiprocess
   },
   'adapter_localmemcache' => {
     :build => 'Moneta::Adapters::LocalMemCache.new(:file => File.join(make_tempdir, "adapter_localmemcache"))',
-    :specs => ADAPTER_SPECS.without_increment
+    :specs => ADAPTER_SPECS.without_increment.without_create
   },
   'adapter_memcached_dalli' => {
     :build => 'Moneta::Adapters::MemcachedDalli.new(:namespace => "adapter_memcached_dalli")',
@@ -1218,7 +1269,7 @@ end}
   'adapter_riak' => {
     :build => 'Moneta::Adapters::Riak.new',
     :options => ":bucket => 'adapter_riak'",
-    :specs => ADAPTER_SPECS.without_increment,
+    :specs => ADAPTER_SPECS.without_increment.without_create,
     # We don't want Riak warnings in tests
     :preamble => "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n"
   },
@@ -1250,6 +1301,133 @@ end}
     :build => 'Moneta::Adapters::YAML.new(:file => File.join(make_tempdir, "adapter_yaml"))',
     :specs => STANDARD_SPECS.simplevalues_only.simplekeys_only.without_transform
   },
+  'mutex' => {
+    :store => :Memory,
+    :specs => Specs.new,
+    :tests => %{
+it 'should have #lock' do
+  mutex = Moneta::Mutex.new(store, 'mutex')
+  mutex.lock.should be_true
+  mutex.locked?.should be_true
+  expect do
+   mutex.lock
+  end.to raise_error(RuntimeError)
+  expect do
+   mutex.try_lock
+  end.to raise_error(RuntimeError)
+  mutex.unlock.should be_nil
+  mutex.locked?.should be_false
+end
+
+it 'should have #enter' do
+  mutex = Moneta::Mutex.new(store, 'mutex')
+  mutex.enter.should be_true
+  mutex.locked?.should be_true
+  expect do
+   mutex.enter
+  end.to raise_error(RuntimeError)
+  expect do
+   mutex.try_enter
+  end.to raise_error(RuntimeError)
+  mutex.leave.should be_nil
+  mutex.locked?.should be_false
+end
+
+it 'should lock with #lock' do
+  a = Moneta::Mutex.new(store, 'mutex')
+  b = Moneta::Mutex.new(store, 'mutex')
+  a.lock.should be_true
+  b.try_lock.should be_false
+  a.unlock.should be_nil
+end
+
+it 'should have lock timeout' do
+  a = Moneta::Mutex.new(store, 'mutex')
+  b = Moneta::Mutex.new(store, 'mutex')
+  a.lock.should be_true
+  b.lock(1).should be_false
+  a.unlock.should be_nil
+end
+
+it 'should have #synchronize' do
+  mutex = Moneta::Mutex.new(store, 'mutex')
+  mutex.synchronize do
+    mutex.locked?.should be_true
+  end
+  mutex.locked?.should be_false
+end
+  }
+  },
+  'semaphore' => {
+    :store => :Memory,
+    :specs => Specs.new,
+    :tests => %{
+it 'should have #lock' do
+  mutex = Moneta::Semaphore.new(store, 'semaphore')
+  mutex.lock.should be_true
+  mutex.locked?.should be_true
+  expect do
+   mutex.lock
+  end.to raise_error(RuntimeError)
+  expect do
+   mutex.try_lock
+  end.to raise_error(RuntimeError)
+  mutex.unlock.should be_nil
+  mutex.locked?.should be_false
+end
+
+it 'should have #enter' do
+  mutex = Moneta::Semaphore.new(store, 'semaphore')
+  mutex.enter.should be_true
+  mutex.locked?.should be_true
+  expect do
+   mutex.enter
+  end.to raise_error(RuntimeError)
+  expect do
+   mutex.try_enter
+  end.to raise_error(RuntimeError)
+  mutex.leave.should be_nil
+  mutex.locked?.should be_false
+end
+
+it 'should lock with #lock' do
+  a = Moneta::Semaphore.new(store, 'semaphore')
+  b = Moneta::Semaphore.new(store, 'semaphore')
+  a.lock.should be_true
+  b.try_lock.should be_false
+  a.unlock.should be_nil
+end
+
+it 'should have lock timeout' do
+  a = Moneta::Semaphore.new(store, 'semaphore')
+  b = Moneta::Semaphore.new(store, 'semaphore')
+  a.lock.should be_true
+  b.lock(1).should be_false
+  a.unlock.should be_nil
+end
+
+it 'should count concurrent accesses' do
+  a = Moneta::Semaphore.new(store, 'semaphore', 2)
+  b = Moneta::Semaphore.new(store, 'semaphore', 2)
+  c = Moneta::Semaphore.new(store, 'semaphore', 2)
+  a.synchronize do
+    a.locked?.should be_true
+    b.synchronize do
+      b.locked?.should be_true
+      c.try_lock.should be_false
+    end
+  end
+end
+
+it 'should have #synchronize' do
+  semaphore = Moneta::Semaphore.new(store, 'semaphore')
+  semaphore.synchronize do
+    semaphore.locked?.should be_true
+  end
+  semaphore.locked?.should be_false
+end
+  }
+  },
   'optionmerger' => {
     :store => :Memory,
     :specs => Specs.new,
@@ -1314,22 +1492,20 @@ it 'merges options except for some methods' do
 end
 
 it 'has method #raw' do
-  store.raw.default_options.should == {:store=>{:raw=>true},:load=>{:raw=>true},:delete=>{:raw=>true}}
+  store.raw.default_options.should == {:store=>{:raw=>true},:create=>{:raw=>true},:load=>{:raw=>true},:delete=>{:raw=>true}}
   store.raw.should equal(store.raw.raw)
 end
 
 it 'has method #prefix' do
-  store.prefix('a').default_options.should == {:store=>{:prefix=>'a'},:load=>{:prefix=>'a'},
+  store.prefix('a').default_options.should == {:store=>{:prefix=>'a'},:load=>{:prefix=>'a'},:create=>{:prefix=>'a'},
                                                :delete=>{:prefix=>'a'},:key? => {:prefix=>'a'},:increment=>{:prefix=>'a'}}
 
-  store.prefix('a').prefix('b').default_options.should == {:store=>{:prefix=>'ab'},:load=>{:prefix=>'ab'},
+  store.prefix('a').prefix('b').default_options.should == {:store=>{:prefix=>'ab'},:load=>{:prefix=>'ab'},:create=>{:prefix=>'ab'},
                                                            :delete=>{:prefix=>'ab'},:key? => {:prefix=>'ab'},:increment=>{:prefix=>'ab'}}
 
-  store.raw.prefix('b').default_options.should == {:store=>{:raw=>true,:prefix=>'b'},:load=>{:raw=>true,:prefix=>'b'},
-                                                   :delete=>{:raw=>true,:prefix=>'b'},:key? => {:prefix=>'b'},:increment=>{:prefix=>'b'}}
+  store.raw.prefix('b').default_options.should == {:store=>{:raw=>true,:prefix=>'b'},:load=>{:raw=>true,:prefix=>'b'},:create=>{:raw=>true,:prefix=>'b'},:delete=>{:raw=>true,:prefix=>'b'},:key? => {:prefix=>'b'},:increment=>{:prefix=>'b'}}
 
-  store.prefix('a').raw.default_options.should == {:store=>{:raw=>true,:prefix=>'a'},:load=>{:raw=>true,:prefix=>'a'},
-                                                   :delete=>{:raw=>true,:prefix=>'a'},:key? => {:prefix=>'a'},:increment=>{:prefix=>'a'}}
+  store.prefix('a').raw.default_options.should == {:store=>{:raw=>true,:prefix=>'a'},:load=>{:raw=>true,:prefix=>'a'},:create=>{:raw=>true,:prefix=>'a'},:delete=>{:raw=>true,:prefix=>'a'},:key? => {:prefix=>'a'},:increment=>{:prefix=>'a'}}
 end
 
 it 'supports adding proxis using #with' do
@@ -1796,6 +1972,67 @@ it 'raises error in #decrement on non integer value' do
   expect do
     store.decrement('strkey')
   end.to raise_error
+end
+
+it 'supports Semaphore' do
+  a = Moneta::Semaphore.new(store, 'semaphore', 2)
+  b = Moneta::Semaphore.new(store, 'semaphore', 2)
+  c = Moneta::Semaphore.new(store, 'semaphore', 2)
+  a.synchronize do
+    a.locked?.should be_true
+    b.synchronize do
+      b.locked?.should be_true
+      c.try_lock.should be_false
+    end
+  end
+end
+}
+
+SPECS['create'] = %{it 'creates the given key' do
+  store.create('key','value').should be_true
+  store['key'].should == 'value'
+end
+
+it 'creates raw value with the given key' do
+  store.raw.create('key','value').should be_true
+  store.raw['key'].should == 'value'
+end
+
+it 'does not create a key if it exists' do
+  store['key'] = 'value'
+  store.create('key','another value').should be_false
+  store['key'].should == 'value'
+end
+
+it 'supports Mutex' do
+  a = Moneta::Mutex.new(store, 'mutex')
+  b = Moneta::Mutex.new(store, 'mutex')
+  a.lock.should be_true
+  b.try_lock.should be_false
+  a.unlock.should be_nil
+end
+}
+
+SPECS['not_create'] = %{it 'does not support #create' do
+  expect do
+    store.create('key','value')
+  end.to raise_error(NotImplementedError)
+end}
+
+SPECS['create_expires'] = %{it 'creates the given key and expires it' do
+  store.create('key','value', :expires => 1).should be_true
+  store['key'].should == 'value'
+  sleep 2
+  store.key?('key').should be_false
+end
+
+it 'does not change expires if the key exists' do
+  store.store('key', 'value', :expires => false).should == 'value'
+  store.create('key','another value', :expires => 1).should be_false
+  store['key'].should == 'value'
+  sleep 2
+  store['key'].should == 'value'
+  store.key?('key').should be_true
 end}
 
 SPECS['marshallable_key']  = %{it 'refuses to #[] from keys that cannot be marshalled' do
@@ -1889,7 +2126,7 @@ it 'might raise exception on invalid value' do
   end
 end}
 
-SPECS['transform_value_with_expires']  = %{it 'allows to bypass transformer with :raw' do
+SPECS['transform_value_expires']  = %{it 'allows to bypass transformer with :raw' do
   store['key'] = 'value'
   load_value(store.load('key', :raw => true)).should == 'value'
   store['key'] = [1,2,3]