redis_hash 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14c0920d865fbe1f15499c0c50876cef5f72d179c49ad352ad61cae430722c06
-  data.tar.gz: cc78b095bd8043d381832900daad5ae60fcdf7b3ae0bdac2c354d604cca151e9
+  metadata.gz: d3131d41ea67e65aa544a9ebdb7da08c0b0611a0f1439715af115e8c33ff9c96
+  data.tar.gz: 3dc68b7eaf87c5730073d4f4eb71c64d7369220f9c334e7d89fe495a1b4538af
 SHA512:
-  metadata.gz: b092d1ca79de529e0e8ab93aa738c173d6719c1f01ffa2a5a35cd16376befa11fcbeaf2f4ea3b136c24d545fca2446b7464ef836cf4e0dacd679dcd4a3e047aa
-  data.tar.gz: 1e40e8fa91ee20f8c5160d0ac33b4a99e85c12e8ff758448240364e2339526afe3aee03964c943b80666cdf210cee3de23ff9436cad0fc5c65c1f1a572203251
+  metadata.gz: a636758a36b3167865640201ac84227360d441be44b441ea17586681ed7167145b31e3e0d497783ee770840de87c3ed9b6aea58c483da140d39581a6beb0e315
+  data.tar.gz: f8c94d4d75e2c9bbc17a658d66c898dfb863955360779e5480973f9f5dd810124a513e5fc9af56dc0194d819c4da3d45118e7d9d5809662992d4e3ba92b61473

data/lib/redis_hash.rb

@@ -2,8 +2,10 @@ require "active_support"
 
 require "redis"
 
-require "technologic"
-
 require "redis_hash/version"
 
-module RedisHash; end
+require "redis_hash/base"
+
+module RedisHash
+  class AlreadyDefinedError < StandardError; end
+end

data/lib/redis_hash/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "concerns/adapter"
+require_relative "concerns/default"
+require_relative "concerns/callbacks"
+require_relative "concerns/core"
+require_relative "concerns/identity"
+require_relative "concerns/accessors"
+require_relative "concerns/comparisons"
+require_relative "concerns/predicates"
+require_relative "concerns/insertions"
+require_relative "concerns/deletions"
+require_relative "concerns/enumerators"
+require_relative "concerns/mutations"
+require_relative "concerns/converters"
+require_relative "concerns/counters"
+require_relative "concerns/expiration"
+
+module RedisHash
+  class Base
+    include RedisHash::Adapter
+    include RedisHash::Default
+    include RedisHash::Callbacks
+    include RedisHash::Core
+    include RedisHash::Identity
+    include RedisHash::Accessors
+    include RedisHash::Comparisons
+    include RedisHash::Predicates
+    include RedisHash::Insertions
+    include RedisHash::Deletions
+    include RedisHash::Enumerators
+    include RedisHash::Mutations
+    include RedisHash::Converters
+    include RedisHash::Counters
+    include RedisHash::Expiration
+  end
+end

data/lib/redis_hash/concerns/accessors.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Accessors allow for the retrieval of data from the Hash.
+module RedisHash
+  module Accessors
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :hget, :hkeys, :hlen, :hmget, :hvals, to: :redis
+      delegate :assoc, :compact, :dig, :fetch_values, :flatten, :key, :rassoc, :rehash, to: :to_h
+    end
+
+    def [](field)
+      hget(redis_key, field) || default(field)
+    end
+
+    def fetch(field, default = nil)
+      value = self[field]
+      return value if value.present?
+      return yield(field) if block_given?
+      return default unless default.nil?
+
+      raise KeyError, "key not found: \"#{field}\""
+    end
+
+    def keys
+      hkeys(redis_key)
+    end
+
+    def length
+      hlen(redis_key)
+    end
+    alias_method :size, :length
+
+    def values
+      hvals(redis_key)
+    end
+
+    def values_at(*fields)
+      hmget(*fields.flatten.unshift(redis_key))
+    end
+  end
+end

data/lib/redis_hash/concerns/adapter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Adapter which handles the storage and retrieval of hash data in Redis.
+module RedisHash
+  module Adapter
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :redis, :redis_key, :redis_ttl
+
+      delegate :default_redis, :default_redis_key, :default_redis_ttl, to: :class
+
+      private
+
+      def initialize_redis(redis, redis_key, redis_ttl)
+        @redis = redis || default_redis
+        @redis_key = redis_key || default_redis_key
+        @redis_ttl = redis_ttl || default_redis_ttl
+      end
+    end
+
+    class_methods do
+      def default_redis
+        Redis.new
+      end
+
+      def default_redis_key
+        SecureRandom.hex
+      end
+
+      def default_redis_ttl
+        nil
+      end
+    end
+  end
+end

data/lib/redis_hash/concerns/callbacks.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Callbacks provide an extensible mechanism for hooking into a RedisHash.
+module RedisHash
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveSupport::Callbacks
+      define_callbacks :initialize, :insertion, :deletion
+    end
+  end
+end

data/lib/redis_hash/concerns/comparisons.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Comparisons encompasses equality and set inclusion.
+module RedisHash
+  module Comparisons
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :<, :<=, :>, :>=, :compare_by_identity, :compare_by_identity?, to: :to_h
+    end
+
+    def eql?(other)
+      other.hash == hash
+    end
+    alias_method :==, :eql?
+  end
+end

data/lib/redis_hash/concerns/converters.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Converters allow for other objects to be coerced into a RedisHash.
+module RedisHash
+  module Converters
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def [](*arguments)
+        options = block_given? ? yield({}) : {}
+        new(**options).merge!(Hash[*arguments])
+      end
+
+      def try_convert(object, &block)
+        return object if object.is_a?(RedisHash)
+
+        self[object, &block] if object.respond_to?(:to_hash)
+      end
+    end
+  end
+end

data/lib/redis_hash/concerns/core.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# A RedisHash is a wrapper around a h<key> stored in Redis.
+module RedisHash
+  module Core
+    extend ActiveSupport::Concern
+
+    def initialize(default = nil, redis: nil, redis_key: nil, redis_ttl: nil, &block)
+      run_callbacks(:initialize) do
+        initialize_default(default, &block)
+        initialize_redis(redis, redis_key, redis_ttl)
+      end
+    end
+  end
+end

data/lib/redis_hash/concerns/counters.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Counters allow for the incrementing and decrementing of numeric values into the RedisHash.
+module RedisHash
+  module Counters
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :hincrby, :hincrbyfloat, to: :redis
+
+      private
+
+      def increment_field_by(field, by, modifier: 1)
+        raise ArgumentError, "by must be greater than or equal to 0" if by < 0
+
+        by *= modifier
+
+        return hincrbyfloat(redis_key, field, by) if by.is_a?(Float)
+
+        hincrby(redis_key, field, by)
+      end
+    end
+
+    def increment(field, by: 1)
+      increment_field_by(field, by)
+    end
+
+    def decrement(field, by: 1)
+      increment_field_by(field, by, modifier: -1)
+    end
+  end
+end

data/lib/redis_hash/concerns/default.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# A Default allows a static or procedurally generated value to be returned on failed lookups.
+module RedisHash
+  module Default
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :default_proc
+
+      private
+
+      def initialize_default(default, &block)
+        raise ArgumentError, "cannot specify both block and static default" if block_given? && default.present?
+
+        set_default(default, &block)
+      end
+
+      def set_default(default, &block)
+        self.default = default if default.present?
+        self.default_proc = block if block_given?
+      end
+
+      def to_default(field = nil, allow_nil_field: true)
+        @default.presence || (default_proc&.call(self, field) if !field.nil? || allow_nil_field)
+      end
+
+      def validate_proc(proc)
+        raise TypeError, "wrong default_proc type #{proc.class.name} (expected Proc)" unless proc.is_a? Proc
+
+        validate_lambda_arity(proc.arity) if proc.lambda?
+      end
+
+      def validate_lambda_arity(arity)
+        raise TypeError, "default_proc takes two arguments (2 for #{arity})" if arity >= 0 && arity != 2
+      end
+    end
+
+    def default=(value)
+      @default = value
+      @default_proc = nil
+    end
+
+    def default_proc=(value)
+      validate_proc(value) unless value.nil?
+
+      @default = nil
+      @default_proc = value
+    end
+
+    def default(field = nil)
+      to_default(field, allow_nil_field: false)
+    end
+  end
+end

data/lib/redis_hash/concerns/deletions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Deletions allow for the removal of data from the Hash.
+module RedisHash
+  module Deletions
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :del, :hdel, to: :redis
+    end
+
+    def clear
+      del(redis_key) and {}
+    end
+
+    def delete(field)
+      run_callbacks(:deletion) do
+        value = self[field]
+        result = hdel(redis_key, field)
+        (result == 0 && block_given?) ? yield(field) : value
+      end
+    end
+
+    def shift
+      return to_default if empty?
+
+      field = keys.first
+      [ field, delete(field) ]
+    end
+  end
+end

data/lib/redis_hash/concerns/enumerators.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Enumerators allow for the traversal and manipulation of data in the Hash.
+module RedisHash
+  module Enumerators
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :each, :each_pair, :each_key, :each_value, :reject, :select, :transform_values, to: :to_h
+    end
+
+    def delete_if
+      return enum_for(__method__) unless block_given?
+
+      each { |field, value| delete(field) if yield(field, value) }
+
+      to_h
+    end
+
+    def keep_if
+      return enum_for(__method__) unless block_given?
+
+      delete_if { |field, value| !yield(field, value) }
+    end
+
+    def reject!(&block)
+      return enum_for(__method__) unless block_given?
+
+      original = to_h
+      delete_if(&block)
+      current = to_h
+
+      (original == current) ? nil : current
+    end
+
+    def select!
+      return enum_for(__method__) unless block_given?
+
+      reject! { |*arguments| !yield(*arguments) }
+    end
+
+    def transform_values!
+      return enum_for(__method__) unless block_given?
+
+      each { |field, value| store(field, yield(value)) }
+
+      to_h
+    end
+  end
+end

data/lib/redis_hash/concerns/expiration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Expiration ensures that volatile hashes are properly configured to expire in Redis.
+module RedisHash
+  module Expiration
+    extend ActiveSupport::Concern
+
+    included do
+      set_callback :insertion, :before, :before_insertion
+      set_callback :insertion, :after, :after_insertion
+
+      private
+
+      attr_writer :was_empty_before_insertion
+
+      def before_insertion
+        self.was_empty_before_insertion = empty?
+      end
+
+      def after_insertion
+        expire(redis_ttl) if redis_ttl.present? && empty_before_insertion?
+      end
+    end
+
+    def empty_before_insertion?
+      @was_empty_before_insertion.present?
+    end
+
+    def expire(seconds)
+      redis.expire(redis_key, seconds)
+    end
+
+    def ttl
+      redis.ttl(redis_key)
+    end
+  end
+end

data/lib/redis_hash/concerns/identity.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Identity relates to the specific object instance.
+module RedisHash
+  module Identity
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :hgetall, to: :redis
+      delegate :inspect, :to_proc, :to_s, to: :to_h
+    end
+
+    def hash
+      { redis_id: redis.id, redis_key: redis_key }.hash
+    end
+
+    def to_hash
+      to_h
+    end
+
+    def to_h
+      hgetall(redis_key)
+    end
+  end
+end

data/lib/redis_hash/concerns/insertions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Insertions allow for the addition of data into the RedisHash.
+module RedisHash
+  module Insertions
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :hmset, :hset, :hsetnx, to: :redis
+      delegate :merge, to: :to_h
+    end
+
+    def merge!(other_hash)
+      run_callbacks(:insertion) { hmset(*other_hash.to_a.unshift(redis_key)) }
+
+      self
+    end
+    alias_method :update, :merge!
+
+    def store(field, value)
+      run_callbacks(:insertion) { hset(redis_key, field, value) }
+    end
+    alias_method :[]=, :store
+
+    def setnx!(field, value)
+      run_callbacks(:insertion) do
+        success = hsetnx(redis_key, field, value)
+
+        raise RedisHash::AlreadyDefinedError, "#{field} already defined" unless success
+      end
+
+      true
+    end
+
+    def setnx(field, value)
+      setnx!(field, value)
+    rescue RedisHash::AlreadyDefinedError
+      false
+    end
+  end
+end

data/lib/redis_hash/concerns/mutations.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Mutations allow for the manipulation of data in the Hash.
+module RedisHash
+  module Mutations
+    extend ActiveSupport::Concern
+
+    def compact!
+      delete_if { |_, value| value.blank? }
+    end
+
+    def invert
+      inversion = to_h.invert
+      clear
+      inversion.each { |key, value| self[key] = value }
+    end
+
+    def replace(other_hash)
+      clear and merge!(other_hash)
+    end
+  end
+end

data/lib/redis_hash/concerns/predicates.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Predicates enable querying the Hash for data.
+module RedisHash
+  module Predicates
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :hexists, to: :redis
+    end
+
+    def any?(&block)
+      return length > 0 unless block_given?
+
+      to_h.any?(&block)
+    end
+
+    def empty?
+      length == 0
+    end
+
+    def include?(field)
+      hexists(redis_key, field)
+    end
+    alias_method :has_key?, :include?
+    alias_method :key?, :include?
+    alias_method :member?, :include?
+
+    def value?(value)
+      values.include? value
+    end
+    alias_method :has_value?, :value?
+  end
+end

data/lib/redis_hash/version.rb

@@ -1,4 +1,4 @@
 module RedisHash
   # This constant is managed by spicerack
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_hash
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Eric Garside
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.2.1
-- !ruby/object:Gem::Dependency
-  name: technologic
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.9.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -63,6 +49,22 @@ files:
 - LICENSE.txt
 - README.md
 - lib/redis_hash.rb
+- lib/redis_hash/base.rb
+- lib/redis_hash/concerns/accessors.rb
+- lib/redis_hash/concerns/adapter.rb
+- lib/redis_hash/concerns/callbacks.rb
+- lib/redis_hash/concerns/comparisons.rb
+- lib/redis_hash/concerns/converters.rb
+- lib/redis_hash/concerns/core.rb
+- lib/redis_hash/concerns/counters.rb
+- lib/redis_hash/concerns/default.rb
+- lib/redis_hash/concerns/deletions.rb
+- lib/redis_hash/concerns/enumerators.rb
+- lib/redis_hash/concerns/expiration.rb
+- lib/redis_hash/concerns/identity.rb
+- lib/redis_hash/concerns/insertions.rb
+- lib/redis_hash/concerns/mutations.rb
+- lib/redis_hash/concerns/predicates.rb
 - lib/redis_hash/version.rb
 homepage: https://github.com/Freshly/spicerack/tree/master/redis_hash
 licenses: