moneta 1.4.1 → 1.5.1

data/lib/moneta/server.rb

@@ -4,14 +4,17 @@ module Moneta
   # Moneta server to be used together with Moneta::Adapters::Client
   # @api public
   class Server
-    TIMEOUT = 1
-    MAXSIZE = 0x100000
+    include Config
+
+    config :timeout, default: 1
+    config :max_size, default: 0x100000
 
     # @api private
     class Connection
-      def initialize(io, store)
+      def initialize(io, store, max_size)
         @io = io
         @store = store
+        @max_size = max_size
         @fiber = Fiber.new { run }
       end
 
@@ -58,7 +61,7 @@ module Moneta
 
       def read_msg
         size = read(4).unpack('N').first
-        throw :closed, 'Message too big' if size > MAXSIZE
+        throw :closed, 'Message too big' if size > @max_size
         Marshal.load(read(size))
       end
 
@@ -155,9 +158,13 @@ module Moneta
     # @param [Hash] options
     # @option options [Integer] :port (9000) TCP port
     # @option options [String] :socket Alternative Unix socket file name
+    # @option options [Integer] :timeout (1) Number of seconds to timeout on IO.select
+    # @option options [Integer] :max_size (0x100000) Maximum number of bytes
+    #   allowed to be sent by clients in requests
     def initialize(store, options = {})
+      options = configure(**options)
       @store = store
-      @server = start(options)
+      @server = start(**options)
       @ios = [@server]
       @reads = @ios.dup
       @writes = []
@@ -187,7 +194,7 @@ module Moneta
         @ios
           .reject { |io| io == @server }
           .each { |io| close_connection(io) }
-        File.unlink(@socket) if @socket rescue nil
+        File.unlink(config.socket) if config.socket rescue nil
       end
     end
 
@@ -202,7 +209,7 @@ module Moneta
     private
 
     def mainloop
-      if ready = IO.select(@reads, @writes, @ios, TIMEOUT)
+      if ready = IO.select(@reads, @writes, @ios, config.timeout)
         reads, writes, errors = ready
         errors.each { |io| close_connection(io) }
 
@@ -229,7 +236,7 @@ module Moneta
 
     def accept_connection
       io = @server.accept
-      @connections[io] = Connection.new(io, @store)
+      @connections[io] = Connection.new(io, @store, config.max_size)
       @ios << io
       resume(io)
     ensure
@@ -261,21 +268,21 @@ module Moneta
       end
     end
 
-    def start(options)
-      if @socket = options[:socket]
+    def start(host: '127.0.0.1', port: 9000, socket: nil)
+      if socket
         begin
-          UNIXServer.open(@socket)
+          UNIXServer.open(socket)
         rescue Errno::EADDRINUSE
-          if client = (UNIXSocket.open(@socket) rescue nil)
+          if client = (UNIXSocket.open(socket) rescue nil)
             client.close
             raise
           end
-          File.unlink(@socket)
+          File.unlink(socket)
           tries ||= 0
           (tries += 1) < 3 ? retry : raise
         end
       else
-        TCPServer.open(options[:host] || '127.0.0.1', options[:port] || 9000)
+        TCPServer.open(host, port)
       end
     end
 

data/lib/moneta/version.rb

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

data/lib/moneta/wrapper.rb

@@ -71,5 +71,10 @@ module Moneta
     def merge!(pairs, options = {})
       wrap(:merge!, pairs, options) { super }
     end
+
+    # (see Proxy#config)
+    def config
+      wrap(:config) { super }
+    end
   end
 end

data/lib/moneta.rb

@@ -3,9 +3,11 @@
 # * {Moneta.new}
 # * {Moneta.build}
 module Moneta
+  autoload :Adapter,           'moneta/adapter'
   autoload :Builder,           'moneta/builder'
   autoload :Cache,             'moneta/cache'
   autoload :CreateSupport,     'moneta/create_support'
+  autoload :Config,            'moneta/config'
   autoload :DBMAdapter,        'moneta/dbm_adapter'
   autoload :Defaults,          'moneta/defaults'
   autoload :EachKeySupport,    'moneta/each_key_support'

data/moneta.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 2.3.0'
 
+  s.add_development_dependency 'multi_json', '~> 1.15.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'

data/spec/active_support/cache_moneta_store_spec.rb

@@ -74,7 +74,7 @@ describe "cache_moneta_store" do
       end
       expect(result['rabbit']).to eq rabbit
       expect(result['irish whisky']).to eq 'irish whisky was missing'
-      expect(store.fetch 'irish whisky').to eq 'irish whisky was missing'
+      expect(store.fetch('irish whisky')).to eq 'irish whisky was missing'
     end
   end
 
@@ -88,9 +88,9 @@ describe "cache_moneta_store" do
 
     it 'writes multiple values with expiration time' do
       store.write_multi({
-        'rabbit' => white_rabbit,
-        'irish whisky' => 'Jameson'
-      }, expires_in: 0.2.second)
+                          'rabbit' => white_rabbit,
+                          'irish whisky' => 'Jameson'
+                        }, expires_in: 0.2.second)
 
       expect(store.read_multi('rabbit', 'irish whisky')).to eq \
         'rabbit' => white_rabbit,
@@ -234,23 +234,23 @@ describe "cache_moneta_store" do
     end
 
     context "with :Memory store" do
-      let(:store){ described_class.new(store: :Memory) }
+      let(:store) { described_class.new(store: :Memory) }
       include_examples :moneta_store
     end
 
     context "with existing :Memory store" do
-      let(:store){ described_class.new(store: ::Moneta.new(:Memory)) }
+      let(:store) { described_class.new(store: ::Moneta.new(:Memory)) }
       include_examples :moneta_store
     end
 
-    context "with Redis store" do
-      let(:store) {described_class.new(store: :Redis) }
+    context "with Redis store", adapter: :Redis do
+      let(:store) { described_class.new(store: :Redis) }
       include_examples :moneta_store
     end
   end
 
   describe ActiveSupport::Cache::MemoryStore do
-    let(:store){ described_class.new }
+    let(:store) { described_class.new }
 
     include_examples :basic_store
     include_examples :expiry
@@ -258,8 +258,8 @@ describe "cache_moneta_store" do
     include_examples :basic_instrumentation
   end
 
-  describe ActiveSupport::Cache::MemCacheStore do
-    let(:store){ described_class.new('127.0.0.1:11213') }
+  describe ActiveSupport::Cache::MemCacheStore, memcached: true do
+    let(:store) { described_class.new('127.0.0.1:11213') }
 
     include_context :start_memcached, 11213
 
@@ -270,8 +270,8 @@ describe "cache_moneta_store" do
     include_examples :increment_decrement_instrumentation
   end
 
-  describe ActiveSupport::Cache::RedisCacheStore do
-    let(:store){ described_class.new(url: 'redis:///3') }
+  describe ActiveSupport::Cache::RedisCacheStore, redis: true do
+    let(:store) { described_class.new(url: "redis:///3") }
 
     include_examples :basic_store
     include_examples :expiry

data/spec/features/null.rb

@@ -1,66 +1,66 @@
 shared_examples :null do
   it 'reads from keys like a Hash' do
-    moneta_property_of(keys: 1).check do |keys:|
-      store[keys[0]].should be_nil
-      store.load(keys[0]).should be_nil
+    moneta_property_of(keys: 1).check do |m|
+      store[m.keys[0]].should be_nil
+      store.load(m.keys[0]).should be_nil
     end
   end
 
   it 'guarantees that the same value is returned when setting a key' do
-    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
-      (store[keys[0]] = values[0]).should equal(values[0])
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      (store[m.keys[0]] = m.values[0]).should equal(m.values[0])
     end
   end
 
   it 'returns false from #key? if a key is not available' do
-    moneta_property_of(keys: 1).check(1) do |keys:|
-      store.key?(keys[0]).should be false
+    moneta_property_of(keys: 1).check(1) do |m|
+      store.key?(m.keys[0]).should be false
     end
   end
 
   it 'returns nil from delete if a value for a key does not exist' do
-    moneta_property_of(keys: 1).check do |keys:|
-      store.delete(keys[0]).should be_nil
+    moneta_property_of(keys: 1).check do |m|
+      store.delete(m.keys[0]).should be_nil
     end
   end
 
   it 'removes all keys from the store with clear' do
-    moneta_property_of(keys: 2, values: 2).check do |keys:, values:|
-      store[keys[0]] = values[0]
-      store[keys[1]] = values[1]
+    moneta_property_of(keys: 2, values: 2).check do |m|
+      store[m.keys[0]] = m.values[0]
+      store[m.keys[1]] = m.values[1]
       store.clear.should equal(store)
-      store.key?(keys[0]).should be false
-      store.key?(keys[1]).should be false
+      store.key?(m.keys[0]).should be false
+      store.key?(m.keys[1]).should be false
     end
   end
 
   it 'fetches a key with a default value with fetch, if the key is not available' do
-    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
-      store.fetch(keys[0], values[0]).should == values[0]
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      store.fetch(m.keys[0], m.values[0]).should == m.values[0]
     end
   end
 
   it 'fetches a key with a block with fetch, if the key is not available' do
-    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
-      store.fetch(keys[0]) do |k|
-        k.should equal(keys[0])
-        values[0]
-      end.should equal(values[0])
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      store.fetch(m.keys[0]) do |k|
+        k.should equal(m.keys[0])
+        m.values[0]
+      end.should equal(m.values[0])
     end
   end
 
   it 'accepts frozen options' do
-    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
+    moneta_property_of(keys: 1, values: 1).check do |m|
       options = {option1: 1, options2: 2}
       options.freeze
       store.clear.should equal(store)
-      store.key?(keys[0], options).should be false
-      store.load(keys[0], options).should be_nil
-      store.fetch(keys[0], 42, options).should == 42
-      store.fetch(keys[0], options) { 42 }.should == 42
-      store.delete(keys[0], options).should be_nil
+      store.key?(m.keys[0], options).should be false
+      store.load(m.keys[0], options).should be_nil
+      store.fetch(m.keys[0], 42, options).should == 42
+      store.fetch(m.keys[0], options) { 42 }.should == 42
+      store.delete(m.keys[0], options).should be_nil
       store.clear(options).should equal(store)
-      store.store(keys[0], values[0], options).should == values[0]
+      store.store(m.keys[0], m.values[0], options).should == m.values[0]
     end
   end
 end

data/spec/features/persist.rb

@@ -1,12 +1,12 @@
 shared_examples :persist do
   it 'persists values' do
-    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
+    moneta_property_of(keys: 1, values: 1).check do |m|
       new_store.tap do |store|
-        store[keys[0]] = values[0]
+        store[m.keys[0]] = m.values[0]
         store.close
       end
       new_store.tap do |store|
-        store[keys[0]].should == values[0]
+        store[m.keys[0]].should == m.values[0]
         store.close
       end
     end

data/spec/features/returndifferent.rb

@@ -1,9 +1,9 @@
 shared_examples :returndifferent do
   it 'guarantees that a different value is retrieved' do
-    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
-      next if [TrueClass,FalseClass,NilClass,Numeric].any?(&values[0].method(:is_a?))
-      store[keys[0]] = values[0]
-      store[keys[0]].should_not be_equal(values[0])
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      next if [TrueClass,FalseClass,NilClass,Numeric].any?(&m.values[0].method(:is_a?))
+      store[m.keys[0]] = m.values[0]
+      store[m.keys[0]].should_not be_equal(m.values[0])
     end
   end
 end

data/spec/features/returnsame.rb

@@ -1,9 +1,9 @@
 shared_examples :returnsame do
   it 'guarantees that the same value is retrieved' do
-    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
-      next if [TrueClass,FalseClass,Numeric].any?(&values[0].method(:is_a?))
-      store[keys[0]] = values[0]
-      store[keys[0]].should be_equal(values[0])
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      next if [TrueClass, FalseClass, Numeric].any?(&m.values[0].method(:is_a?))
+      store[m.keys[0]] = m.values[0]
+      store[m.keys[0]].should be_equal(m.values[0])
     end
   end
 end