moneta 1.0.0 → 1.5.1

data/lib/moneta/adapters/file.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'English'
 
 module Moneta
   module Adapters
@@ -6,14 +7,18 @@ module Moneta
     # @api public
     class File
       include Defaults
-      supports :create, :increment
+      include Config
+
+      supports :create, :increment, :each_key
+
+      config :dir, required: true
 
       # @param [Hash] options
       # @option options [String] :dir Directory where files will be stored
       def initialize(options = {})
-        raise ArgumentError, 'Option :dir is required' unless @dir = options[:dir]
-        FileUtils.mkpath(@dir)
-        raise "#{@dir} is not a directory" unless ::File.directory?(@dir)
+        configure(**options)
+        FileUtils.mkpath(config.dir)
+        raise "#{config.dir} is not a directory" unless ::File.directory?(config.dir)
       end
 
       # (see Proxy#key?)
@@ -21,21 +26,36 @@ module Moneta
         ::File.exist?(store_path(key))
       end
 
+      # (see Proxy#each_key)
+      def each_key(&block)
+        entries = ::Dir.entries(config.dir).reject do |k|
+          ::File.directory?(::File.join(config.dir, k))
+        end
+
+        if block_given?
+          entries.each { |k| yield(k) }
+          self
+        else
+          enum_for(:each_key) { ::Dir.entries(config.dir).length - 2 }
+        end
+      end
+
       # (see Proxy#load)
       def load(key, options = {})
         ::File.read(store_path(key), mode: 'rb')
       rescue Errno::ENOENT
+        nil
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        temp_file = ::File.join(@dir, "value-#{$$}-#{Thread.current.object_id}")
+        temp_file = ::File.join(config.dir, "value-#{$PROCESS_ID}-#{Thread.current.object_id}")
         path = store_path(key)
         FileUtils.mkpath(::File.dirname(path))
-        ::File.open(temp_file, 'wb') {|f| f.write(value) }
+        ::File.open(temp_file, 'wb') { |f| f.write(value) }
         ::File.rename(temp_file, path)
         value
-      rescue Exception
+      rescue
         File.unlink(temp_file) rescue nil
         raise
       end
@@ -46,13 +66,14 @@ module Moneta
         ::File.unlink(store_path(key))
         value
       rescue Errno::ENOENT
+        nil
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        temp_dir = "#{@dir}-#{$$}-#{Thread.current.object_id}"
-        ::File.rename(@dir, temp_dir)
-        FileUtils.mkpath(@dir)
+        temp_dir = "#{config.dir}-#{$PROCESS_ID}-#{Thread.current.object_id}"
+        ::File.rename(config.dir, temp_dir)
+        FileUtils.mkpath(config.dir)
         self
       rescue Errno::ENOENT
         self
@@ -67,7 +88,7 @@ module Moneta
         ::File.open(path, ::File::RDWR | ::File::CREAT) do |f|
           Thread.pass until f.flock(::File::LOCK_EX)
           content = f.read
-          amount += Utils.to_int(content) unless content.empty?
+          amount += Integer(content) unless content.empty?
           content = amount.to_s
           f.binmode
           f.pos = 0
@@ -86,7 +107,7 @@ module Moneta
           FileUtils.mkpath(::File.dirname(path))
           # Call native java.io.File#createNewFile
           return false unless ::Java::JavaIo::File.new(path).createNewFile
-          ::File.open(path, 'wb+') {|f| f.write(value) }
+          ::File.open(path, 'wb+') { |f| f.write(value) }
           true
         end
       else
@@ -107,7 +128,7 @@ module Moneta
       protected
 
       def store_path(key)
-        ::File.join(@dir, key)
+        ::File.join(config.dir, key)
       end
     end
   end

data/lib/moneta/adapters/fog.rb

@@ -4,19 +4,18 @@ module Moneta
   module Adapters
     # Fog backend (Cloud storage services)
     # @api public
-    class Fog
-      include Defaults
+    class Fog < Adapter
+      config :dir, required: true
 
-      attr_reader :backend
+      backend { |**options| ::Fog::Storage.new(options) }
 
       # @param [Hash] options
       # @option options [String] :dir Fog directory
       # @option options [::Fog::Storage] :backend Use existing backend instance
       # @option options Other options passed to `Fog::Storage#new`
       def initialize(options = {})
-        raise ArgumentError, 'Option :dir is required' unless dir = options.delete(:dir)
-        @backend = options[:backend] || ::Fog::Storage.new(options)
-        @directory = @backend.directories.get(dir) || @backend.directories.create(key: dir)
+        super
+        @directory = backend.directories.get(config.dir) || backend.directories.create(key: config.dir)
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/gdbm.rb

@@ -4,23 +4,17 @@ module Moneta
   module Adapters
     # GDBM backend
     # @api public
-    class GDBM < Memory
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::GDBM] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::GDBM.new(options[:file])
-          end
-      end
+    class GDBM < Adapter
+      include DBMAdapter
+      include IncrementSupport
+      include CreateSupport
+      include EachKeySupport
 
-      # (see Proxy#close)
-      def close
-        @backend.close
-        nil
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::GDBM] :backend Use existing backend instance
+      backend { |file:| ::GDBM.new(file) }
     end
   end
 end

data/lib/moneta/adapters/hbase.rb

@@ -4,10 +4,12 @@ module Moneta
   module Adapters
     # HBase thrift backend
     # @api public
-    class HBase
-      include Defaults
+    class HBase < Adapter
+      config :column, 'value'
+      config :table, 'moneta'
+      config :column_family, 'moneta'
 
-      attr_reader :backend
+      backend { |host: '127.0.0.1', port: 9090| HBaseRb::Client.new(host, port) }
 
       # TODO: Add create support using checkAndPut if added to thrift api
       # https://issues.apache.org/jira/browse/HBASE-3307
@@ -22,14 +24,10 @@ module Moneta
       # @option options [String] :column ('value') Column
       # @option options [::HBaseRb::Client] :backend Use existing backend instance
       def initialize(options = {})
-        options[:column] ||= 'value'
-        options[:table] ||= 'moneta'
-        cf = (options[:column_family] || 'moneta')
-        @column = "#{cf}:#{options[:column]}"
-        @backend = options[:backend] ||
-          HBaseRb::Client.new(options[:host] || '127.0.0.1', options[:port] || '9090')
-        @backend.create_table(options[:table], cf) unless @backend.has_table?(options[:table])
-        @table = @backend.get_table(options[:table])
+        super
+        @column = [config.column_family, config.column].join(':')
+        backend.create_table(config.table, config.column_family) unless backend.has_table?(config.table)
+        @table = backend.get_table(config.table)
       end
 
       # (see Proxy#key?)
@@ -53,7 +51,7 @@ module Moneta
       def increment(key, amount = 1, options = {})
         result = @table.atomic_increment(key, @column, amount)
         # HACK: Throw error if applied to invalid value
-        Utils.to_int(load(key)) if result == 0
+        Integer(load(key)) if result == 0
         result
       end
 
@@ -75,7 +73,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
 

data/lib/moneta/adapters/kyotocabinet.rb

@@ -4,41 +4,102 @@ module Moneta
   module Adapters
     # KyotoCabinet backend
     # @api public
-    class KyotoCabinet < Memory
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::KyotoCabinet::DB] :backend Use existing backend instance
-      def initialize(options = {})
-        if options[:backend]
-          @backend = options[:backend]
-        else
-          raise ArgumentError, 'Option :file is required' unless options[:file]
-          @backend = ::KyotoCabinet::DB.new
-          raise @backend.error.to_s unless @backend.open(options[:file],
-                                                         ::KyotoCabinet::DB::OWRITER | ::KyotoCabinet::DB::OCREATE)
-        end
+    class KyotoCabinet < Adapter
+      include HashAdapter
+
+      supports :each_key, :increment, :create
+
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::KyotoCabinet::DB] :backend Use existing backend instance
+      backend do |file:|
+        backend = ::KyotoCabinet::DB.new
+        raise backend.error.to_s unless backend.open(file, ::KyotoCabinet::DB::OWRITER | ::KyotoCabinet::DB::OCREATE)
+        backend
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @backend.check(key) >= 0
+        backend.check(key) >= 0
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @backend.seize(key)
+        backend.seize(key)
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @backend.add(key, value)
+        backend.add(key, value)
       end
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
+
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) { backend.count } unless block_given?
+        backend.each_key { |arr| yield arr[0] }
+        self
+      end
+
+      # (see Proxy#increment)
+      def increment(key, amount = 1, options = {})
+        ret = nil
+        success = backend.accept(key) do |_, value|
+          ret =
+            if value
+              Integer(value) + amount
+            else
+              amount
+            end
+          ret.to_s
+        end
+
+        raise backend.error unless success
+        ret
+      end
+
+      # (see Proxy#slice)
+      def slice(*keys, atomic: true, **options)
+        backend.get_bulk(keys, atomic)
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = slice(*keys, **options)
+        keys.map { |key| hash[key] }
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        hard = options.key?(:hard) ? options[:hard] : false
+        atomic = options.key?(:atomic) ? options[:atomic] : true
+
+        success =
+          if block_given?
+            backend.transaction(hard) do
+              existing = slice(*pairs.map { |k, _| k }, **options)
+              pairs = pairs.map do |key, new_value|
+                if existing.key?(key)
+                  [key, yield(key, existing[key], new_value)]
+                else
+                  [key, new_value]
+                end
+              end
+              backend.set_bulk(pairs.to_h, atomic) >= 0
+            end
+          else
+            backend.set_bulk(pairs.to_h, atomic) >= 0
+          end
+
+        raise backend.error unless success
+        self
+      end
     end
   end
 end

data/lib/moneta/adapters/leveldb.rb

@@ -4,35 +4,55 @@ module Moneta
   module Adapters
     # LevelDB backend
     # @api public
-    class LevelDB < Memory
-      # @param [Hash] options
-      # @option options [String] :dir - Database path
-      # @option options All other options passed to `LevelDB::DB#new`
-      # @option options [::LevelDB::DB] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :dir is required' unless options[:dir]
-            ::LevelDB::DB.new(options[:dir])
-          end
-      end
+    class LevelDB < Adapter
+      include HashAdapter
+      include IncrementSupport
+      include CreateSupport
+      include EachKeySupport
+
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :dir - Database path
+      #   @option options All other options passed to `LevelDB::DB#new`
+      #   @option options [::LevelDB::DB] :backend Use existing backend instance
+      backend { |dir:| ::LevelDB::DB.new(dir) }
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @backend.includes?(key)
+        backend.includes?(key)
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @backend.each {|k,v| delete(k, options) }
+        backend.each { |k,| delete(k, options) }
         self
       end
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
+
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) { backend.size } unless block_given?
+        backend.each { |key, _| yield key }
+        self
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        ret = nil
+        backend.batch { ret = super }
+        ret
+      end
+
+      # (see Proxy#merge!)
+      def merge!(*keys, **options)
+        backend.batch { super }
+        self
+      end
     end
   end
 end

data/lib/moneta/adapters/lmdb.rb

@@ -5,33 +5,30 @@ module Moneta
   module Adapters
     # LMDB backend
     # @api public
-    class LMDB
-      include Defaults
+    class LMDB < Adapter
+      supports :create, :increment, :each_key
 
-      supports :create, :increment
-      attr_reader :backend, :db
+      PUT_FLAGS = %i[nooverwrite nodupdata current append appenddup].freeze
 
-      PUT_FLAGS = [:nooverwrite, :nodupdata, :current, :append, :appenddup]
+      config :db, default: 'moneta'
+
+      backend do |dir:, **options|
+        FileUtils.mkpath(dir)
+        ::LMDB.new(dir, options)
+      end
 
       # @param [Hash] options
       # @option options [String] :dir Environment directory
       # @option options [::LMDB::Environment] :backend Use existing backend instance
-      # @option options [String or nil] :db Database name
-      def initialize(options)
-        db = options.delete(:db)
-        @backend = options.delete(:backend) ||
-          begin
-            raise ArgumentError, 'Option :dir is required' unless dir = options.delete(:dir)
-            FileUtils.mkpath(dir)
-            ::LMDB.new(dir, options)
-          end
-
-        @db = @backend.database(db, create: true)
+      # @option options [String or nil] :db ('moneta') Database name
+      def initialize(options = {})
+        super
+        @db = backend.database(config.db, create: true)
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        !@db.get(key).nil?
+        @db.get(key) != nil
       end
 
       # (see Proxy#load)
@@ -47,7 +44,7 @@ module Moneta
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @backend.transaction do
+        backend.transaction do
           if value = @db.get(key)
             @db.delete(key)
             value
@@ -63,9 +60,8 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.transaction do
-          value = @db.get(key)
-          value = Utils.to_int(value) + amount
+        backend.transaction do
+          value = Integer(@db.get(key) || 0) + amount
           @db.put(key, value.to_s, Utils.only(options, *PUT_FLAGS))
           value
         end
@@ -73,7 +69,7 @@ module Moneta
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        @backend.transaction do
+        backend.transaction do
           if @db.get(key)
             false
           else
@@ -85,9 +81,37 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
+
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) { @db.size } unless block_given?
+
+        @db.cursor do |cursor|
+          while record = cursor.next
+            yield record[0]
+          end
+        end
+
+        self
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        backend.transaction { super }
+      end
+
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        backend.transaction { super }
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        backend.transaction { super }
+      end
     end
   end
 end

data/lib/moneta/adapters/localmemcache.rb

@@ -4,25 +4,19 @@ module Moneta
   module Adapters
     # LocalMemCache backend
     # @api public
-    class LocalMemCache
-      include Defaults
+    class LocalMemCache < Adapter
       include HashAdapter
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::LocalMemCache] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::LocalMemCache.new(filename: options[:file])
-          end
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::LocalMemCache] :backend Use existing backend instance
+      backend { |file:| ::LocalMemCache.new(filename: file) }
 
       # (see Proxy#delete)
       def delete(key, options = {})
         value = load(key, options)
-        @backend.delete(key)
+        backend.delete(key)
         value
       end
     end