moneta 1.3.0 → 1.4.0

data/lib/moneta/hash_adapter.rb

@@ -0,0 +1,68 @@
+module Moneta
+  # @api private
+  module HashAdapter
+    attr_reader :backend
+
+    # (see Proxy#key?)
+    def key?(key, options = {})
+      @backend.has_key?(key)
+    end
+
+    # (see Proxy#load)
+    def load(key, options = {})
+      @backend[key]
+    end
+
+    # (see Proxy#store)
+    def store(key, value, options = {})
+      @backend[key] = value
+    end
+
+    # (see Proxy#delete)
+    def delete(key, options = {})
+      @backend.delete(key)
+    end
+
+    # (see Proxy#clear)
+    def clear(options = {})
+      @backend.clear
+      self
+    end
+
+    # (see Defaults#values_at)
+    def values_at(*keys, **options)
+      return super unless @backend.respond_to? :values_at
+      @backend.values_at(*keys)
+    end
+
+    # (see Defaults#fetch_values)
+    def fetch_values(*keys, **options, &defaults)
+      return super unless @backend.respond_to? :fetch_values
+      defaults ||= {} # prevents KeyError
+      @backend.fetch_values(*keys, &defaults)
+    end
+
+    # (see Defaults#slice)
+    def slice(*keys, **options)
+      return super unless @backend.respond_to? :slice
+      @backend.slice(*keys)
+    end
+
+    # (see Defaults#merge!)
+    def merge!(pairs, options = {}, &block)
+      return super unless method = [:merge!, :update].find do |method|
+        @backend.respond_to? method
+      end
+
+      hash = Hash === pairs ? pairs : Hash[pairs.to_a]
+      case method
+      when :merge!
+        @backend.merge!(hash, &block)
+      when :update
+        @backend.update(hash, &block)
+      end
+
+      self
+    end
+  end
+end

data/lib/moneta/increment_support.rb

@@ -0,0 +1,16 @@
+module Moneta
+  # @api private
+  module IncrementSupport
+    # (see Defaults#increment)
+    def increment(key, amount = 1, options = {})
+      existing = load(key, options)
+      value = (existing == nil ? 0 : Integer(existing)) + amount
+      store(key, value.to_s, options)
+      value
+    end
+
+    def self.included(base)
+      base.supports(:increment) if base.respond_to?(:supports)
+    end
+  end
+end

data/lib/moneta/nil_values.rb

@@ -0,0 +1,35 @@
+module Moneta
+  # This contains overrides of methods in Defaults where additional nil
+  # checks are required, because nil values are possible in the store.
+  # @api private
+  module NilValues
+    def fetch_values(*keys, **options)
+      values = values_at(*keys, **options)
+      return values unless block_given?
+      keys.zip(values).map do |key, value|
+        if value == nil && !key?(key)
+          yield key
+        else
+          value
+        end
+      end
+    end
+
+    def slice(*keys, **options)
+      keys.zip(values_at(*keys, **options)).reject do |key, value|
+        value == nil && !key?(key)
+      end
+    end
+
+    def merge!(pairs, options = {})
+      pairs.each do |key, value|
+        if block_given? && key?(key, options)
+          existing = load(key, options)
+          value = yield(key, existing, value)
+        end
+        store(key, value, options)
+      end
+      self
+    end
+  end
+end

data/lib/moneta/option_support.rb

@@ -0,0 +1,51 @@
+module Moneta
+  # @api private
+  module OptionSupport
+    # Return Moneta store with default options or additional proxies
+    #
+    # @param [Hash] options Options to merge
+    # @return [Moneta store]
+    #
+    # @api public
+    def with(options = nil, &block)
+      adapter = self
+      if block
+        builder = Builder.new(&block)
+        builder.adapter(adapter)
+        adapter = builder.build.last
+      end
+      options ? OptionMerger.new(adapter, options) : adapter
+    end
+
+    # Return Moneta store with default option raw: true
+    #
+    # @return [OptionMerger]
+    # @api public
+    def raw
+      @raw ||=
+        begin
+          store = with(raw: true, only: [:load, :store, :create, :delete])
+          store.instance_variable_set(:@raw, store)
+          store
+        end
+    end
+
+    # Return Moneta store with default prefix option
+    #
+    # @param [String] prefix Key prefix
+    # @return [OptionMerger]
+    # @api public
+    def prefix(prefix)
+      with(prefix: prefix, except: :clear)
+    end
+
+    # Return Moneta store with default expiration time
+    #
+    # @param [Integer] expires Default expiration time
+    # @return [OptionMerger]
+    # @api public
+    def expires(expires)
+      with(expires: expires, only: [:store, :create, :increment])
+    end
+  end
+end

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.3.0'.freeze
+  VERSION = '1.4.0'.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,7 +6,7 @@ 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")
@@ -19,19 +18,18 @@ Gem::Specification.new do |s|
   s.summary          = %{A unified interface to key/value stores, including Redis, Memcached, TokyoCabinet, ActiveRecord and many more}
 
   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",
+    '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}",
+    '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.2.1'
 end

data/script/benchmarks

@@ -164,8 +164,7 @@ class MonetaBenchmarks
       {name: "MemcachedNative"}
     end,
     {name: "Memory"},
-    {name: "MongoMoped"},
-    {name: "MongoOfficial"},
+    {name: "Mongo"},
     {name: "PStore", options: { file: "#{DIR}/pstore" }},
     {name: "Redis"},
     {

data/script/contributors

@@ -1,7 +1,12 @@
-#!/bin/sh
-git log --format='%aN <%aE>' |\
-sed -e 's/hiddenbek/Scott Wadden/g' |\
-sed -e 's/Asmod4n/Hendrik Beskow/' |\
-grep -v 'asppsa@gmail.com\|hannes.georg@xing.com\|spotapov\|yehuda-katzs-mac\|wycats ' |\
-sort -u | sort > CONTRIBUTORS
+#!/usr/bin/env ruby
 
+contributors = `git log --format='%aN <%aE>'`
+  .gsub(/hiddenbek/, 'Scott Wadden')
+  .gsub(/Asmod4n/, 'Hendrik Beskow')
+  .lines
+  .uniq
+  .reject { |line| line.match? /asppsa@gmail.com|hannes.georg@xing.com|spotapov|yehuda-katzs-mac|wycats / }
+  .sort { |str1, str2| str1.casecmp(str2) }
+
+file = File.open('CONTRIBUTORS', 'w')
+file << contributors.join

data/spec/active_support/cache_moneta_store_spec.rb

@@ -79,40 +79,38 @@ describe "cache_moneta_store" do
   end
 
   shared_examples :expiry do
-    at_each_usec do
-      it 'writes the data with expiration time' do
-        store.write 'rabbit', white_rabbit, expires_in: 0.2.second
-        expect(store.read('rabbit')).to eq white_rabbit
-        sleep 0.3
-        expect(store.read('rabbit')).to be_nil
-      end
+    it 'writes the data with expiration time' do
+      store.write 'rabbit', white_rabbit, expires_in: 0.2.second
+      expect(store.read('rabbit')).to eq white_rabbit
+      sleep 0.3
+      expect(store.read('rabbit')).to be_nil
+    end
 
-      it 'writes multiple values with expiration time' do
-        store.write_multi({
-          'rabbit' => white_rabbit,
-          'irish whisky' => 'Jameson'
-        }, expires_in: 0.2.second)
+    it 'writes multiple values with expiration time' do
+      store.write_multi({
+        'rabbit' => white_rabbit,
+        'irish whisky' => 'Jameson'
+      }, expires_in: 0.2.second)
 
-        expect(store.read_multi('rabbit', 'irish whisky')).to eq \
-          'rabbit' => white_rabbit,
-          'irish whisky' => 'Jameson'
+      expect(store.read_multi('rabbit', 'irish whisky')).to eq \
+        'rabbit' => white_rabbit,
+        'irish whisky' => 'Jameson'
 
-        sleep 0.3
-        expect(store.read_multi('rabbit', 'irish whisky')).to be_empty
-      end
+      sleep 0.3
+      expect(store.read_multi('rabbit', 'irish whisky')).to be_empty
+    end
 
-      it "sets expiry on cache miss" do
-        store.fetch('rabbit', force: true, expires_in: 0.2.second) { white_rabbit }
-        expect(store.fetch('rabbit')).to eq white_rabbit
-        sleep 0.3
-        expect(store.fetch('rabbit')).to be_nil
-      end
+    it "sets expiry on cache miss" do
+      store.fetch('rabbit', force: true, expires_in: 0.2.second) { white_rabbit }
+      expect(store.fetch('rabbit')).to eq white_rabbit
+      sleep 0.3
+      expect(store.fetch('rabbit')).to be_nil
+    end
 
-      it 'does not set expiry on cache hit' do
-        expect(store.fetch('rabbit', expires_in: 0.2.second) { white_rabbit }).to eq rabbit
-        sleep 0.3
-        expect(store.fetch('rabbit')).to eq rabbit
-      end
+    it 'does not set expiry on cache hit' do
+      expect(store.fetch('rabbit', expires_in: 0.2.second) { white_rabbit }).to eq rabbit
+      sleep 0.3
+      expect(store.fetch('rabbit')).to eq rabbit
     end
   end
 

data/spec/features/concurrent_increment.rb

@@ -8,9 +8,8 @@ shared_examples :concurrent_increment do
         increments = (0...100).map { [] }
         100.times do
           100.times do |j|
-            increments[j] << s.increment(j.to_s, 1, expires: false).tap do
-              Thread.pass if rand(1000) >= 995
-            end
+            increments[j] << s.increment(j.to_s, 1, expires: false)
+            Thread.pass if rand(1000) >= 995
           end
         end
         increments

data/spec/features/create_expires.rb

@@ -1,19 +1,19 @@
 shared_examples :create_expires do
-  at_each_usec do
-    it 'creates the given key and expires it' do
-      store.create('key','value', expires: min_ttl).should be true
-      store['key'].should == 'value'
-      advance min_ttl + t_res
-      store.key?('key').should be false
-    end
+  it 'creates the given key and expires it' do
+    store.create('key','value', expires: min_ttl).should be true
+    store['key'].should == 'value'
+    advance min_ttl
+    2.times { advance_next_tick }
+    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: min_ttl).should be false
-      store['key'].should == 'value'
-      advance min_ttl + t_res
-      store['key'].should == 'value'
-      store.key?('key').should be true
-    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: min_ttl).should be false
+    store['key'].should == 'value'
+    advance min_ttl
+    2.times { advance_next_tick }
+    store['key'].should == 'value'
+    store.key?('key').should be true
   end
 end

data/spec/features/default_expires.rb

@@ -1,15 +1,14 @@
 shared_examples :default_expires do
-  at_each_usec do
-    it 'sets the default expiration time', default_expires: true do
-      store['key1'] = 'val1'
-      advance(t_res / 4.0) # sleep less than a single time-space
-      store.key?('key1').should be true
-      store.fetch('key1').should == 'val1'
-      store.load('key1').should == 'val1'
-      advance min_ttl + t_res
-      store.key?('key1').should be false
-      store.fetch('key1').should be_nil
-      store.load('key1').should be_nil
-    end
+  it 'sets the default expiration time', default_expires: true do
+    store['key1'] = 'val1'
+    advance(t_res / 4.0) # sleep less than a single time-space
+    store.key?('key1').should be true
+    store.fetch('key1').should == 'val1'
+    store.load('key1').should == 'val1'
+    advance min_ttl
+    2.times { advance_next_tick }
+    store.key?('key1').should be false
+    store.fetch('key1').should be_nil
+    store.load('key1').should be_nil
   end
 end