moneta 1.4.2 → 1.5.0

data/lib/moneta/config.rb

@@ -0,0 +1,101 @@
+require 'set'
+
+module Moneta
+  # Some docs here
+  module Config
+    # @api private
+    module ClassMethods
+      def config(name, coerce: nil, default: nil, required: false, &block)
+        raise ArgumentError, 'name must be a symbol' unless Symbol === name
+
+        defaults = config_defaults
+
+        raise ArgumentError, "#{name} is already a config option" if defaults.key?(name)
+        raise ArgumentError, "coerce must respond to :to_proc" if coerce && !coerce.respond_to?(:to_proc)
+
+        defaults.merge!(name => default.freeze).freeze
+        instance_variable_set :@config_defaults, defaults
+
+        instance_variable_set :@config_coercions, config_coercions.merge!(name => coerce.to_proc) if coerce
+        instance_variable_set :@config_required_keys, config_required_keys.add(name).freeze if required
+        instance_variable_set :@config_blocks, config_blocks.merge!(name => block) if block
+      end
+
+      def config_variable(name)
+        if instance_variable_defined?(name)
+          instance_variable_get(name).dup
+        elsif superclass.respond_to?(:config_variable)
+          superclass.config_variable(name)
+        end
+      end
+
+      def config_defaults
+        config_variable(:@config_defaults) || {}
+      end
+
+      def config_required_keys
+        config_variable(:@config_required_keys) || Set.new
+      end
+
+      def config_coercions
+        config_variable(:@config_coercions) || {}
+      end
+
+      def config_blocks
+        config_variable(:@config_blocks) || {}
+      end
+
+      def config_struct
+        unless @config_struct
+          keys = config_defaults.keys
+          @config_struct = Struct.new(*keys) unless keys.empty?
+        end
+
+        @config_struct
+      end
+    end
+
+    def config
+      raise "Not configured" unless defined?(@config)
+      @config
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    protected
+
+    def configure(**options)
+      raise 'Already configured' if defined?(@config)
+
+      self.class.config_required_keys.each do |key|
+        raise ArgumentError, "#{key} is required" unless options.key? key
+      end
+
+      defaults = self.class.config_defaults
+
+      overrides, remainder = options
+        .partition { |key,| defaults.key? key }
+        .map { |pairs| pairs.to_h }
+
+      self.class.config_coercions.each do |key, coerce|
+        overrides[key] = coerce.call(overrides[key]) if overrides.key?(key)
+      end
+
+      overridden = defaults.merge!(overrides)
+
+      config_blocks = self.class.config_blocks
+      values = overridden.map do |key, value|
+        if config_block = config_blocks[key]
+          instance_exec(**overridden, &config_block)
+        else
+          value
+        end
+      end
+
+      @config = self.class.config_struct&.new(*values).freeze
+      remainder
+    end
+  end
+end

data/lib/moneta/expires.rb

@@ -14,7 +14,6 @@ module Moneta
     def initialize(adapter, options = {})
       raise 'Store already supports feature :expires' if adapter.supports?(:expires)
       super
-      self.default_expires = options[:expires]
     end
 
     # (see Proxy#key?)

data/lib/moneta/expires_support.rb

@@ -3,8 +3,6 @@ module Moneta
   #
   #
   module ExpiresSupport
-    attr_accessor :default_expires
-
     protected
 
     # Calculates the time when something will expire.
@@ -19,7 +17,7 @@ module Moneta
     # @return [false] if it should not expire
     # @return [Time] the time when something should expire
     # @return [nil] if it is not known
-    def expires_at(options, default = @default_expires)
+    def expires_at(options, default = config.expires)
       value = expires_value(options, default)
       Numeric === value ? Time.now + value : value
     end
@@ -36,7 +34,7 @@ module Moneta
     # @return [false] if it should not expire
     # @return [Numeric] seconds until expiration
     # @return [nil] if it is not known
-    def expires_value(options, default = @default_expires)
+    def expires_value(options, default = config.expires)
       case value = options[:expires]
       when 0, false
         false
@@ -54,6 +52,7 @@ module Moneta
     class << self
       def included(base)
         base.supports(:expires) if base.respond_to?(:supports)
+        base.config :expires
       end
     end
   end

data/lib/moneta/pool.rb

@@ -309,9 +309,9 @@ module Moneta
     #   store to become available.  If not specified, will wait forever.
     # @yield A builder context for speciying how to construct stores
     def initialize(options = {}, &block)
-      super(nil)
       @id = "Moneta::Pool(#{object_id})"
       @manager = PoolManager.new(Builder.new(&block), **options)
+      super(nil, options)
     end
 
     # Closing has no effect on the pool, as stores are closed in the background

data/lib/moneta/proxy.rb

@@ -3,6 +3,7 @@ module Moneta
   # @api public
   class Proxy
     include Defaults
+    include Config
 
     attr_reader :adapter
 
@@ -10,6 +11,7 @@ module Moneta
     # @param [Hash] options
     def initialize(adapter, options = {})
       @adapter = adapter
+      configure(**options)
     end
 
     # (see Defaults#key?)
@@ -133,5 +135,32 @@ module Moneta
         super
       end
     end
+
+    # Overrides the default implementation of the config method to:
+    #
+    # * pass the adapter's config, if this proxy has no configuration of its
+    #   own
+    # * return a merged configuration, allowing the proxy have precedence over
+    #   the adapter
+    def config
+      unless @proxy_config
+        config = super
+        adapter_config = adapter&.config
+
+        @proxy_config =
+          if config && adapter_config
+            adapter_members = adapter_config.members - config.members
+            members = config.members + adapter_members
+            struct = Struct.new(*members)
+
+            values = config.values + adapter_config.to_h.values_at(*adapter_members)
+            struct.new(*values)
+          else
+            config || adapter_config
+          end
+      end
+
+      @proxy_config
+    end
   end
 end

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.2'.freeze
+  VERSION = '1.5.0'.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/moneta/adapters/client/client_helper.rb

@@ -12,13 +12,14 @@ RSpec.shared_context :start_server do |**options|
       puts "Failed to start server - #{ex.message}"
       tries ||= 0
       tries += 1
-      sleep Moneta::Server::TIMEOUT
+      timeout = options[:timeout] || Moneta::Server.config_defaults[:timeout]
+      sleep 1
       tries < 3 ? retry : raise
     end
   end
 
   after :context do
-    @server.stop
-    @thread.join
+    @server&.stop
+    @thread&.join
   end
 end

data/spec/moneta/adapters/faraday_helper.rb

@@ -1,9 +1,10 @@
 RSpec.shared_context :faraday_adapter do
   before :context do
-    require 'faraday/adapter/manticore' if defined?(JRUBY_VERSION)
+    #require 'faraday/adapter/manticore' if defined?(JRUBY_VERSION)
   end
 
   let(:faraday_adapter) do
-    defined?(JRUBY_VERSION) ? :manticore : :net_http
+    #defined?(JRUBY_VERSION) ? :manticore : :net_http
+    :net_http
   end
 end

data/spec/moneta/adapters/lruhash/adapter_lruhash_spec.rb

@@ -52,8 +52,10 @@ describe 'adapter_lruhash', adapter: :LRUHash do
 
   it 'adds a value that is as large as the default max_size when max_size is missing' do
     store = Moneta::Adapters::LRUHash.new
+    expect(store.config.max_size).to eq Moneta::Adapters::LRUHash.config_defaults[:max_size]
+
     large_item = 'Really big'
-    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE)
+    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash.config_defaults[:max_size])
     store[:really_big] = large_item
     store[:really_big].should eq(large_item)
   end
@@ -61,7 +63,7 @@ describe 'adapter_lruhash', adapter: :LRUHash do
   it 'does not add values that are larger than the default max_size when max_size is missing' do
     store = Moneta::Adapters::LRUHash.new
     large_item = 'Really big'
-    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE + 1)
+    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash.config_defaults[:max_size] + 1)
     store[:really_big] = large_item
     store[:really_big].should be_nil
   end
@@ -69,7 +71,7 @@ describe 'adapter_lruhash', adapter: :LRUHash do
   it 'adds values that are larger than the default max_size when max_size is nil' do
     store = Moneta::Adapters::LRUHash.new(max_size: nil)
     large_item = 'Really big'
-    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE + 1)
+    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash.config_defaults[:max_size] + 1)
     store[:really_big] = large_item
     store[:really_big].should eq(large_item)
   end
@@ -94,7 +96,8 @@ describe 'adapter_lruhash', adapter: :LRUHash do
   end
 
   it 'only allows the default number of items when max_count is missing' do
-    stub_const('Moneta::Adapters::LRUHash::DEFAULT_MAX_COUNT', 5)
+    defaults = Moneta::Adapters::LRUHash.config_defaults
+    allow(Moneta::Adapters::LRUHash).to receive(:config_defaults).and_return(defaults.merge(max_count: 5))
     store = Moneta::Adapters::LRUHash.new(max_value: nil, max_size: nil)
     (1..6).each { |n| store[n] = n }
     store.key?(1).should be false
@@ -103,8 +106,9 @@ describe 'adapter_lruhash', adapter: :LRUHash do
     store[6].should eq(6)
   end
 
-  it 'adds more values than DEFAULT_MAX_COUNT allows when max_count is nil' do
-    stub_const('Moneta::Adapters::LRUHash::DEFAULT_MAX_COUNT', 5)
+  it 'adds more values than the default max_count allows when max_count is nil' do
+    defaults = Moneta::Adapters::LRUHash.config_defaults
+    allow(Moneta::Adapters::LRUHash).to receive(:config_defaults).and_return(defaults.merge(max_count: 5))
     store = Moneta::Adapters::LRUHash.new(max_count: nil, max_value: nil, max_size: nil)
     (1..6).each { |n| store[n] = n }
     store[1].should eq(1)

data/spec/moneta/adapters/mongo/adapter_mongo_spec.rb

@@ -28,7 +28,7 @@ describe 'adapter_mongo', adapter: :Mongo do
   end
 
   it 'uses the database specified via the :database option' do
-    expect(store.backend.database.name).to eq database
+    expect(store.config.database).to eq database
   end
 
   it 'uses the database specified via the :db option' do
@@ -36,6 +36,6 @@ describe 'adapter_mongo', adapter: :Mongo do
       db: database,
       collection: 'adapter_mongo'
     )
-    expect(store.backend.database.name).to eq database
+    expect(store.config.database).to eq database
   end
 end

data/spec/moneta/config_spec.rb

@@ -0,0 +1,219 @@
+describe Moneta::Config do
+  describe 'without any configuration' do
+    it 'does not set the config attribute' do
+      klass = Class.new do
+        include ::Moneta::Config
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+
+      instance = klass.new(k: 'v')
+      expect(instance.config).to be nil
+    end
+  end
+
+  describe 'basic functionality' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a
+        config :b
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+    end
+
+    it 'sets all config values to nil by default' do
+      instance = klass.new
+      expect(instance.config.a).to eq nil
+      expect(instance.config.b).to be nil
+    end
+
+    it 'sets config values with values provided to #configure' do
+      instance = klass.new(a: 1)
+      expect(instance.config.a).to eq 1
+      expect(instance.config.b).to be nil
+    end
+
+    it 'freezes the config' do
+      instance = klass.new
+      expect(instance.config.frozen?).to be true
+    end
+  end
+
+  describe 'with required arguments' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a, required: true
+        config :b, default: 'x', required: true
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+    end
+
+    it 'raises an ArgumentError if #configure is called without one of the required arguments' do
+      expect { klass.new(a: 1) }.to raise_error ArgumentError, 'b is required'
+      expect { klass.new(b: 1) }.to raise_error ArgumentError, 'a is required'
+    end
+  end
+
+  describe 'with defaults' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a, default: 't'
+        config :b, default: 's'
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+    end
+
+    it 'uses the defaults if no argument is provided' do
+      instance = klass.new(a: 1)
+
+      expect(instance.config.a).to eq 1
+      expect(instance.config.b).to eq 's'
+    end
+
+    it 'allows falsy values to override truthy defaults' do
+      instance = klass.new(a: nil, b: false)
+
+      expect(instance.config.a).to be nil
+      expect(instance.config.b).to be false
+    end
+  end
+
+  describe 'with coercion' do
+    describe 'using a symbol' do
+      subject :klass do
+        Class.new do
+          include ::Moneta::Config
+
+          config :a, coerce: :to_s
+
+          def initialize(**options)
+            configure(**options)
+          end
+        end
+      end
+
+      it "uses the symbol's to_proc property" do
+        instance = klass.new(a: :x)
+        expect(instance.config.a).to eq 'x'
+      end
+    end
+
+    describe 'using a lambda' do
+      subject :klass do
+        Class.new do
+          include ::Moneta::Config
+
+          config :a, coerce: lambda { |a| a.to_sym }
+
+          def initialize(**options)
+            configure(**options)
+          end
+        end
+      end
+
+      it "calls the lambda" do
+        instance = klass.new(a: 'x')
+        expect(instance.config.a).to eq :x
+      end
+    end
+  end
+
+  describe 'with a block' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a do |a:, b:|
+          { a: a, b: b, test: @test }
+        end
+
+        config :b, default: 'b default'
+
+        def initialize(test: nil, **options)
+          @test = test
+          configure(**options)
+        end
+      end
+    end
+
+    it 'calls the block after all arguments and defaults have been processed' do
+      instance1 = klass.new(a: 'a value')
+      expect(instance1.config.a).to include(a: 'a value', b: 'b default')
+
+      instance2 = klass.new(b: 'b value')
+      expect(instance2.config.a).to include(a: nil, b: 'b value')
+    end
+
+    it 'calls the block using instance_exec' do
+      instance = klass.new(test: 'test value')
+      expect(instance.config.a).to include(test: 'test value')
+    end
+  end
+
+  describe 'with inheritance' do
+    subject :klass do
+      Class.new do
+        include ::Moneta::Config
+
+        config :a
+
+        def initialize(**options)
+          configure(**options)
+        end
+      end
+    end
+
+    it 'does not allow subclasses to override superclass config' do
+      expect do
+        Class.new(klass) do
+          config :a
+        end
+      end.to raise_error ArgumentError, 'a is already a config option'
+    end
+
+    it 'does not affect the superclass when additional config is added to the subclass' do
+      klass2 = Class.new(klass) do
+        config :b
+      end
+
+      instance1 = klass.new(a: 1, b: 2)
+      expect(instance1.config.to_h).to eq(a: 1)
+
+      instance2 = klass2.new(a: 1, b: 2)
+      expect(instance2.config.to_h).to eq(a: 1, b: 2)
+    end
+
+    it 'is possible for two subclasses to have the same additional config' do
+      klass2 = Class.new(klass) do
+        config :b
+      end
+
+      klass3 = Class.new(klass) do
+        config :b
+      end
+
+      instance2 = klass2.new(a: 2, b: 1)
+      expect(instance2.config.to_h).to eq(a: 2, b: 1)
+
+      instance3 = klass3.new(a: 1, b: 2)
+      expect(instance3.config.to_h).to eq(a: 1, b: 2)
+    end
+  end
+end

data/spec/moneta/proxies/transformer/transformer_bson_spec.rb

@@ -1,4 +1,6 @@
-describe 'transformer_bson', proxy: :Transformer do
+# Currently broken in JRuby 9.3 - see https://github.com/jruby/jruby/issues/6941
+
+describe 'transformer_bson', proxy: :Transformer, broken: defined?(JRUBY_VERSION) && ::Gem::Version.new(JRUBY_VERSION) >= ::Gem::Version.new('9.3.0.0') do
   moneta_build do
     Moneta.build do
       use :Transformer, key: :bson, value: :bson

data/spec/moneta/proxies/transformer/transformer_marshal_escape_spec.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 describe 'transformer_marshal_escape', proxy: :Transformer do
   moneta_build do
     Moneta.build do