conflow 0.1.0

data/lib/conflow/redis/findable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Conflow
+  module Redis
+    # Findable module allows to use .find method on models with identifiers. It requires additional field: :type
+    module Findable
+      def self.included(base)
+        base.extend ClassMethods
+        base.field :type, :value
+      end
+
+      def initialize(*args)
+        super
+        self.type = self.class.name
+      end
+
+      # Adds .find method which accepts ID and returns model of proper (sub)type
+      module ClassMethods
+        def find(id)
+          class_name = ValueField.new(format(key_template + ":type", id: id)).value
+          raise ::Redis::CommandError, "#{name} with ID #{id} doesn't exist" unless class_name
+
+          Object.const_get(class_name).new(id)
+        end
+      end
+    end
+  end
+end

data/lib/conflow/redis/hash_field.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Conflow
+  module Redis
+    # Represents Redis hash. It's methods mirror most used Hash methods.
+    class HashField < Field
+      include Enumerable
+
+      def [](field)
+        value = command(:hget, [key, field])
+        value ? JSON.parse(value) : value
+      end
+
+      def []=(field, value)
+        command :hset, [key, field, JSON.dump(value)]
+      end
+
+      def merge(hash)
+        command :hmset, [key, hash.flatten]
+      end
+
+      def delete(*fields)
+        command :hdel, [key, fields]
+      end
+
+      def overwrite(new_hash)
+        redis.with do |conn|
+          conn.pipelined do
+            conn.del(key)
+            conn.hmset(key, prepare_hash(new_hash).flatten)
+          end
+        end
+      end
+
+      def keys
+        command(:hkeys, [key]).map(&:to_sym)
+      end
+
+      def size
+        command :hlen, [key]
+      end
+
+      def to_h
+        command(:hgetall, [key]).each_with_object({}) do |(key, value), hash|
+          hash[key.to_sym] = JSON.parse(value)
+        end
+      end; alias to_hash to_h
+
+      def each(&block)
+        to_h.each(&block)
+      end
+
+      def ==(other)
+        case other
+        when Hash      then to_h == other
+        when HashField then key == other.key || to_h == other.to_h
+        else super
+        end
+      end
+
+      def to_s
+        to_h.to_s
+      end
+
+      private
+
+      def prepare_hash(hash)
+        hash.each_with_object({}) do |(k, v), h|
+          h[k] = v && JSON.dump(v)
+        end
+      end
+    end
+  end
+end

data/lib/conflow/redis/identifier.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Conflow
+  module Redis
+    # Identifier changes logic of fields so that they can be found by an id.
+    # ID is a counter stored in redis under .counter_key
+    # Key is build with template stored in .key_template
+    module Identifier
+      # Extends base class with {ClassMethods}
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # class methods for classes with identifier
+      module ClassMethods
+        attr_writer :counter_key, :key_template
+
+        # Copies *counter_key* and *key_template* to child classes
+        def inherited(base)
+          base.instance_variable_set("@counter_key", counter_key)
+          base.instance_variable_set("@key_template", key_template)
+          super
+        end
+
+        # Redis key holding counter with IDs of model.
+        # @example default key
+        #   class My::Super::Class < Conflow::Redis::Field
+        #     include Conflow::Redis::Identifier
+        #   end
+        #
+        #   My::Super::Class.counter_key #=> "my:super:class:idcnt"
+        # @return [String] Redis key
+        def counter_key
+          @counter_key ||= [*name.downcase.split("::"), :idcnt].join(":")
+        end
+
+        # Template for building keys for fields using only the ID.
+        # @example default key
+        #   class My::Super::Class < Conflow::Redis::Field
+        #     include Conflow::Redis::Identifier
+        #   end
+        #
+        #   My::Super::Class.key_template #=> "my:super:class:%<id>d"
+        # @return [String] Template for building redis keys
+        def key_template
+          @key_template ||= [*name.downcase.split("::"), "%<id>d"].join(":")
+        end
+
+        # @return [Integer] next available ID
+        def generate_id
+          Conflow.redis.with { |conn| conn.incr(counter_key) }
+        end
+      end
+
+      # ID of the model
+      attr_reader :id
+
+      # Overrides logic of {Field#initialize}, allowing creating objects with ID instead of full key
+      # @param id [Integer] ID of the model
+      def initialize(id = self.class.generate_id)
+        @id = id.to_i
+        super(format(self.class.key_template, id: id))
+      end
+    end
+  end
+end

data/lib/conflow/redis/model.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Conflow
+  module Redis
+    # Models adds .field method which allows to define fields easily.
+    module Model
+      # Extends base class with .field and .has_many methods
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # - if other object is a {Model} as well, it compares keys
+      # - standard Ruby comparison otherwise
+      # @return [Boolean] true if other is the same model, false otherwise
+      def ==(other)
+        other.is_a?(Model) ? key == other.key : super
+      end
+
+      # Methods for defining fields on model
+      module ClassMethods
+        # Defines Redis field accessors.
+        # @param name [Symbol] name of the field
+        # @param type [:hash, :array, :value, :sorted_set] type of the new field
+        #
+        # @see Conflow::Redis::HashField
+        # @see Conflow::Redis::ArrayField
+        # @see Conflow::Redis::ValueField
+        # @see Conflow::Redis::SortedSetField
+        # @example
+        #   model_class.field :data, :hash
+        #   instance = model_class.new
+        #   instance.hash["something"] = 800
+        #   instance.hash = { something: "else"}
+        #   instance.hash["something"] #=> "else"
+        def field(name, type)
+          case type
+          when :hash       then FieldBuilder.new(name, Conflow::Redis::HashField).call(self)
+          when :array      then FieldBuilder.new(name, Conflow::Redis::ArrayField).call(self)
+          when :value      then FieldBuilder.new(name, Conflow::Redis::ValueField).call(self)
+          when :sorted_set then FieldBuilder.new(name, Conflow::Redis::SortedSetField).call(self)
+          else raise ArgumentError, "Unknown type: #{type}. Should be one of: [:hash, :array]"
+          end
+        end
+
+        # Convienience method for defining relation-like accessor.
+        # @example
+        #   has_many :jobs, Conflow::Job # defines #job_ids and #jobs
+        def has_many(name, klass, field_name: "#{name.to_s.chop}_ids")
+          field(field_name, :array)
+          define_method(name) { send(field_name).map { |id| klass.new(id) } }
+        end
+      end
+    end
+  end
+end

data/lib/conflow/redis/script.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Conflow
+  module Redis
+    # Main class for scripts, handling logic of executing and caching scripts.
+    class Script
+      class << self
+        # @return [Boolean] whether scripts are cached or not
+        attr_reader :cache_scripts
+        # @return [String] LUA script of this Conflow::Redis::Script
+        attr_reader :script
+
+        # Sets cache_scripts option on inherited scripts
+        def inherited(base)
+          scripts << base
+          base.cache_scripts = cache_scripts
+          super
+        end
+
+        # @!attribute [rw] cache_scripts
+        #   This options decides whether scripts used by the gem will be cached in Redis or not.
+        #   See {https://redis.io/commands/eval Redis EVAL} and {https://redis.io/commands/evalsha Redis EVALSHA}.
+        #   @example Disable caching scripts (set this in your initializer)
+        #     Conflow::Redis::Script.cache_scripts = false
+        def cache_scripts=(value)
+          @cache_scripts = value
+
+          @command = value ? :sha_eval : :eval
+          scripts.each { |script_class| script_class.cache_scripts = cache_scripts }
+        end
+
+        # Executes script in Redis with given arguments.
+        #
+        # @overload call(keys, args = [])
+        #   @param keys [Array<String>] Array of keys
+        #   @param args [Array<Object>] Array of arguments of the script
+        def call(*args)
+          Conflow.redis.with { |conn| send(command, conn, args) }
+        end
+
+        private
+
+        attr_reader :command, :sha
+
+        def script=(script)
+          @script = script
+          @sha = Digest::SHA1.hexdigest(script)
+        end
+
+        def scripts
+          @scripts ||= []
+        end
+
+        def sha_eval(redis, args)
+          redis.evalsha(sha, *args)
+        rescue ::Redis::CommandError => e
+          raise unless e.message == "NOSCRIPT No matching script. Please use EVAL."
+          redis.script(:load, script)
+          retry
+        end
+
+        def eval(redis, args)
+          redis.eval(script, *args)
+        end
+      end
+
+      self.cache_scripts = true
+    end
+  end
+end

data/lib/conflow/redis/sorted_set_field.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Conflow
+  module Redis
+    # Represents Redis sorted set. Closest Ruby representation is a Hash
+    # where keys are elements of the set and values represent score.
+    class SortedSetField < Field
+      # Adds one or more keys to the set.
+      # @param hash [Hash] hash of values and scores to be added
+      # @return [String] Redis response
+      #
+      # @example Adding multiple fields
+      #   field.add(last: 10, tied: 2, second: 4, first: 2)
+      def add(hash)
+        command :zadd, [key, hash_to_array(hash)]
+      end
+
+      # Access score of given element.
+      # @param value [String, Symbol] element of the set
+      # @return [String] Score of the element (nil if element not present in set)
+      #
+      # @example
+      #   field[:last] #=> 10
+      def [](value)
+        command :zscore, [key, value]
+      end
+
+      # Set score of given element.
+      # @param value [String, Symbol] element of the set
+      # @param rank [Numeric] score to be assigned
+      # @return [Integer] Number of added elements (1 if key didn't exist, 0 otherwise)
+      #
+      # @example
+      #   field[:last] = 24 #=> 0
+      def []=(value, rank)
+        command :zadd, [key, rank, value]
+      end
+
+      # Number of elements in the set
+      # @return [Integer] Size of the set
+      #
+      # @example
+      #   field.size #=> 4
+      def size
+        command :zcard, [key]
+      end
+
+      # Remove element from the set.
+      # @param value [String, Symbol] element of the set
+      # @return [Integer] Number of removed elements (1 if key existed, 0 otherwise)
+      #
+      # @example
+      #   field.delete(:last) #=> 1
+      def delete(value)
+        command :zrem, [key, value]
+      end
+
+      # Return elements with given score
+      # @param score [Numeric, Hash]
+      #   - when Numeric, only elements with that exact score will be returned
+      #   - when Hash, elements within min..max range will be returned. See {https://redis.io/commands/zrange Redis docs}
+      # @option score [String, Numeric] :min minimal score
+      # @option score [String, Numeric] :max maximal score
+      # @return [Array<String>] Elements with given score
+      #
+      # @example with specific score
+      #   field.where(score: 2) #=> ["first", "tie"]
+      # @example with only min set
+      #   field.where(score: { min: 3 }) #=> ["last", "second"]
+      # @example with both min and max set
+      #   field.where(score: { min: 3, max: "(10" }) #=> ["last"]
+      def where(score:)
+        command :zrangebyscore, [key, *prepare_score_bounds(score)]
+      end
+
+      # Removes elements of the set with given score and returns them.
+      # See {where} for details on how to choose score.
+      # @return [Array<String>] Elements with given score
+      def delete_if(score:)
+        score_bounds = prepare_score_bounds(score)
+
+        transaction do |conn|
+          conn.zrangebyscore key, *score_bounds
+          conn.zremrangebyscore key, *score_bounds
+        end[0]
+      end
+
+      # Returns first *n* elements of the sorted set
+      # @param num [Integer] amount of elements to be returned. Defaults to 1.
+      # @return [String, Array<String>] first *num* elements from the set
+      def first(num = 1)
+        result = command :zrange, [key, 0, num - 1]
+        num == 1 ? result[0] : result
+      end
+
+      # Returns last *n* elements of the sorted set
+      # @param num [Integer] amount of elements to be returned. Defaults to 1.
+      # @return [String, Array<String>] last *num* elements from the set
+      def last(num = 1)
+        result = command :zrevrange, [key, 0, num - 1]
+        num == 1 ? result[0] : result
+      end
+
+      # Creates regular Ruby Hash based on Redis values.
+      # @return [Hash] Hash representing this Sorted set
+      def to_h
+        Hash[command :zrange, [key, 0, -1, with_scores: true]]
+      end
+
+      # Removes old values from the set and overrides them with new.
+      # @param hash [Hash] new values of the set
+      # @return [String] Redis response
+      def overwrite(hash)
+        redis.with do |conn|
+          conn.pipelined do
+            conn.del(key)
+            conn.zadd(key, hash_to_array(hash))
+          end
+        end
+      end
+
+      private
+
+      def hash_to_array(hash)
+        ary = Array.new(hash.size * 2)
+
+        hash.each_with_object(ary).with_index do |((value, score), result), index|
+          result[index * 2] = score
+          result[index * 2 + 1] = value
+        end
+      end
+
+      def prepare_score_bounds(score)
+        case score
+        when Hash    then { min: "-inf", max: "+inf" }.merge(score).values
+        when Numeric then [score, score]
+        end
+      end
+    end
+  end
+end

data/lib/conflow/redis/value_field.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Conflow
+  module Redis
+    # Represents single value (Redis String). Values are serialized as JSON in order to preserve type.
+    class ValueField < Field
+      # @note *value* must be serializable through JSON.dump
+      # @param value [Object] new value to be saved
+      # @return [String] Redis response
+      def overwrite(value)
+        command :set, [key, JSON.dump(value)]
+      end
+
+      # @note *value* must be serializable through JSON.dump
+      # @param value [Object] value to be assigned to field (unless key already holds value)
+      # @return [String] Redis response
+      def default(value)
+        command :set, [key, JSON.dump(value), nx: true]
+      end
+
+      # @param other [Object] Object to compare value with. Handles Strings, Numerics,
+      #   Symbols and other {ValueField} objects
+      # @return [String] Redis response
+      def ==(other)
+        case other
+        when String, Numeric then value == other
+        when Symbol          then value.to_sym == other
+        when ValueField      then key == other.key || to_s == other.to_s
+        else super
+        end
+      end
+
+      # @return [Boolean] true if object does not exist in Redis, else otherwise
+      def nil?
+        value.nil?
+      end
+
+      # @return [String, nil] String representation of value
+      def to_s
+        value&.to_s
+      end; alias to_str to_s
+
+      # @return [Object] JSON-parsed value present in Redis
+      def value
+        result = command(:get, [key])
+        result && JSON.parse(result)
+      end
+    end
+  end
+end